https://www.rivadouce.fr/on/demandware.static/Sites-rivadouce-Site/-/fr_FR/v1790949690384/js/main.js
1/******/ (() => { // webpackBootstrap 2/******/ var __webpack_modules__ = ({ 3 4/***/ 9127: 5/***/ ((module) => { 6 7"use strict"; 8 9 10function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); } 11 12function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } 13 14function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) { ; } } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } } 15 16function _arrayWithHoles(r) { if (Array.isArray(r)) return r; } 17 18function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; } 19 20function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } } 21 22function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; } 23 24var listCitiesId = "list-cities"; 25var listAddressesId = "list-addresses"; 26var minPostalCodeChars = $($("[name$='country' i]")[0]).find("option").length > 1 ? 4 : 5; 27/** 28 * Replace "-" and "'" by space 29 * 30 * @param {string} field 31 * @returns 32 */ 33 34function sanitizeField(field) { 35 return field ? field.replace(/[-']/g, " ") : ""; 36} 37/** 38 * Remove existing datalist and clear input fields 39 * 40 * @param {string} listId 41 * @param {jQuery} $fields 42 */ 43 44 45function initDataList(listId, $fields) { 46 $("datalist#".concat(listId)).remove(); 47 48 if ($fields) { 49 $fields.val("").removeAttr("list"); 50 } 51} 52/** 53 * Create a datalist for suggestions 54 * 55 * @param {Array} items 56 * @param {jQuery} $field 57 * @param {string} listId 58 * @param {Function} formatter 59 * @returns {jQuery} 60 */ 61 62 63function createDataList(items, $field, listId, formatter) { 64 initDataList(listId); 65 var options = items.map(formatter).join(""); 66 var dataList = "<datalist id='".concat(listId, "'>").concat(options, "</datalist>"); 67 $field.attr("list", listId).after(dataList).focus(); 68 return $("datalist#".concat(listId)); 69} 70/** 71 * Initializes city auto-completion based on ZIP code input fields. 72 * 73 * This function sets up event listeners on ZIP code input fields to trigger 74 * AJAX requests for fetching city suggestions based on the entered ZIP code 75 * and selected country. It updates the corresponding city input fields with 76 * suggestions or directly fills them if only one city is returned. 77 * 78 * Preconditions: 79 * - The function requires the presence of specific input fields in the DOM: 80 * - ZIP code fields with IDs containing 'zipCode' (case-insensitive). 81 * - A hidden input field with the name 'getCitiesUrlName' containing the URL for city lookup.
82 * - City input fields with names ending in 'city' (case-insensitive). 83 * - A country selection field with a name ending in 'country' (case-insensitive). 84 * 85 * @returns {void} 86 */ 87 88 89function initCityCompletion() { 90 var $zipCodeFields = $("input[id*='zipCode' i]"); 91 var $getCitiesUrlName = $("input[name='getCitiesUrlName']"); 92 var $cityFields = $("input[name$='city' i]"); 93 var $country = $("[name$='country' i]"); 94 95 if (!$zipCodeFields.length || !$getCitiesUrlName.length || !$cityFields.length || !$country.length) { 96 return; 97 } 98 99 $cityFields.removeClass("input-validation"); 100 $zipCodeFields.off("input").on("input", function (event) { 101 var $this = $(this); 102 var $currentCityField = $this.parents("form").find("input[name$='city']"); 103 var index = $zipCodeFields.index($this); 104 $country = $this.closest("form").find("[name$='country']"); 105 106 if ($this.val().length < minPostalCodeChars) { 107 initDataList(listCitiesId + index, $currentCityField); 108 return; 109 } 110 111 if (event.originalEvent && (event.originalEvent.keyCode < 48 || event.originalEvent.keyCode > 57)) { 112 return; 113 } 114 115 $.ajax({ 116 url: $getCitiesUrlName.val(), 117 type: "get", 118 dataType: "json", 119 data: { 120 zipCode: $this.val(), 121 country: $country.val() 122 }, 123 success: function success(data) { 124 if (!data.success || !data.cities.length) { 125 return; 126 } 127 128 if (data.cities.length === 1) { 129 $currentCityField.val(data.cities[0].toUpperCase()); 130 return; 131 } 132 133 createDataList(data.cities, $currentCityField, listCitiesId + index, function (city) { 134 city = sanitizeField(city); 135 return "<option value='".concat(city, "'>").concat(city, "</option>"); 136 }); 137 }, 138 error: function error(err) { 139 console.log(err); 140 } 141 }); 142 }); 143 $cityFields.parents("form").on("submit", function () { 144 $cityFields.addClass("input-validation"); 145 }); 146} 147/** 148 * Initializes Google Places Autocomplete on address input fields. 149 * Adds real-time address suggestions and autofills postal code and city 150 * ONLY when user explicitly selects an address from the datalist. 151 */ 152 153 154function initAddressCompletion() { 155 var $addressFields = $("input[name*='_address1']"); 156 157 if (!$addressFields.length) { 158 return; 159 } 160 161 var sessionToken = new window.google.maps.places.AutocompleteSessionToken(); 162 var autocompleteService = new window.google.maps.places.AutocompleteService(); 163 var placesService = new window.google.maps.places.PlacesService(document.createElement("div")); 164 var lang = $("html").attr("lang") || "fr"; 165 var addressCache = new Map(); 166 var debounceTimer; 167 var DEBOUNCE_DELAY = 1000; 168 var MIN_CHARS = 7; 169 var pendingRequests = new Set(); // Tracking the last selected address to avoid unnecessary requests 170 171 var lastSelectedAddress = ""; 172 var lastInputTime = 0; 173 /** 174 * Retrieves a cache entry for the given key 175 * @param {string} key - The cache key to look up 176 * @returns {Object|null} The cached data or null if not found 177 */ 178 179 var getCacheEntry = function getCacheEntry(key) { 180 return addressCache.get(key) || null; 181 }; 182 /** 183 * Stores data in the cache with automatic size management 184 * @param {string} key - The cache key 185 * @param {Object} data - The data to store 186 */ 187 188 189 var setCacheEntry = function setCacheEntry(key, data) { 190 if (addressCache.size > 500) { 191 var oldestKey = addressCache.keys().next().value; 192 addressCache["delete"](oldestKey); 193 } 194 195 addressCache.set(key, data); 196 }; 197 /** 198 * Renders address predictions in a datalist and caches the results 199 * @param {jQuery} $field - The input field to attach predictions to 200 * @param {number} index - The field index 201 * @param {Array} predictions - Array of Google Places predictions 202 */ 203 204 205 var renderPredictions = function renderPredictions($field, index, predictions) { 206 var key = $field.val().trim().toLowerCase(); 207 setCacheEntry(key, { 208 predictions: predictions 209 }); 210 createDataList(predictions, $field, listAddressesId + index, function (place) { 211 return "<option value='".concat(sanitizeField(place.description), "'>").concat(sanitizeField(place.description), "</option>"); 212 }); 213 }; 214 /** 215 * Fetches address predictions from Google Places API with duplicate request prevention 216 * @param {jQuery} $field - The input field 217 * @param {number} index - The field index 218 * @param {string} inputValue - The value to search for 219 * @param {string} countryCode - The country code to restrict results 220 */ 221 222 223 var fetchPredictions = function fetchPredictions($field, index, inputValue, countryCode) { 224 var requestKey = "".concat(inputValue, "-").concat(countryCode); // Prevent duplicate concurrent requests 225 226 if (pendingRequests.has(requestKey)) { 227 return; 228 } 229 230 pendingRequests.add(requestKey); 231 autocompleteService.getPlacePredictions({ 232 input: inputValue, 233 sessionToken: sessionToken, 234 componentRestrictions: { 235 country: countryCode 236 }, 237 language: lang.toLowerCase(), 238 types: ["address"] 239 }, function (predictions, status) { 240 pendingRequests["delete"](requestKey); 241 242 if (status === window.google.maps.places.PlacesServiceStatus.OK) { 243 renderPredictions($field, index, predictions); 244 } 245 }); 246 }; 247 /** 248 * Processes place details and fills address fields with extracted data 249 * @param {jQuery} $field - The input field that triggered the request 250 * @param {Object} place - Google Places place object with details 251 * @param {string} key - Cache key for storing the result 252 */ 253 254 255 var handlePlaceDetails = function handlePlaceDetails($field, place, key) { 256 var addressData = { 257 address: place.name, 258 postal_code: getAddressComponent(place, "postal_code"), 259 city: getAddressComponent(place, "locality") 260 }; 261 setCacheEntry(key, { 262 details: addressData 263 }); 264 fillAddressFields($field, addressData); 265 $field.trigger("blur"); 266 sessionToken = new window.google.maps.places.AutocompleteSessionToken(); 267 }; 268 /** 269 * Fetches detailed place information from Google Places API 270 * @param {jQuery} $field - The input field 271 * @param {string} placeId - Google Places place ID 272 * @param {string} key - Cache key for storing the result 273 */ 274 275 276 var fetchPlaceDetails = function fetchPlaceDetails($field, placeId, key) { 277 // Prevent duplicate place detail requests 278 if (pendingRequests.has(placeId)) { 279 return; 280 } 281 282 pendingRequests.add(placeId); 283 placesService.getDetails({ 284 placeId: placeId, 285 sessionToken: sessionToken, 286 region: lang.toLowerCase(), 287 language: lang.toLowerCase(), 288 fields: ["address_components", "name"] 289 }, function (place, status) { 290 pendingRequests["delete"](placeId); 291 292 if (status === window.google.maps.places.PlacesServiceStatus.OK) { 293 handlePlaceDetails($field, place, key); 294 } 295 }); 296 }; 297 /** 298 * Checks if the entered value exactly matches an option in the datalist 299 * @param {jQuery} $field - Input field 300 * @param {string} inputValue - The entered value 301 * @returns {boolean} True if the value matches an option in the datalist 302 */ 303 304 305 var isValidDatalistSelection = function isValidDatalistSelection($field, inputValue) { 306 var index = $addressFields.index($field); 307 var $datalist = $("datalist#".concat(listAddressesId).concat(index)); 308 309 if (!$datalist.length) { 310 return false;
311 } 312 313 var normalizedInput = inputValue.trim().toLowerCase(); 314 var isValid = false; 315 $datalist.find("option").each(function () { 316 var optionValue = $(this).val().trim().toLowerCase(); 317 318 if (optionValue === normalizedInput) { 319 isValid = true; 320 return false; // break 321 } 322 }); 323 return isValid; 324 }; 325 /** 326 * Handles input events on address fields with intelligent caching and debouncing 327 * @param {Event} event - The input event 328 */ 329 330 331 var onAddressInput = function onAddressInput(event) { 332 var $field = $(event.currentTarget); 333 var index = $addressFields.index($field); 334 var inputValue = $field.val().trim(); 335 lastInputTime = Date.now(); 336 337 if (inputValue.toLowerCase() === lastSelectedAddress || inputValue.length < MIN_CHARS) { 338 return; 339 } 340 341 var $country = $field.closest("form").find("[name$='country']"); 342 var countryCode = $country.val().toLowerCase(); 343 clearTimeout(debounceTimer); 344 debounceTimer = setTimeout(function () { 345 // Check if user is still typing 346 if (Date.now() - lastInputTime < DEBOUNCE_DELAY / 2) { 347 return; 348 } 349 350 var cacheEntry = getCacheEntry(inputValue.toLowerCase()); 351 352 if (cacheEntry !== null && cacheEntry !== void 0 && cacheEntry.predictions) { 353 renderPredictions($field, index, cacheEntry.predictions); 354 return; 355 } // Prevent re-fetch if exact address is already in cached predictions 356 357 358 var _iterator = _createForOfIteratorHelper(addressCache), 359 _step; 360 361 try { 362 for (_iterator.s(); !(_step = _iterator.n()).done;) { 363 var _cachedData$predictio; 364 365 var _step$value = _slicedToArray(_step.value, 2), 366 cachedData = _step$value[1]; 367 368 var match = (_cachedData$predictio = cachedData.predictions) === null || _cachedData$predictio === void 0 ? void 0 : _cachedData$predictio.find(function (p) { 369 return p.description.toLowerCase() === inputValue.toLowerCase(); 370 }); 371 372 if (match) { 373 return; 374 } 375 } 376 } catch (err) { 377 _iterator.e(err); 378 } finally { 379 _iterator.f(); 380 } 381 382 fetchPredictions($field, index, inputValue, countryCode); 383 }, DEBOUNCE_DELAY); 384 }; 385 /** 386 * Handles address selection - ONLY fills fields if user selected from datalist 387 * @param {Event} event - The change event 388 */ 389 390 391 var onAddressChange = function onAddressChange(event) { 392 var $field = $(event.currentTarget); 393 var selectedValue = $field.val().trim(); 394 var key = selectedValue.toLowerCase(); // Check if this is a valid selection from the datalist 395 396 if (!isValidDatalistSelection($field, selectedValue)) { 397 // The user has not selected from the datalist 398 // We keep their entry without modifying the other fields 399 return; 400 } // This is a valid selection from the datalist 401 402 403 lastSelectedAddress = key; 404 var cacheEntry = getCacheEntry(key); 405 406 if (cacheEntry !== null && cacheEntry !== void 0 && cacheEntry.details) { 407 fillAddressFields($field, cacheEntry.details); 408 $field.trigger("blur"); 409 return; 410 } 411 412 var foundMatch = null; 413 414 var _iterator2 = _createForOfIteratorHelper(addressCache), 415 _step2; 416 417 try { 418 for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { 419 var _cachedData$predictio2; 420 421 var _step2$value = _slicedToArray(_step2.value, 2), 422 cachedData = _step2$value[1]; 423 424 foundMatch = (_cachedData$predictio2 = cachedData.predictions) === null || _cachedData$predictio2 === void 0 ? void 0 : _cachedData$predictio2.find(function (p) { 425 return p.description.toLowerCase() === key; 426 }); 427 428 if (foundMatch) { 429 break; 430 } 431 } 432 } catch (err) { 433 _iterator2.e(err); 434 } finally { 435 _iterator2.f(); 436 } 437 438 if (foundMatch) { 439 fetchPlaceDetails($field, foundMatch.place_id, key); 440 return; 441 } // Fallback: if the address is not found in the cache, a new search is made 442 443 444 var $country = $field.closest("form").find("[name$='country']"); 445 var countryCode = $country.val().toLowerCase(); 446 autocompleteService.getPlacePredictions({ 447 input: selectedValue, 448 sessionToken: sessionToken, 449 componentRestrictions: { 450 country: countryCode 451 }, 452 language: lang.toLowerCase(), 453 types: ["address"] 454 }, function (predictions, status) { 455 if (status === window.google.maps.places.PlacesServiceStatus.OK && predictions.length) { 456 setCacheEntry(key, { 457 predictions: predictions 458 }); 459 fetchPlaceDetails($field, predictions[0].place_id, key); 460 } 461 }); 462 }; 463 /** 464 * Adds validation class to address fields on form submission 465 */ 466 467 468 var onFormSubmit = function onFormSubmit() { 469 $addressFields.addClass("input-validation"); 470 }; 471 /** 472 * Cleans up timers and pending requests on page unload 473 */ 474 475 476 var cleanup = function cleanup() { 477 clearTimeout(debounceTimer); 478 pendingRequests.clear(); 479 }; 480 481 $addressFields.removeClass("input-validation"); 482 initMaxCharsForAddress1($addressFields); 483 $addressFields.off("input").on("input", onAddressInput); 484 $addressFields.off("change").on("change", onAddressChange); 485 $addressFields.on("focus", function () { 486 sessionToken = new window.google.maps.places.AutocompleteSessionToken(); 487 }); 488 $addressFields.parents("form").on("submit", onFormSubmit); 489 $(window).on("beforeunload", cleanup); 490} 491/** 492 * Retrieves a specific address component from Place Details. 493 */ 494 495 496function getAddressComponent(place, type) { 497 var component = place.address_components.find(function (comp) { 498 return comp.types.includes(type); 499 }); 500 return component ? component.long_name : ""; 501} 502/** 503 * Fill address fields with selected address data 504 * 505 * @param {jQuery} $addressField 506 * @param {Object} address 507 */ 508 509 510function fillAddressFields($addressField, address) { 511 if (!($addressField !== null && $addressField !== void 0 && $addressField.length) || !(address !== null && address !== void 0 && address.address) || !(address !== null && address !== void 0 && address.city)) { 512 return; 513 } 514 515 var $parentForm = $addressField.parents("form"); 516 517 if (!($parentForm !== null && $parentForm !== void 0 && $parentForm.length)) { 518 return; 519 } 520 521 var $zipCodeField = $parentForm.find("input[name$='postalCode']"); 522 523 if (!($zipCodeField !== null && $zipCodeField !== void 0 && $zipCodeField.length)) { 524 return; 525 } 526 527 var $cityField = $parentForm.find("input[name$='city']"); 528 529 if (!$cityField.length) { 530 return; 531 } 532 533 $addressField.val(address.address.toUpperCase()); 534 $zipCodeField.val(address.postal_code); 535 $cityField.val(address.city.toUpperCase()); 536} 537/** 538 * Initializes the maximum character limit for the "address1" field in a form, and manages overflow to "address2". 539 * 540 * This function modifies the behavior of address input fields within forms by removing the "maxlength" attribute 541 * from the "address1" field and handling character overflow to the "address2" field upon form submission. 542 * 543 * @param {jQuery} $addressFields - A jQuery object representing the address input fields to be initialized. 544 * 545 * The function performs the following steps: 546 * 1. Checks if the provided `$addressFields` is valid and contains elements. If not, it exits early. 547 * 2. Identifies the parent forms of the address fields. If no forms are found, it exits early. 548 * 3. Retrieves the maximum character limit from the "maxlength" attribute of the address fields. 549 * If no valid maximum character limit is found, it exits early. 550 * 4. Removes the "maxlength" attribute from the address fields to allow unrestricted input. 551 * 5. Defines an `onSubmitForm` function to handle form submission: 552 * - Prevents the default form submission behavior. 553 * - Checks the length of the "address1" field's value. If it exceeds the maximum character limit, 554 * it transfers the excess characters to the "address2" field. 555 * - Triggers the form's submit event. 556 * 6. Attaches the `onSubmitForm` function to the click event of the form's submit buttons, ensuring 557 * that the function is executed when the form is submitted. 558 */ 559 560 561function initMaxCharsForAddress1($addressFields) { 562 if (!($addressFields !== null && $addressFields !== void 0 && $addressFields.length)) { 563 return; 564 } 565 566 var $parentForms = $addressFields.parents("form"); 567 568 if (!($parentForms !== null && $parentForms !== void 0 && $parentForms.length)) { 569 return; 570 } 571 572 var maxChars = +$addressFields.attr("maxlength"); 573 574 if (!maxChars) { 575 return; 576 } 577 578 $addressFields.removeAttr("maxlength"); 579 /** 580 * On submit form with address1 and address2 581 */ 582
583 var onSubmitForm = function onSubmitForm() { 584 var $this = $(this); 585 var $form = $this.parents("form"); 586 var $currentAddress1Field = $form.find("input[name*='_address1']"); 587 var $currentAddress2Field = $form.find("input[name*='_address2']"); 588 589 if ($currentAddress1Field.length && $currentAddress2Field.length && $currentAddress1Field.val().length > maxChars) { 590 var excess = $currentAddress1Field.val().slice(maxChars); 591 $currentAddress1Field.val($currentAddress1Field.val().slice(0, maxChars)); 592 593 if (excess !== $currentAddress2Field.val()) { 594 $currentAddress2Field.val(excess + " " + ($currentAddress2Field.val() || "")); 595 } else { 596 $currentAddress2Field.val($currentAddress2Field.val() || ""); 597 } 598 } 599 }; 600 601 $parentForms.find("[type='submit']").off("click", onSubmitForm).on("click", onSubmitForm); 602} 603/** 604 * Dynamically loads the Google Maps API with Places library if needed. 605 * Checks for existing address fields and ensures the API is loaded only once. 606 * Triggers the callback once the API is ready. 607 * 608 * @param {Function} callback - Function to execute after API is loaded. 609 * @returns {void} Returns early if no address fields or API key is found. 610 */ 611 612 613function loadGoogleMapsAPI(callback) { 614 var _window$google; 615 616 var $addressFields = $("input[name*='_address1']"); 617 618 if (!$addressFields.length) { 619 return; 620 } 621 622 var $placeApk = $("#PLACE_APK"); 623 624 if (!$placeApk.length) { 625 return; 626 } 627 628 if ((_window$google = window.google) !== null && _window$google !== void 0 && _window$google.maps) { 629 callback(); 630 return; 631 } 632 633 var script = document.createElement("script"); 634 script.src = "https://maps.googleapis.com/maps/api/js?key=" + $placeApk.val() + "&libraries=places"; 635 script.async = true; 636 script.defer = true; 637 script.onload = callback; 638 document.head.appendChild(script); 639} 640/** 641 * initialize city and address completion 642 */ 643 644 645function init() { 646 initCityCompletion(); // Load Google Maps before initiating autocomplete 647 648 loadGoogleMapsAPI(function () { 649 initAddressCompletion(); 650 }); 651} 652 653module.exports = { 654 init: init 655}; 656 657/***/ }), 658 659/***/ 5790: 660/***/ (() => { 661 662/** 663 * Initializes toggle eye icons for password input fields. 664 * 665 * This function searches for all input fields of type "password" on the page and appends a toggle button 666 * (with an eye icon) to enable or disable password visibility. 667 * 668 * - When the toggle button is clicked, it toggles the input type between "password" and "text". 669 * - The icon changes between "eye" (to show the password) and "eye with a line" (to hide the password). 670 * - The toggle button only appears if the password input field contains text. 671 * 672 * Usage: 673 * Call this function after the DOM is fully loaded to apply the behavior to all password fields on the page. 674 */ 675function initEyeIconForPasswordFields() { 676 var $passwordInput = $("input[type='password']"); 677 678 if (!$passwordInput.length) { 679 return; 680 } 681 682 var iconReveal = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"black\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" width=\"18\" height=\"18\">\n <path d=\"M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z\"></path>\n <circle cx=\"12\" cy=\"12\" r=\"3\"></circle>\n </svg>"; 683 var iconHide = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"black\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" width=\"18\" height=\"18\">\n <path d=\"M17.94 17.94A10.94 10.94 0 0 1 12 20C5 20 1 12 1 12a16.3 16.3 0 0 1 3.16-4.87\"></path>\n <path d=\"M22.54 10.88A16.88 16.88 0 0 0 19 6.52M1 1l22 22\"></path>\n </svg>"; 684 var $toggleButton = $("<span class='icon-eye'>").html(iconReveal); 685 $passwordInput.addClass("with-eye-icon").after($toggleButton); 686 $("span.icon-eye").each(function () { 687 var $currentToggleButton = $(this); 688 $currentToggleButton.off("click").on("click", function () { 689 var $currentPasswordInput = $currentToggleButton.siblings("input"); 690 var currentType = $currentPasswordInput.attr("type"); 691 var isPasswordVisible = currentType === "text"; 692 $currentPasswordInput.attr("type", isPasswordVisible ? "password" : "text"); 693 $currentToggleButton.html(isPasswordVisible ? iconReveal : iconHide); 694 }); 695 }); 696 $passwordInput.each(function () { 697 var $currentPasswordInput = $(this); 698 $currentPasswordInput.off("input").on("input", function () { 699 var $currentToggleButton = $currentPasswordInput.siblings("span.icon-eye"); 700 701 if ($currentPasswordInput.val()) { 702 $currentToggleButton.show(); 703 } else { 704 $currentToggleButton.hide(); 705 } 706 }); 707 }); 708 $passwordInput.trigger("input"); 709} 710 711$(function () { 712 initEyeIconForPasswordFields(); 713}); 714 715/***/ }), 716 717/***/ 5956: 718/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 719 720var utils = __webpack_require__(4443); 721/** 722 * Initializes the header banner by setting up event listeners and managing its visibility based on session storage. 723 * 724 * This function performs the following actions: 725 * 1. Selects the header banner element using jQuery. 726 * 2. Checks if the header banner element exists; if not, the function exits early. 727 * 3. Attaches a click event listener to the close button within the header banner to hide the banner and store the hide status in session storage. 728 * 4. Retrieves the header banner visibility status from session storage and adjusts the banner's visibility accordingly. 729 */ 730 731 732function initHeaderBanner() { 733 var $headerBanner = $(".header-banner"); 734 735 if (!$headerBanner || !$headerBanner.length) { 736 return; 737 } 738 739 $headerBanner.find(".close").off("click").on("click", function () { 740 $headerBanner.addClass("d-none"); 741 window.sessionStorage.setItem("hide_header_banner", "1");
742 $("body").trigger("after:close:header-banner"); 743 }); 744 var headerBannerStatus = window.sessionStorage.getItem("hide_header_banner"); 745 746 if (!headerBannerStatus || headerBannerStatus < 0) { 747 $headerBanner.removeClass("d-none"); 748 } else if (+headerBannerStatus === 1) { 749 $headerBanner.addClass("d-none"); 750 } 751} 752/** 753 * Initializes the header banner slider for promotional messages. 754 * This function sets up an animation that cycles through the list items 755 * within the header promotion section. 756 * 757 * On desktop: vertical animation (bottom to top) 758 * On mobile: horizontal marquee animation (right to left) with pause in center 759 * 760 * @returns {void} 761 */ 762 763 764function initHeaderBannerSlider() { 765 var $headerPromotion = $(".header-promotion"); 766 767 if (!$headerPromotion.length) { 768 return; 769 } 770 771 var $list = $headerPromotion.find("ul"); 772 773 if (!$list.length) { 774 return; 775 } 776 777 var $sentences = $list.find("li"); 778 779 if ($sentences.length < 2) { 780 return; 781 } 782 783 var pauseDelay = 4000; // 4 seconds delay 784 785 var timeoutId = null; 786 var currentIndex = 0; 787 788 var animateVertical = function animateVertical() { 789 // same value for top as scss variable $heightHeaderPromotion 790 $list.animate({ 791 top: "-=32px" 792 }, 500, function () { 793 $list.append($list.children().first()); 794 $list.css("top", 0); 795 clearTimeout(timeoutId); 796 timeoutId = setTimeout(animateVertical, pauseDelay); 797 }); 798 }; 799 800 var animateHorizontal = function animateHorizontal() { 801 var animationSpeed = 2000; 802 var $currentItem = $($sentences[currentIndex]); 803 var containerWidth = $headerPromotion.width(); // Start position : completely right (off screen) 804 805 var startPosition = containerWidth; // Center position 806 807 var centerPosition = 0; // End position: completely left (off-screen) 808 809 var endPosition = $currentItem.outerWidth(); // Place the element on the right, off-screen 810 811 $currentItem.css({ 812 left: startPosition + "px", 813 position: "absolute", 814 "white-space": "nowrap" 815 }); // Animate from right to center 816 817 $currentItem.animate({ 818 left: centerPosition + "px" 819 }, animationSpeed, "linear", function () { 820 return onReachCenter($currentItem, endPosition, animationSpeed); 821 }); 822 }; // Pause in the center 823 824 825 var onReachCenter = function onReachCenter($currentItem, endPosition, animationSpeed) { 826 clearTimeout(timeoutId); 827 $currentItem.css({ 828 "white-space": "inherit" 829 }); 830 timeoutId = setTimeout(function () { 831 return onPauseComplete($currentItem, endPosition, animationSpeed); 832 }, pauseDelay); 833 }; // Continue the animation from the center to the left (off-screen) 834 835 836 var onPauseComplete = function onPauseComplete($currentItem, endPosition, animationSpeed) { 837 $currentItem.animate({ 838 left: -endPosition + "px" 839 }, animationSpeed, "linear", onAnimationComplete); 840 }; // Move on to the next item 841 842 843 var onAnimationComplete = function onAnimationComplete() { 844 currentIndex = (currentIndex + 1) % $sentences.length; 845 animateHorizontal(); 846 }; // Initialization according to the device 847 848 849 if (utils.isMobile()) { 850 // Hide all elements initially 851 $sentences.css({ 852 position: "absolute", 853 left: "-9999px" 854 }); 855 animateHorizontal(); 856 } else { 857 $sentences.css({ 858 position: "static" 859 }); 860 setTimeout(animateVertical, pauseDelay); 861 } 862 863 var resizeTimer; 864 $(window).on("resize", function () { 865 clearTimeout(resizeTimer); 866 clearTimeout(timeoutId); 867 resizeTimer = setTimeout(function () { 868 $sentences.stop(true, true); 869 870 if (utils.isMobile()) { 871 currentIndex = 0; 872 $sentences.css({ 873 position: "absolute", 874 left: "-9999px" 875 }); 876 animateHorizontal(); 877 } else { 878 $sentences.css({ 879 position: "static", 880 left: "auto" 881 }); 882 $list.css({ 883 top: 0 884 }); 885 setTimeout(animateVertical, pauseDelay); 886 } 887 }, 250); 888 }); 889} 890/** 891 * Initializes the header banner and its slider. 892 * This function sets up the necessary components for displaying and interacting with the header banner. 893 */ 894 895
896function init() { 897 initHeaderBanner(); 898 initHeaderBannerSlider(); 899} 900 901module.exports = { 902 init: init 903}; 904 905/***/ }), 906 907/***/ 7186: 908/***/ ((module) => { 909 910"use strict"; 911 912/** 913 * Update Number of products with m3GroupeArticle type "DOCUMENTS" in cart 914 * 915 * @param {array} items of cart 916 */ 917 918function updateNbDocumentsInCart(items) { 919 if (!items || !items.length) { 920 items = []; 921 } 922 923 var nbDocumentsInCart = 0; 924 925 for (var i = 0, ln = items.length; i < ln; i++) { 926 if (typeof items[i].m3GroupeArticle !== "undefined" && items[i].m3GroupeArticle === "DOCUMENTS") { 927 nbDocumentsInCart++; 928 } 929 } 930 931 var $nbDocumentsInCart = $("#nbDocumentsInCart"); 932 933 if (!$nbDocumentsInCart || !$nbDocumentsInCart.length) { 934 return; 935 } 936 937 $nbDocumentsInCart.val(nbDocumentsInCart); 938} 939/** 940 * Bind event when cart update qty 941 */ 942 943 944function onCartUpdateQty() { 945 $("body").on("product:onCartUpdateQty", function (e, items) { 946 updateNbDocumentsInCart(items); 947 }); 948} 949/** 950 * Initialization of miniCart events 951 */ 952 953 954function initEvents() { 955 onCartUpdateQty(); 956} 957/** 958 * Initialization 959 */ 960 961 962function init() { 963 initEvents(); 964} 965 966module.exports = { 967 init: init 968}; 969 970/***/ }), 971 972/***/ 3307: 973/***/ ((module) => { 974 975/** 976 * Displays a feedback message for 4 seconds. 977 * Shows error styling for error/unsuccessful responses. 978 * Automatically clears the message and styling after display. 979 * 980 * @param {Object} data - Response data object 981 * @param {string} data.msg - Message text to display 982 * @param {boolean} data.error - Error flag (true for error styling) 983 * @param {boolean} data.success - Success flag (false triggers error styling) 984 * @param {jQuery} $feedbackMsg - jQuery element where message will be displayed 985 */ 986function displayMessage(data, $feedbackMsg) { 987 $.spinner().stop(); 988 989 if (!data || !$feedbackMsg.length) { 990 return; 991 } 992 993 if (data.error === true || !data.success) { 994 $feedbackMsg.addClass("input-error"); 995 } 996 997 $feedbackMsg.text(data.msg); 998 setTimeout(function () { 999 $feedbackMsg.text(""); 1000 $feedbackMsg.removeClass("input-error"); 1001 }, 4000); 1002} 1003 1004var $newsletterModal = $("#newsletter-modal"); 1005var newsletterModalClosed = window.localStorage.getItem("newsletterWasClosed"); 1006var startTime = 30; 1007var remainingTime = 0; 1008var timerInterval = setInterval(timeLeft, 1000); 1009/** 1010 * shows countdown of time to modal reveal in session storage 1011 **/ 1012 1013function timeLeft() { 1014 remainingTime = localStorage.getItem("startTime"); 1015 1016 if (remainingTime > 1 || remainingTime != null) { 1017 localStorage.setItem("startTime", remainingTime - 1); 1018 } 1019} 1020/** 1021 * show newsletter after time finished and if newsletter modal wasn`t closed before 1022 * @param {number} time - time for newsletter to be shown 1023 */ 1024 1025 1026function startTimer(time) { 1027 if (newsletterModalClosed !== "true") { 1028 setTimeout(function () { 1029 localStorage.removeItem("startTime"); 1030 clearInterval(timerInterval); 1031 $newsletterModal.modal("show"); 1032 }, time * 1000); 1033 localStorage.setItem("startTime", time); 1034 } 1035} 1036/** 1037 * Appends key-value pair to a url 1038 * @param {string} url - Original url 1039 * @param {string} key - key to append 1040 * @param {string} value - value to append 1041 * @returns {string|null} result url with appended parameters or null if url does not exist 1042 */ 1043 1044 1045function appendToUrl(url, key, value) { 1046 if (!url) { 1047 return null; 1048 } 1049 1050 var newUrl = url; 1051 newUrl += (newUrl.indexOf("?") !== -1 ? "&" : "?") + key + "=" + value; 1052 return newUrl; 1053} 1054 1055module.exports = { 1056 init: function init() { 1057 var isRegistered = $newsletterModal.data("is-registered"); 1058 var isSubscribed = $newsletterModal.data("is-unsubscribed"); 1059 var newsletterUrl = appendToUrl($newsletterModal.data("url"), "currentUrl", window.location.href); 1060 1061 if (newsletterUrl) { 1062 $.ajax({ 1063 url: newsletterUrl, 1064 type: "get", 1065 success: function success(data) { 1066 // show newsletter modal for unregistered users and registered not subscribed 1067 if (data && data.isEnabled && (!isRegistered || isRegistered && !isSubscribed)) { 1068 // use variable if user is on the first page 1069 if (!localStorage.getItem("startTime")) { 1070 startTimer(startTime); 1071 } else { 1072 // use data with remaining time from session storage if user navigates to next page or refreshes the page 1073 startTimer(localStorage.getItem("startTime")); 1074 } 1075 } 1076 }, 1077 error: function error() {} 1078 }); 1079 } 1080 1081 $("body").on("hidden.bs.modal", "#newsletter-modal", function () { 1082 $newsletterModal.modal("hide"); 1083 window.localStorage.setItem("newsletterWasClosed", "true"); 1084 }); 1085 }, 1086 newsletter: function newsletter() { 1087 $(".newsletter-modal-form").on("submit", function (event) { 1088 event.preventDefault(); 1089 var $this = $(this); 1090 var url = $this.attr("action"); 1091 var emailId = $("#newsletter-form-email").val(); 1092 $.spinner().start(); 1093 $this.attr("disabled", true); 1094 $.ajax({ 1095 url: url, 1096 type: "post", 1097 dataType: "json", 1098 data: { 1099 emailId: emailId 1100 }, 1101 success: function success(response) { 1102 $.spinner().stop(); 1103 displayMessage(response, $this.find(".newsletter-feedback")); 1104 }, 1105 error: function error(err) { 1106 $.spinner().stop(); 1107 displayMessage(err, $this.find(".newsletter-feedback")); 1108 } 1109 }); 1110 }); 1111 } 1112}; 1113 1114/***/ }), 1115 1116/***/ 115: 1117/***/ (() => { 1118 1119"use strict"; 1120 1121/** 1122 * Handles scrolling to the last viewed product on a PLP (Product Listing Page) when using browser back button. 1123 * 1124 * This function: 1125 * 1. Saves the clicked product ID to session storage when a product is clicked 1126 * 2. Detects when user returns to the PLP using browser back button 1127 * 3. Automatically scrolls to the last viewed product 1128 * 4. Handles lazy loading of images and "Show More" functionality 1129 * 5. Supports products from recommendation carousels 1130 * 1131 * @return {void} 1132 */ 1133 1134function initScrollPLP() { 1135 var isPLP = $(".page[data-action='Search-Show']").length; 1136 1137 if (!isPLP) { 1138 return; 1139 } 1140 1141 var addProductIdToSessionStorage = function addProductIdToSessionStorage() { 1142 sessionStorage.setItem("lastProductClickedPLP", JSON.stringify({ 1143 pid: $(this).closest(".grid-tile").attr("data-pid"), 1144 fromReco: !!$(this).closest("#recommender-slider").length 1145 })); 1146 }; 1147
1148 $(document).off("click", ".grid-tile a", addProductIdToSessionStorage).on("click", ".grid-tile a", addProductIdToSessionStorage); 1149 1150 var loadLazyImages = function loadLazyImages(pid) { 1151 var cb = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 1152 $(".grid-tile img.lazyload").each(function () { 1153 if ($(this).closest(".grid-tile").attr("data-pid") == pid) { 1154 if (cb) { 1155 cb(); 1156 } 1157 1158 return false; 1159 } 1160 1161 var img = this; 1162 var originalSrc = img.dataset.src || img.getAttribute("data-src") || img.src; 1163 img.removeAttribute("loading"); 1164 1165 if (originalSrc && img.src !== originalSrc) { 1166 img.src = originalSrc; 1167 } 1168 }); 1169 1170 if (cb) { 1171 cb(); 1172 } 1173 }; 1174 1175 var scrollToProduct = function scrollToProduct(pid) { 1176 var scrollPosition = +$(".grid-tile[data-pid=\"".concat(pid, "\"]")).offset().top - +$("header").height() - 45; 1177 window.scrollTo({ 1178 top: scrollPosition 1179 }); 1180 sessionStorage.removeItem("lastProductClickedPLP"); 1181 setTimeout(function () { 1182 return $.spinner().stop(); 1183 }, 200); 1184 }; 1185 1186 var findProduct = function findProduct(event) { 1187 var lastProductClickedPLP = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 1188 1189 if (lastProductClickedPLP.fromReco) { 1190 var scrollHandler = function scrollHandler() { 1191 scrollToProduct(lastProductClickedPLP.pid); 1192 }; 1193 1194 $("body").off("recommender:slider:loaded", scrollHandler).one("recommender:slider:loaded", scrollHandler); 1195 } else if ($(".grid-tile[data-pid=\"".concat(lastProductClickedPLP.pid, "\"]")).length) { 1196 loadLazyImages(lastProductClickedPLP.pid, function () { 1197 setTimeout(function () { 1198 scrollToProduct(lastProductClickedPLP.pid); 1199 }, 800); 1200 }); 1201 } else { 1202 var $showMoreButton = $(".show-more button"); 1203 1204 if ($showMoreButton.length) { 1205 $showMoreButton.trigger("click"); 1206 1207 var findProductHandler = function findProductHandler(e) { 1208 $.spinner().start(); 1209 findProduct(e, lastProductClickedPLP); 1210 }; 1211 1212 $("body").off("search:after:showMore:plp", findProductHandler).one("search:after:showMore:plp", findProductHandler); 1213 } else { 1214 sessionStorage.removeItem("lastProductClickedPLP"); 1215 $.spinner().stop(); 1216 } 1217 } 1218 }; 1219 1220 $(function () { 1221 var _performance$getEntri; 1222 1223 var usedBackButton = ((_performance$getEntri = performance.getEntriesByType("navigation")[0]) === null || _performance$getEntri === void 0 ? void 0 : _performance$getEntri.type) === "back_forward"; 1224 1225 if (!usedBackButton) { 1226 sessionStorage.removeItem("lastProductClickedPLP"); 1227 return; 1228 } 1229 1230 var lastProductClickedPLP = sessionStorage.getItem("lastProductClickedPLP"); 1231 1232 if (!lastProductClickedPLP) { 1233 return; 1234 } 1235 1236 $.spinner().start(); 1237 findProduct(null, JSON.parse(lastProductClickedPLP)); 1238 }); 1239} 1240 1241$(function () { 1242 initScrollPLP(); 1243}); 1244 1245/***/ }), 1246 1247/***/ 8558: 1248/***/ (() => { 1249 1250var $current; 1251/** 1252 * Show a spinner inside a given element 1253 * @param {element} $target - Element to block by the veil and spinner. 1254 * Pass body to block the whole page. 1255 */ 1256 1257function addSpinner($target) { 1258 // Don't stack spinners, if one spinner exists don't create another 1259 if (!$current) { 1260 var $spinnerHtml = $($("#spinner").html()); 1261 $spinnerHtml.attr("id", "spinnerInstance"); 1262 $target.append($spinnerHtml).find(".loader-component").addClass("loading"); 1263 $target.addClass("disable-spinner-target"); 1264 $target.is("body") ? $target.find(".loader-overlay").removeClass("position-fixed position-absolute").addClass("position-fixed") : $target.find(".loader-overlay").removeClass("position-fixed position-absolute").addClass("position-absolute"); 1265 $current = $target; 1266 } 1267} 1268/** 1269 * Remove existing spinner 1270 * @param {element} $veil - jQuery pointer to the veil element 1271 */ 1272 1273 1274function removeSpinner() { 1275 if ($current) { 1276 $current.removeClass("disable-spinner-target"); 1277 $("#spinnerInstance").remove(); 1278 $current = null; 1279 } 1280} // element level spinner: 1281 1282 1283$.fn.spinner = function () { 1284 var $element = $(this); 1285 1286 var Fn = function Fn() { 1287 this.start = function () { 1288 if ($element.length) { 1289 addSpinner($element); 1290 } 1291 }; 1292 1293 this.stop = function () { 1294 removeSpinner(); 1295 }; 1296 }; 1297 1298 return new Fn(); 1299}; // page-level spinner: 1300 1301 1302$.spinner = function () { 1303 var Fn = function Fn() { 1304 this.start = function () { 1305 addSpinner($("body")); 1306 }; 1307 1308 this.stop = function () { 1309 removeSpinner(); 1310 }; 1311 }; 1312 1313 return new Fn(); 1314}; 1315 1316/***/ }), 1317 1318/***/ 1917: 1319/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 1320 1321window.jQuery = __webpack_require__(4540); 1322window.$ = __webpack_require__(4540); 1323 1324(__webpack_require__(5956).init)(); 1325 1326(__webpack_require__(9127).init)(); 1327 1328(__webpack_require__(7186).init)(); 1329 1330__webpack_require__(5790); 1331 1332(__webpack_require__(4443).processFormFieldError)(); 1333 1334__webpack_require__(115); 1335 1336/***/ }), 1337 1338/***/ 4443: 1339/***/ ((module) => { 1340 1341"use strict"; 1342 1343/** 1344 * Creates a debounced function that delays invoking the provided function until after wait milliseconds have elapsed 1345 * since the last time the debounced function was invoked. 1346 * 1347 * @param {Function} func - The function to debounce. 1348 * @param {number} wait - The number of milliseconds to delay. 1349 * @returns {Function} - The debounced function. 1350 */ 1351 1352function debounce(func, wait) { 1353 var timeout; 1354 return function () { 1355 var context = this, 1356 args = arguments; 1357 clearTimeout(timeout); 1358 timeout = setTimeout(function () {
1359 return func.apply(context, args); 1360 }, wait); 1361 }; 1362} 1363/** 1364 * Display correct cart qty, take into account if there is DOCUMENTS product in cart 1365 * 1366 * @param {number} initialQty 1367 * @returns {number} total 1368 */ 1369 1370 1371function displayCartQty(initialQty) { 1372 var $nbDocumentsInCart = $("#nbDocumentsInCart"); 1373 1374 if (!$nbDocumentsInCart.length) { 1375 return initialQty; 1376 } 1377 1378 var nbDocumentsInCart = +$nbDocumentsInCart.val(); 1379 return initialQty - (nbDocumentsInCart > 0 ? nbDocumentsInCart : 0); 1380} 1381/** 1382 * Return is mobile or not 1383 * 1384 * @returns {boolean} is mobile or not 1385 */ 1386 1387 1388function isMobile() { 1389 return ["Android", "webOS", "iPhone", "iPad", "iPod", "BlackBerry", "Windows Phone"].some(function (keyword) { 1390 return navigator.userAgent.includes(keyword); 1391 }); 1392} 1393/** 1394 * Smoothly scrolls to a specified anchor on the page with an optional offset. 1395 * 1396 * @param {string} anchorName - The hash name of the anchor (e.g., "#section"). 1397 * @param {string} [anchorSelector] - The CSS selector of the anchor (defaults to the anchorName). 1398 * @param {number} [offset=0] - The vertical offset in pixels to apply to the scroll position. 1399 */ 1400 1401 1402function goToAnchor(anchorName, anchorSelector) { 1403 var offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; 1404 1405 if (!anchorName) { 1406 return; 1407 } 1408 1409 anchorSelector = anchorSelector || anchorName; 1410 1411 if (window.location.hash === anchorName) { 1412 goToElement(anchorSelector, offset); 1413 } 1414} 1415/** 1416 * Smoothly scrolls to a specified element. 1417 * 1418 * @param {string|HTMLElement|jQuery} elementOrSelector - The element or selector to scroll to. 1419 * @param {number} [offset=0] - Offset from the target position. 1420 * @param {Function} [cb=null] - Callback function to execute after scrolling. 1421 */ 1422 1423 1424function goToElement(elementOrSelector) { 1425 var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 1426 var cb = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; 1427 var anchor; 1428 1429 if (typeof elementOrSelector === "string") { 1430 anchor = document.querySelector(elementOrSelector); 1431 } else if (elementOrSelector instanceof jQuery) { 1432 anchor = elementOrSelector[0]; 1433 } else { 1434 anchor = elementOrSelector; 1435 } 1436 1437 if (!anchor) { 1438 return; 1439 } 1440 1441 var anchorPosition = anchor.getBoundingClientRect().top + window.scrollY; 1442 window.scrollTo({ 1443 top: anchorPosition - offset, 1444 behavior: "smooth" 1445 }); 1446 1447 if (typeof cb === "function") { 1448 cb(); 1449 } 1450} 1451/* Toggles the state of a button (enable or disable) and updates its styling. 1452 * 1453 * @param object $btn jQuery object representing the button to be modified. 1454 * @param string $action Action to perform on the button: 1455 * - "disable" (default): Disables the button and changes its background color to grey. 1456 * - Any other value: Enables the button and restores its default background color. 1457 * 1458 * @return void Exits if the button object is empty. 1459 */ 1460 1461 1462function activationBtn($btn) { 1463 var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "disable"; 1464 1465 if (!$btn.length) { 1466 return; 1467 } 1468 1469 if (action == "disable") { 1470 $btn.prop("disabled", true).addClass("disableBtn"); 1471 } else { 1472 $btn.prop("disabled", false).removeClass("disableBtn"); 1473 } 1474} 1475/** 1476 * Scrolls the page to the first element with a validation error. 1477 * @param {Event} [event=null] - Optional event to prevent (e.g. form submit). 1478 * @param {jQuery} [$form=null] - jQuery form containing errors (searches entire document if null). 1479 * @param {number} [timer=1000] - Delay in ms before focusing the errored element. 1480 */ 1481 1482 1483function scrollToError() { 1484 var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; 1485 var $form = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 1486 var timer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000; 1487 var $firstElmt = $form ? $form.find(".is-invalid").first() : $(".is-invalid").first(); 1488 1489 if (!$firstElmt.length) { 1490 return; 1491 } 1492 1493 if (event) { 1494 event.preventDefault(); 1495 } 1496 1497 goToElement($firstElmt.closest("div"), $("header").height() + 15, function () { 1498 setTimeout(function () { 1499 $firstElmt.trigger("focus"); 1500 }, timer); 1501 }); 1502} 1503/** 1504 * Sets up form error handling by adding an event handler to submit buttons. 1505 * Scrolls to the first error after submission. Uses scrollToError() with a short 1506 * delay (200ms) to allow validation to complete. 1507 */ 1508 1509
1510function processFormFieldError() { 1511 var goToAfterSubmit = function goToAfterSubmit(event) { 1512 setTimeout(function () { 1513 scrollToError(event); 1514 }, 200); 1515 }; 1516 1517 $(function () { 1518 $("form [type='submit']").off("click", goToAfterSubmit).on("click", goToAfterSubmit); 1519 }); 1520} 1521/** 1522 * Throttles a function to run at most once every `limit` milliseconds. 1523 * 1524 * @param {Function} func - The function to throttle. 1525 * @param {number} limit - The time limit in ms. 1526 * @returns {Function} - A throttled version of the function. 1527 */ 1528 1529 1530function throttle(func, limit) { 1531 var lastCall = 0; 1532 return function () { 1533 var now = Date.now(); 1534 1535 if (now - lastCall >= limit) { 1536 lastCall = now; 1537 1538 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 1539 args[_key] = arguments[_key]; 1540 } 1541 1542 func.apply(this, args); 1543 } 1544 }; 1545} 1546/** 1547 * Return true only if browser is safari 1548 * 1549 * @returns {boolean} res 1550 */ 1551 1552 1553function isSafari() { 1554 var ua = navigator.userAgent || ""; 1555 return /Safari/.test(ua) && !/Chrome|CriOS|Chromium|Android/.test(ua); 1556} 1557/** 1558 * Get Boolean value from string "true" / "false" or Boolean 1559 * 1560 * @param {Boolean|String} val 1561 * @returns {Boolean} res 1562 */ 1563 1564 1565function getBoolean(val) { 1566 return typeof val === "boolean" ? val : String(val).trim().toLowerCase() === "true"; 1567} 1568 1569module.exports = { 1570 debounce: debounce, 1571 displayCartQty: displayCartQty, 1572 isMobile: isMobile, 1573 goToAnchor: goToAnchor, 1574 activationBtn: activationBtn, 1575 goToElement: goToElement, 1576 scrollToError: scrollToError, 1577 processFormFieldError: processFormFieldError, 1578 throttle: throttle, 1579 isSafari: isSafari, 1580 getBoolean: getBoolean 1581}; 1582 1583/***/ }), 1584 1585/***/ 8959: 1586/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1587 1588var processInclude = __webpack_require__(7199); 1589 1590$(document).ready(function () { 1591 processInclude(__webpack_require__(8194)); 1592}); 1593/** 1594 * Initializes the page and includes the Quick View JavaScript if necessary 1595 */ 1596 1597function init() { 1598 var includeQuickViewJs = $("[class$='editorialRichText']").length && $(".product-tile").length; 1599 1600 if (!includeQuickViewJs) { 1601 return; 1602 } 1603 1604 processInclude(__webpack_require__(1601)); 1605} 1606 1607module.exports = { 1608 init: init 1609}; 1610 1611/***/ }), 1612 1613/***/ 754: 1614/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1615 1616var base = __webpack_require__(2658); 1617 1618var quickView = __webpack_require__(1601); 1619 1620var focusHelper = __webpack_require__(7768); 1621 1622var utils = __webpack_require__(4443); 1623/** 1624 * appends params to a url 1625 * @param {string} url - Original url 1626 * @param {Object} params - Parameters to append 1627 * @returns {string} result url with appended parameters 1628 */ 1629 1630 1631function appendToUrl(url, params) { 1632 var newUrl = url; 1633 newUrl += (newUrl.indexOf("?") !== -1 ? "&" : "?") + Object.keys(params).map(function (key) { 1634 return key + "=" + encodeURIComponent(params[key]); 1635 }).join("&"); 1636 return newUrl; 1637} 1638/** 1639 * Checks whether the basket is valid. if invalid displays error message and disables 1640 * checkout button 1641 * @param {Object} data - AJAX response from the server 1642 */ 1643 1644 1645function validateBasket(data) { 1646 if (data.valid.error) { 1647 if (data.valid.message) { 1648 var errorHtml = "<div class=\"alert alert-danger alert-dismissible valid-cart-error " + "fade show\" role=\"alert\">" + "<button type=\"button\" class=\"close\" data-dismiss=\"alert\" aria-label=\"Close\">" + "<span aria-hidden=\"true\">×</span>" + "</button>" + data.valid.message + "</div>"; 1649 $(".cart-error").append(errorHtml); 1650 } else { 1651 $(".cart").empty().append("<div class=\"row\"> " + "<div class=\"col-12 text-center fs30 fw500\"> " + "<div class=\"fs-30 fw500 my-3 my-md-6\">" + data.resources.emptyCartMsg + "</div> " + "</div> " + "</div>"); 1652 $(".number-of-items").empty().append(data.resources.numberOfItems); 1653 $(".minicart-quantity").empty().append(utils.displayCartQty(data.numItems)); 1654 $(".minicart-link").attr({ 1655 "aria-label": data.resources.minicartCountOfItems, 1656 title: data.resources.minicartCountOfItems 1657 }); 1658 $(".minicart .popover").empty(); 1659 $(".minicart .popover").removeClass("show"); 1660 } 1661 1662 $(".checkout-btn").addClass("disabled"); 1663 } else { 1664 $(".coupon-error-message").empty(); 1665 $("#loyaltyError").addClass("d-none").html(""); 1666 $(".checkout-btn").removeClass("disabled"); 1667 } 1668} 1669/** 1670 * re-renders the order totals and the number of items in the cart 1671 * @param {Object} data - AJAX response from the server 1672 */ 1673 1674 1675function updateCartTotals(data) { 1676 $(".number-of-items").empty().append(data.resources.numberOfItems); 1677 $(".shipping-cost").empty().append(data.totals.totalShippingCost); 1678 $(".tax-total").empty().append(data.totals.totalTax); 1679 $(".grand-total").empty().append(data.totals.grandTotal); 1680 $(".sub-total").empty().append(data.totals.subTotal); 1681 $(".minicart-quantity").empty().append(utils.displayCartQty(data.numItems)); 1682 $(".minicart-link").attr({ 1683 "aria-label": data.resources.minicartCountOfItems, 1684 title: data.resources.minicartCountOfItems 1685 }); 1686 1687 if (data.totals.orderLevelDiscountTotal.value > 0) { 1688 $(".order-discount").removeClass("hide-order-discount"); 1689 $(".order-discount-total").empty().append("- " + data.totals.orderLevelDiscountTotal.formatted); 1690 } else { 1691 $(".order-discount").addClass("hide-order-discount"); 1692 } 1693 1694 if (data.totals.shippingLevelDiscountTotal.value > 0) { 1695 $(".shipping-discount").removeClass("hide-shipping-discount"); 1696 $(".shipping-discount-total").empty().append("- " + data.totals.shippingLevelDiscountTotal.formatted); 1697 } else { 1698 $(".shipping-discount").addClass("hide-shipping-discount"); 1699 } 1700
1701 data.items.forEach(function (item) { 1702 var _item$bundledProductL; 1703 1704 if (item.renderedPromotions) { 1705 $(".item-" + item.UUID).empty().append(item.renderedPromotions); 1706 } 1707 1708 if (item.priceTotal && item.priceTotal.renderedPrice) { 1709 $(".item-total-" + item.UUID).empty().append(item.priceTotal.renderedPrice); 1710 } 1711 1712 if ((_item$bundledProductL = item.bundledProductLineItems) !== null && _item$bundledProductL !== void 0 && _item$bundledProductL.length) { 1713 $(".uuid-" + item.UUID).find(".bundled-line-item").each(function (index) { 1714 $(this).find("span").first().text(item.bundledProductLineItems[index].quantity + " x "); 1715 }); 1716 } 1717 }); 1718 1719 if (data.cartShippingMethodSelectionHtml) { 1720 $(".cart-shipping-selection").html(data.cartShippingMethodSelectionHtml); 1721 } 1722} 1723/** 1724 * Updates the closest shipment value in the cart. 1725 * 1726 * @param {Object} data - The cart data. 1727 * @param {Object} data.resources - The cart resources. 1728 * @param {string} data.resources.shipmentValueMsg - The shipment value message. 1729 */ 1730 1731 1732function updateShipmentValueText(data) { 1733 var $shipmentValue = $(".shipment-value"); 1734 $shipmentValue.empty().removeClass("bottom-border"); 1735 1736 if (data && data.resources && data.resources.shipmentValueMsg) { 1737 $shipmentValue.append(data.resources.shipmentValueMsg).addClass("bottom-border"); 1738 } 1739} 1740/** 1741 * re-renders the order totals and the number of items in the cart 1742 * @param {Object} message - Error message to display 1743 */ 1744 1745 1746function createErrorNotification(message) { 1747 var errorHtml = "<div class=\"alert alert-danger alert-dismissible valid-cart-error " + "fade show\" role=\"alert\">" + "<button type=\"button\" class=\"close\" data-dismiss=\"alert\" aria-label=\"Close\">" + "<span aria-hidden=\"true\">×</span>" + "</button>" + message + "</div>"; 1748 $(".cart-error").append(errorHtml); 1749} 1750/** 1751 * re-renders the approaching discount messages 1752 * @param {Object} approachingDiscounts - updated approaching discounts for the cart 1753 */ 1754 1755 1756function updateApproachingDiscounts(approachingDiscounts) { 1757 var html = ""; 1758 $(".approaching-discounts").empty(); 1759 1760 if (approachingDiscounts.length > 0) { 1761 approachingDiscounts.forEach(function (item) { 1762 html += "<div class=\"single-approaching-discount text-center\">" + item.discountMsg + "</div>"; 1763 }); 1764 } 1765 1766 $(".approaching-discounts").append(html); 1767} 1768/** 1769 * Updates the availability of a product line item 1770 * @param {Object} data - AJAX response from the server 1771 * @param {string} uuid - The uuid of the product line item to update 1772 */ 1773 1774 1775function updateAvailability(data, uuid) { 1776 var lineItem; 1777 var messages = ""; 1778 1779 for (var i = 0; i < data.items.length; i++) { 1780 if (data.items[i].UUID === uuid) { 1781 lineItem = data.items[i]; 1782 break; 1783 } 1784 } 1785 1786 if (lineItem && lineItem.UUID) { 1787 $(".availability-" + lineItem.UUID).empty(); 1788 } 1789 1790 if (lineItem && lineItem.availability) { 1791 if (lineItem.availability.messages) { 1792 lineItem.availability.messages.forEach(function (message) { 1793 messages += "<p class=\"line-item-attributes\">" + message + "</p>"; 1794 }); 1795 } 1796 1797 if (lineItem.availability.inStockDate) { 1798 messages += "<p class=\"line-item-attributes line-item-instock-date\">" + lineItem.availability.inStockDate + "</p>"; 1799 } 1800 } 1801 1802 if (lineItem && lineItem.UUID) { 1803 $(".availability-" + lineItem.UUID).html(messages); 1804 } 1805} 1806/** 1807 * Finds an element in the array that matches search parameter 1808 * @param {array} array - array of items to search 1809 * @param {function} match - function that takes an element and returns a boolean indicating if the match is made 1810 * @returns {Object|null} - returns an element of the array that matched the query. 1811 */ 1812 1813 1814function findItem(array, match) { 1815 for (var i = 0, l = array.length; i < l; i++) { 1816 if (match.call(this, array[i])) { 1817 return array[i]; 1818 } 1819 } 1820 1821 return null; 1822} 1823/** 1824 * Updates details of a product line item 1825 * @param {Object} data - AJAX response from the server 1826 * @param {string} uuid - The uuid of the product line item to update 1827 */ 1828 1829 1830function updateProductDetails(data, uuid) { 1831 var lineItem = findItem(data.cartModel.items, function (item) { 1832 return item.UUID === uuid; 1833 }); 1834 1835 if (lineItem.variationAttributes) { 1836 var colorAttr = findItem(lineItem.variationAttributes, function (attr) { 1837 return attr.attributeId === "color"; 1838 }); 1839 1840 if (colorAttr) { 1841 var colorSelector = ".Color-" + uuid;
1842 var newColor = "Color: " + colorAttr.displayValue; 1843 $(colorSelector).text(newColor); 1844 } 1845 1846 var sizeAttr = findItem(lineItem.variationAttributes, function (attr) { 1847 return attr.attributeId === "size"; 1848 }); 1849 1850 if (sizeAttr) { 1851 var sizeSelector = ".Size-" + uuid; 1852 var newSize = "Size: " + sizeAttr.displayValue; 1853 $(sizeSelector).text(newSize); 1854 } 1855 1856 var imageSelector = ".card.product-info.uuid-" + uuid + " .item-image > img"; 1857 $(imageSelector).attr("src", lineItem.images.small[0].url); 1858 $(imageSelector).attr("alt", lineItem.images.small[0].alt); 1859 $(imageSelector).attr("title", lineItem.images.small[0].title); 1860 } 1861 1862 if (lineItem.options && lineItem.options.length) { 1863 var option = lineItem.options[0]; 1864 var optSelector = ".lineItem-options-values[data-option-id=\"" + option.optionId + "\"]"; 1865 $(optSelector).data("value-id", option.selectedValueId); 1866 $(optSelector + " .line-item-attributes").text(option.displayName); 1867 } 1868 1869 var qtySelector = ".quantity[data-uuid=\"" + uuid + "\"]"; 1870 $(qtySelector).val(lineItem.quantity); 1871 $(qtySelector).data("pid", data.newProductId); 1872 $(".remove-product[data-uuid=\"" + uuid + "\"]").data("pid", data.newProductId); 1873 var priceSelector = ".line-item-price-" + uuid + " .sales .value"; 1874 $(priceSelector).text(lineItem.price.sales.formatted); 1875 $(priceSelector).attr("content", lineItem.price.sales.decimalPrice); 1876 1877 if (lineItem.price.list) { 1878 var listPriceSelector = ".line-item-price-" + uuid + " .list .value"; 1879 $(listPriceSelector).text(lineItem.price.list.formatted); 1880 $(listPriceSelector).attr("content", lineItem.price.list.decimalPrice); 1881 } 1882} 1883/** 1884 * Generates the modal window on the first call. 1885 * 1886 */ 1887 1888 1889function getModalHtmlElement() { 1890 if ($("#editProductModal").length !== 0) { 1891 $("#editProductModal").remove(); 1892 } 1893 1894 var htmlString = "<!-- Modal -->" + "<div class=\"modal fade\" id=\"editProductModal\" tabindex=\"-1\" role=\"dialog\">" + "<span class=\"enter-message sr-only\" ></span>" + "<div class=\"modal-dialog quick-view-dialog\">" + "<!-- Modal content-->" + "<div class=\"modal-content\">" + "<div class=\"modal-header\">" + " <button type=\"button\" class=\"close pull-right\" data-dismiss=\"modal\">" + " <span aria-hidden=\"true\">×</span>" + " <span class=\"sr-only\"> </span>" + " </button>" + "</div>" + "<div class=\"modal-body\"></div>" + "<div class=\"modal-footer\"></div>" + "</div>" + "</div>" + "</div>"; 1895 $("body").append(htmlString); 1896} 1897/** 1898 * Parses the html for a modal window 1899 * @param {string} html - representing the body and footer of the modal window 1900 * 1901 * @return {Object} - Object with properties body and footer. 1902 */ 1903 1904 1905function parseHtml(html) { 1906 var $html = $("<div>").append($.parseHTML(html)); 1907 var body = $html.find(".product-quickview"); 1908 var footer = $html.find(".modal-footer").children(); 1909 return { 1910 body: body, 1911 footer: footer 1912 }; 1913} 1914/** 1915 * replaces the content in the modal window for product variation to be edited. 1916 * @param {string} editProductUrl - url to be used to retrieve a new product model 1917 */ 1918 1919 1920function fillModalElement(editProductUrl) { 1921 $(".modal-body").spinner().start(); 1922 $.ajax({ 1923 url: editProductUrl, 1924 method: "GET", 1925 dataType: "json", 1926 success: function success(data) { 1927 var parsedHtml = parseHtml(data.renderedTemplate); 1928 $("#editProductModal .modal-body").empty(); 1929 $("#editProductModal .modal-body").html(parsedHtml.body); 1930 $("#editProductModal .modal-footer").html(parsedHtml.footer); 1931 $("#editProductModal .modal-header .close .sr-only").text(data.closeButtonText); 1932 $("#editProductModal .enter-message").text(data.enterDialogMessage); 1933 $("#editProductModal").modal("show"); 1934 $("body").trigger("editproductmodal:ready"); 1935 $.spinner().stop(); 1936 }, 1937 error: function error() { 1938 $.spinner().stop(); 1939 } 1940 }); 1941} 1942/** 1943 * replace content of modal 1944 * @param {string} actionUrl - url to be used to remove product 1945 * @param {string} productID - pid 1946 * @param {string} productName - product name 1947 * @param {string} uuid - uuid 1948 */ 1949 1950 1951function confirmDelete(actionUrl, productID, productName, uuid) { 1952 var $deleteConfirmBtn = $(".cart-delete-confirmation-btn"); 1953 var $productToRemoveSpan = $(".product-to-remove"); 1954 $deleteConfirmBtn.data("pid", productID); 1955 $deleteConfirmBtn.data("action", actionUrl); 1956 $deleteConfirmBtn.data("uuid", uuid); 1957 $productToRemoveSpan.empty().append(productName); 1958} 1959/** 1960 * Adds a bottom border to the element with class "shipment-value" if it has text, and removes it if it doesn't. 1961 */ 1962 1963 1964function addBottomBorder() { 1965 var $shipmentValue = $(".shipment-value"); 1966 var hasNoText = $.trim($shipmentValue.text()).length === 0; 1967 1968 if (hasNoText) { 1969 $shipmentValue.removeClass("bottom-border"); 1970 } else { 1971 $shipmentValue.addClass("bottom-border"); 1972 } 1973} 1974/** 1975* Initialize the carousel with recommended products in the cart page 1976* @returns {void} 1977*/ 1978 1979 1980function initializeCarousel() { 1981 var $recoSlider = $("#recommender-slider.slick-slider"); 1982 1983 if (!$recoSlider.length) { 1984 return; 1985 } 1986 1987 $recoSlider.on("setPosition", function () { 1988 $("body").trigger("recommender-slider:setPosition"); 1989 }); 1990 $recoSlider.slick({ 1991 arrows: true, 1992 slidesToShow: 4, 1993 slidesToScroll: 1, 1994 infinite: true, 1995 responsive: [{ 1996 breakpoint: 950, 1997 settings: { 1998 slidesToShow: 1, 1999 slidesToScroll: 1, 2000 infinite: true, 2001 dots: true,
2002 arrows: false, 2003 centerMode: true, 2004 centerPadding: "13%" 2005 } 2006 }] 2007 }); 2008} 2009/** 2010* Initializes the recommender slider 2011* @returns {void} 2012*/ 2013 2014 2015function initRecommenderSlider() { 2016 var outerObserver = new MutationObserver(function (mutationsList, observer) { 2017 if (document.getElementById("recommender-slider")) { 2018 initializeCarousel(); 2019 observer.disconnect(); 2020 } 2021 }); 2022 var observerConfig = { 2023 childList: true, 2024 subtree: true 2025 }; 2026 outerObserver.observe(document.body, observerConfig); 2027} 2028/** 2029* Reloads the cart page 2030*/ 2031 2032 2033function reloadCartPage() { 2034 if ($(".cart-page").length) { 2035 location.reload(); 2036 } 2037} 2038 2039module.exports = function () { 2040 $("body").on("click", ".remove-product", function (e) { 2041 e.preventDefault(); 2042 var actionUrl = $(this).data("action"); 2043 var productID = $(this).data("pid"); 2044 var productName = $(this).data("name"); 2045 var uuid = $(this).data("uuid"); 2046 confirmDelete(actionUrl, productID, productName, uuid); 2047 }); 2048 $("body").on("afterRemoveFromCart", function (e, data) { 2049 e.preventDefault(); 2050 confirmDelete(data.actionUrl, data.productID, data.productName, data.uuid); 2051 }); 2052 $(".optional-promo").click(function (e) { 2053 e.preventDefault(); 2054 $(".promo-code-form").toggle(); 2055 }); 2056 $("body").on("click", ".cart-delete-confirmation-btn", function (e) { 2057 e.preventDefault(); 2058 var productID = $(this).data("pid"); 2059 var url = $(this).data("action"); 2060 var uuid = $(this).data("uuid"); 2061 var urlParams = { 2062 pid: productID, 2063 uuid: uuid 2064 }; 2065 url = appendToUrl(url, urlParams); 2066 $("body > .modal-backdrop").remove(); 2067 $.spinner().start(); 2068 $.ajax({ 2069 url: url, 2070 type: "get", 2071 dataType: "json", 2072 success: function success(data) { 2073 var _data$basket; 2074 2075 $("body").trigger("product:onCartUpdateQty", [data === null || data === void 0 ? void 0 : (_data$basket = data.basket) === null || _data$basket === void 0 ? void 0 : _data$basket.items]); 2076 2077 if (data.basket.items.length === 0) { 2078 $(".cart").empty().append("<div class=\"row\"> " + "<div class=\"col-12 text-center fs30 fw500\"> " + "<div class=\"fs-30 fw500 my-3 my-md-6\">" + data.basket.resources.emptyCartMsg + "</div> " + "</div> " + "</div>"); 2079 $(".number-of-items").empty().append(data.basket.resources.numberOfItems); 2080 $(".minicart-quantity").empty().append(utils.displayCartQty(data.basket.numItems)); 2081 $(".minicart-link").attr({ 2082 "aria-label": data.basket.resources.minicartCountOfItems, 2083 title: data.basket.resources.minicartCountOfItems 2084 }); 2085 $(".minicart .popover").empty(); 2086 $(".minicart .popover").removeClass("show"); 2087 $(".cart-recommender-slider").addClass("d-none"); 2088 $("body").removeClass("modal-open"); 2089 $("html").removeClass("veiled"); 2090 } else { 2091 if (data.toBeDeletedUUIDs && data.toBeDeletedUUIDs.length > 0) { 2092 for (var i = 0; i < data.toBeDeletedUUIDs.length; i++) { 2093 $(".uuid-" + data.toBeDeletedUUIDs[i]).remove(); 2094 } 2095 } 2096 2097 $(".uuid-" + uuid).remove(); 2098 2099 if (!data.basket.hasBonusProduct) { 2100 $(".bonus-product").remove(); 2101 } 2102 2103 $(".coupons-and-promos").empty().append(data.basket.totals.discountsHtml); 2104 updateCartTotals(data.basket); 2105 updateApproachingDiscounts(data.basket.approachingDiscounts); 2106 $("body").trigger("setShippingMethodSelection", data.basket); 2107 validateBasket(data.basket); 2108 updateShipmentValueText(data.basket); 2109 } 2110 2111 $("body").trigger("gtm:afterRemoveFromCart", { 2112 data: data.gtmRemoveFromCart 2113 }); 2114 $("body").trigger("cart:update"); 2115 $.spinner().stop(); 2116 }, 2117 error: function error(err) { 2118 if (err.responseJSON.redirectUrl) { 2119 window.location.href = err.responseJSON.redirectUrl; 2120 } else { 2121 createErrorNotification(err.responseJSON.errorMessage); 2122 $.spinner().stop(); 2123 } 2124 } 2125 }); 2126 }); 2127 $("body").on("change", ".quantity-form select.quantity", function () { 2128 var preSelectQty = $(this).data("pre-select-qty"); 2129 var quantity = $(this).val(); 2130 var productID = $(this).data("pid"); 2131 var url = $(this).data("action"); 2132 var uuid = $(this).data("uuid");
2133 var urlParams = { 2134 pid: productID, 2135 quantity: quantity, 2136 uuid: uuid 2137 }; 2138 url = appendToUrl(url, urlParams); 2139 $(this).parents(".card").spinner().start(); 2140 $.ajax({ 2141 url: url, 2142 type: "get", 2143 context: this, 2144 dataType: "json", 2145 success: function success(data) { 2146 $(".quantity[data-uuid=\"" + uuid + "\"]").val(quantity); 2147 $(document).trigger("reinitSelect", [$(".quantity:not(.selectToBox, .selectToQty)")]); 2148 $(document).trigger("miniCartReinintSelect", [$(".select-minicart-quantity:not(.selectToBox, .selectToQty)")]); 2149 $(".coupons-and-promos").empty().append(data.totals.discountsHtml); 2150 updateCartTotals(data); 2151 updateApproachingDiscounts(data.approachingDiscounts); 2152 updateAvailability(data, uuid); 2153 updateShipmentValueText(data); 2154 validateBasket(data); 2155 $(this).data("pre-select-qty", quantity); 2156 var $bonusProduct = $(".bonus-product"); 2157 2158 if (!data.hasBonusProduct) { 2159 $bonusProduct.remove(); 2160 } else { 2161 if ($bonusProduct.length === 0 && data.bonusProductHtml) { 2162 $(".cart.cart-page .card.product-info").last().after(data.bonusProductHtml); 2163 } 2164 } 2165 2166 $("body").trigger("cart:update"); 2167 $.spinner().stop(); 2168 2169 if ($(this).parents(".product-info").hasClass("bonus-product-line-item") && $(".cart-page").length) { 2170 location.reload(); 2171 } 2172 }, 2173 error: function error(err) { 2174 if (err.responseJSON.redirectUrl) { 2175 window.location.href = err.responseJSON.redirectUrl; 2176 } else { 2177 createErrorNotification(err.responseJSON.errorMessage); 2178 $(this).val(parseInt(preSelectQty, 10)); 2179 $.spinner().stop(); 2180 } 2181 } 2182 }); 2183 }); 2184 $(".cart-shipping-selection").change(function () { 2185 var url = $(this).attr("data-actionUrl"); 2186 var urlParams = { 2187 methodID: $(this).find(":checked").attr("data-shipping-id") 2188 }; 2189 $.spinner().start(); 2190 $.ajax({ 2191 url: url, 2192 type: "post", 2193 dataType: "json", 2194 data: urlParams, 2195 success: function success(data) { 2196 if (data.error) { 2197 window.location.href = data.redirectUrl; 2198 } else { 2199 $(".coupons-and-promos").empty().append(data.totals.discountsHtml); 2200 updateCartTotals(data); 2201 updateApproachingDiscounts(data.approachingDiscounts); 2202 validateBasket(data); 2203 updateShipmentValueText(data); 2204 } 2205 2206 $.spinner().stop(); 2207 }, 2208 error: function error(err) { 2209 if (err.redirectUrl) { 2210 window.location.href = err.redirectUrl; 2211 } else { 2212 createErrorNotification(err.responseJSON.errorMessage); 2213 $.spinner().stop(); 2214 } 2215 } 2216 }); 2217 }); 2218 $(".promo-code-form").submit(function (e) { 2219 var $this = $(this); 2220 e.preventDefault(); 2221 $.spinner().start(); 2222 $(".coupon-missing-error", $this).hide(); 2223 $(".coupon-error-message", $this).empty(); 2224 2225 if (!$(".coupon-code-field", $this).val()) { 2226 $(".promo-code-form .form-control", $this).addClass("is-invalid"); 2227 $(".promo-code-form .form-control", $this).attr("aria-describedby", "missingCouponCode"); 2228 $(".coupon-missing-error", $this).show(); 2229 $.spinner().stop(); 2230 } else { 2231 $(".promo-code-form .form-control", $this).removeClass("is-invalid"); 2232 $(".coupon-error-message", $this).empty(); 2233 $.ajax({ 2234 url: $this.attr("action"), 2235 type: "GET", 2236 dataType: "json", 2237 data: $this.serialize(), 2238 success: function success(data) { 2239 if (data.error) { 2240 $(".promo-code-form .form-control", $this).addClass("is-invalid"); 2241 $(".promo-code-form .form-control", $this).attr("aria-describedby", "invalidCouponCode"); 2242 $(".coupon-error-message", $this).empty().show().append(data.errorMessage); 2243 $("body").trigger("promotion:error", data); 2244 } else { 2245 $(".coupons-and-promos").empty().append(data.totals.discountsHtml); 2246 updateCartTotals(data); 2247 updateApproachingDiscounts(data.approachingDiscounts); 2248 validateBasket(data); 2249 updateShipmentValueText(data); 2250 2251 if (!(data !== null && data !== void 0 && data.approachingDiscounts.length)) { 2252 data.needToReload = true; 2253 } 2254 2255 $("body").trigger("promotion:success", data); 2256 } 2257 2258 $(".coupon-code-field", $this).val(""); 2259 $.spinner().stop(); 2260 }, 2261 error: function error(err) { 2262 $("body").trigger("promotion:error", err); 2263 2264 if (err.responseJSON.redirectUrl) { 2265 window.location.href = err.responseJSON.redirectUrl; 2266 } else { 2267 createErrorNotification(err.errorMessage); 2268 $.spinner().stop(); 2269 } 2270 } 2271 }); 2272 } 2273 2274 return false;
2275 }); 2276 var $body = $("body"); 2277 $body.on("promotion:success", function (e, data) { 2278 if ((data === null || data === void 0 ? void 0 : data.needToReload) === true) { 2279 location.reload(); 2280 } 2281 }); 2282 $body.on("click", ".add-loyalty-voucher-confirmation-btn", function () { 2283 var $form = $("#loyaltyPromoCodeForm"); 2284 var $error = $("#loyaltyError"); 2285 $.spinner().start(); 2286 $error.addClass("d-none").html(""); 2287 $.ajax({ 2288 url: $form.attr("action"), 2289 type: $form.attr("method"), 2290 dataType: "json", 2291 data: $form.serialize(), 2292 success: function success(data) { 2293 if (data.error) { 2294 $error.removeClass("d-none").html(data.errorMessage); 2295 $body.trigger("promotion:error", data); 2296 } else { 2297 $(".coupons-and-promos").empty().append(data.totals.discountsHtml); 2298 updateCartTotals(data); 2299 updateApproachingDiscounts(data.approachingDiscounts); 2300 validateBasket(data); 2301 $body.trigger("promotion:success", data); 2302 } 2303 2304 $.spinner().stop(); 2305 }, 2306 error: function error(err) { 2307 var _err$responseJSON; 2308 2309 $error.removeClass("d-none").html(err.errorMessage); 2310 $body.trigger("promotion:error", err); 2311 2312 if (err !== null && err !== void 0 && (_err$responseJSON = err.responseJSON) !== null && _err$responseJSON !== void 0 && _err$responseJSON.redirectUrl) { 2313 window.location.href = err.responseJSON.redirectUrl; 2314 } else { 2315 createErrorNotification(err.errorMessage); 2316 $.spinner().stop(); 2317 } 2318 } 2319 }); 2320 }); 2321 $("body").on("click", ".remove-coupon", function (e) { 2322 e.preventDefault(); 2323 var couponCode = $(this).data("code"); 2324 var uuid = $(this).data("uuid"); 2325 var $deleteConfirmBtn = $(".delete-coupon-confirmation-btn"); 2326 var $productToRemoveSpan = $(".coupon-to-remove"); 2327 $deleteConfirmBtn.data("uuid", uuid); 2328 $deleteConfirmBtn.data("code", couponCode); 2329 $productToRemoveSpan.empty().append(couponCode); 2330 }); 2331 $("body").on("click", ".delete-coupon-confirmation-btn", function (e) { 2332 e.preventDefault(); 2333 var url = $(this).data("action"); 2334 var uuid = $(this).data("uuid"); 2335 var couponCode = $(this).data("code"); 2336 var urlParams = { 2337 code: couponCode, 2338 uuid: uuid 2339 }; 2340 url = appendToUrl(url, urlParams); 2341 $("body > .modal-backdrop").remove(); 2342 $.spinner().start(); 2343 $.ajax({ 2344 url: url, 2345 type: "get", 2346 dataType: "json", 2347 success: function success(data) { 2348 $(".coupon-uuid-" + uuid).remove(); 2349 updateCartTotals(data); 2350 updateApproachingDiscounts(data.approachingDiscounts); 2351 validateBasket(data); 2352 updateShipmentValueText(data); 2353 $.spinner().stop(); 2354 data.needToReload = true; 2355 $("body").trigger("promotion:success", data); 2356 }, 2357 error: function error(err) { 2358 $("body").trigger("promotion:error", err); 2359 2360 if (err.responseJSON.redirectUrl) { 2361 window.location.href = err.responseJSON.redirectUrl; 2362 } else { 2363 createErrorNotification(err.responseJSON.errorMessage); 2364 $.spinner().stop(); 2365 } 2366 } 2367 }); 2368 }); 2369 $("body").on("click", ".cart-page .bonus-product-button", function () { 2370 $.spinner().start(); 2371 $(this).addClass("launched-modal"); 2372 $.ajax({ 2373 url: $(this).data("url"), 2374 method: "GET", 2375 dataType: "json", 2376 success: function success(data) { 2377 base.methods.editBonusProducts(data); 2378 $.spinner().stop(); 2379 }, 2380 error: function error() { 2381 $.spinner().stop(); 2382 } 2383 }); 2384 }); 2385 $("body").on("hidden.bs.modal", "#chooseBonusProductModal", function () { 2386 $("#chooseBonusProductModal").remove(); 2387 $(".modal-backdrop").remove(); 2388 $("body").removeClass("modal-open"); 2389 2390 if ($(".cart-page").length) { 2391 $(".launched-modal .btn-outline-primary").trigger("focus"); 2392 $(".launched-modal").removeClass("launched-modal"); 2393 } else { 2394 $(".product-detail .add-to-cart").focus(); 2395 } 2396 }); 2397 $("body").on("click", ".cart-page .product-edit .edit, .cart-page .bundle-edit .edit", function (e) { 2398 e.preventDefault(); 2399 var editProductUrl = $(this).attr("href"); 2400 getModalHtmlElement(); 2401 fillModalElement(editProductUrl); 2402 }); 2403 $("body").on("shown.bs.modal", "#editProductModal", function () { 2404 $("#editProductModal").siblings().attr("aria-hidden", "true"); 2405 $("#editProductModal .close").focus(); 2406 }); 2407 $("body").on("hidden.bs.modal", "#editProductModal", function () { 2408 $("#editProductModal").siblings().attr("aria-hidden", "false"); 2409 }); 2410 $("body").on("keydown", "#editProductModal", function (e) { 2411 var focusParams = { 2412 event: e, 2413 containerSelector: "#editProductModal", 2414 firstElementSelector: ".close", 2415 lastElementSelector: ".update-cart-product-global", 2416 nextToLastElementSelector: ".modal-footer .quantity-select" 2417 }; 2418 focusHelper.setTabNextFocus(focusParams); 2419 }); 2420 $("body").on("product:updateAddToCart", function (e, response) { 2421 // update global add to cart (single products, bundles)
2422 var dialog = $(response.$productContainer).closest(".quick-view-dialog"); 2423 $(".update-cart-product-global", dialog).attr("disabled", !$(".global-availability", dialog).data("ready-to-order") || !$(".global-availability", dialog).data("available")); 2424 }); 2425 $("body").on("product:updateAvailability", function (e, response) { 2426 // bundle individual products 2427 $(".product-availability", response.$productContainer).data("ready-to-order", response.product.readyToOrder).data("available", response.product.available).find(".availability-msg").empty().html(response.message); 2428 var dialog = $(response.$productContainer).closest(".quick-view-dialog"); 2429 2430 if ($(".product-availability", dialog).length) { 2431 // bundle all products 2432 var allAvailable = $(".product-availability", dialog).toArray().every(function (item) { 2433 return $(item).data("available"); 2434 }); 2435 var allReady = $(".product-availability", dialog).toArray().every(function (item) { 2436 return $(item).data("ready-to-order"); 2437 }); 2438 $(".global-availability", dialog).data("ready-to-order", allReady).data("available", allAvailable); 2439 $(".global-availability .availability-msg", dialog).empty().html(allReady ? response.message : response.resources.info_selectforstock); 2440 } else { 2441 // single product 2442 $(".global-availability", dialog).data("ready-to-order", response.product.readyToOrder).data("available", response.product.available).find(".availability-msg").empty().html(response.message); 2443 } 2444 }); 2445 $("body").on("product:afterAttributeSelect", function (e, response) { 2446 if ($(".modal.show .product-quickview .bundle-items").length) { 2447 $(".modal.show").find(response.container).data("pid", response.data.product.id); 2448 $(".modal.show").find(response.container).find(".product-id").text(response.data.product.id); 2449 } else { 2450 $(".modal.show .product-quickview").data("pid", response.data.product.id); 2451 } 2452 }); 2453 $("body").on("change", ".quantity-select", function () { 2454 var selectedQuantity = $(this).val(); 2455 $(".modal.show .update-cart-url").data("selected-quantity", selectedQuantity); 2456 }); 2457 $("body").on("change", ".options-select", function () { 2458 var selectedOptionValueId = $(this).children("option:selected").data("value-id"); 2459 $(".modal.show .update-cart-url").data("selected-option", selectedOptionValueId); 2460 }); 2461 $("body").on("click", ".update-cart-product-global", function (e) { 2462 e.preventDefault(); 2463 var updateProductUrl = $(this).closest(".cart-and-ipay").find(".update-cart-url").val(); 2464 var selectedQuantity = $(this).closest(".cart-and-ipay").find(".update-cart-url").data("selected-quantity"); 2465 var selectedOptionValueId = $(this).closest(".cart-and-ipay").find(".update-cart-url").data("selected-option"); 2466 var uuid = $(this).closest(".cart-and-ipay").find(".update-cart-url").data("uuid"); 2467 var form = { 2468 uuid: uuid, 2469 pid: base.getPidValue($(this)), 2470 quantity: selectedQuantity, 2471 selectedOptionValueId: selectedOptionValueId 2472 }; 2473 $(this).parents(".card").spinner().start(); 2474 2475 if (updateProductUrl) { 2476 $.ajax({ 2477 url: updateProductUrl, 2478 type: "post", 2479 context: this, 2480 data: form, 2481 dataType: "json", 2482 success: function success(data) { 2483 $("#editProductModal").modal("hide"); 2484 $(".coupons-and-promos").empty().append(data.cartModel.totals.discountsHtml); 2485 updateCartTotals(data.cartModel); 2486 updateApproachingDiscounts(data.cartModel.approachingDiscounts); 2487 updateAvailability(data.cartModel, uuid); 2488 updateProductDetails(data, uuid); 2489 2490 if (data.uuidToBeDeleted) { 2491 $(".uuid-" + data.uuidToBeDeleted).remove(); 2492 } 2493 2494 validateBasket(data.cartModel); 2495 $("body").trigger("cart:update"); 2496 $.spinner().stop(); 2497 }, 2498 error: function error(err) { 2499 if (err.responseJSON.redirectUrl) { 2500 window.location.href = err.responseJSON.redirectUrl; 2501 } else { 2502 createErrorNotification(err.responseJSON.errorMessage); 2503 $.spinner().stop(); 2504 } 2505 } 2506 }); 2507 } 2508 }); 2509 $("body").on("product:afterAddToCart", function () { 2510 if ($("#chooseBonusProductModal").length === 0) { 2511 reloadCartPage(); 2512 } 2513 }); 2514 /** 2515 * Handles adding or removing a sample product via AJAX. 2516 * 2517 * @param {object} $input - jQuery object representing the sample checkbox/input element. 2518 * @param {string} action - Action to perform: 2519 * - "add": Adds the sample to the cart. 2520 * - "remove": Removes the sample from the cart. 2521 * @param {boolean} [reload=true] - Whether to reload the cart page after the action. 2522 * @param {function|null} [cb=null] - Optional callback function to execute upon success. 2523 * 2524 * @return {void} 2525 */ 2526 2527 function handleSampleAction($input, action) { 2528 var reload = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; 2529 var cb = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null; 2530 var uuid = $input.data("uuid") || ""; 2531 var productID = $input.data("pid") || ""; 2532 var urlBase = $(".sampleTile").data(action === "add" ? "addtocarturl" : "removefromcarturl");
2533 var urlParams = { 2534 pid: productID, 2535 uuid: uuid 2536 }; 2537 var url = appendToUrl(urlBase, urlParams); 2538 $.ajax({ 2539 url: url, 2540 method: "GET", 2541 success: function success(data) { 2542 if (data && data.error) { 2543 $("#sampleProduct-".concat(productID)).prop("checked", false); 2544 } else { 2545 if (reload) { 2546 reloadCartPage(); 2547 } 2548 2549 if (cb) { 2550 cb(); 2551 } 2552 } 2553 } 2554 }); 2555 } 2556 /** 2557 * Handles changes to sample product checkboxes and enforces business rules. 2558 * 2559 * @param {Event} e - Event object for the checkbox change event. 2560 * 2561 * @return {void} 2562 */ 2563 2564 2565 function handleChangeSample(e) { 2566 e.preventDefault(); 2567 var maxFreeSampleQuantity = +$("#maxFreeSampleQuantity").val(); 2568 var $this = $(this); 2569 var $siblingsChecked = $this.parents(".product-grid").find(".sample-product-checkbox input:checked"); 2570 var isAdding = $this.prop("checked"); 2571 2572 if (maxFreeSampleQuantity === 1 && $siblingsChecked.length > 1) { 2573 var $other = $this.parents(".sample-product-tile").siblings().find("input:checked"); 2574 handleSampleAction($other, "remove", false, function () { 2575 return handleSampleAction($this, "add"); 2576 }); 2577 } else { 2578 handleSampleAction($this, isAdding ? "add" : "remove"); 2579 } 2580 } 2581 2582 $(".sample-product-checkbox input").on("change", handleChangeSample); 2583 2584 if (!$(".product-detail").length > 0) { 2585 base.availability(); 2586 base.addToCart(); 2587 } 2588 2589 base.selectAttribute(); 2590 base.colorAttribute(); 2591 base.removeBonusProduct(); 2592 base.selectBonusProduct(); 2593 base.enableBonusProductSelection(); 2594 base.showMoreBonusProducts(); 2595 base.addBonusProductsToCart(); 2596 base.focusChooseBonusProductModal(); 2597 base.trapChooseBonusProductModalFocus(); 2598 base.onClosingChooseBonusProductModal(); 2599 quickView.showQuickview(); 2600 quickView.focusQuickview(); 2601 quickView.trapQuickviewFocus(); 2602 quickView.showSpinner(); 2603 quickView.hideDialog(); 2604 quickView.beforeUpdateAttribute(); 2605 quickView.updateAttribute(); 2606 quickView.updateAddToCart(); 2607 quickView.updateAvailability(); 2608 addBottomBorder(); 2609 initRecommenderSlider(); 2610}; 2611 2612/***/ }), 2613 2614/***/ 8194: 2615/***/ ((module) => { 2616 2617module.exports = { 2618 init: function init() { 2619 $('.blog-page').on('click', '.show-more-articles', function () { 2620 var $this = $(this); 2621 var showMoreUrl = $this.data('url'); 2622 $.spinner().start(); 2623 $.ajax({ 2624 url: showMoreUrl, 2625 method: 'GET', 2626 success: function success(response) { 2627 if (response) { 2628 $this.parent().remove(); 2629 $('#articles-list').append(response); 2630 } 2631 2632 $.spinner().stop(); 2633 }, 2634 error: function error() { 2635 $.spinner().stop(); 2636 } 2637 }); 2638 }); 2639 } 2640}; 2641 2642/***/ }), 2643 2644/***/ 6837: 2645/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2646 2647var resources = __webpack_require__(2973); 2648/** 2649 * Validate whole form. Requires `this` to be set to form object 2650 * @param {jQuery.event} event - Event to be canceled if form is invalid. 2651 * @returns {boolean} - Flag to indicate if form is valid 2652 */ 2653 2654 2655function _validateForm(event) { 2656 var valid = true; 2657 2658 if (this.checkValidity && !this.checkValidity()) { 2659 // safari 2660 valid = false; 2661 2662 if (event) { 2663 event.preventDefault(); 2664 event.stopPropagation(); 2665 event.stopImmediatePropagation(); 2666 } 2667 2668 $(this).find("input, select").each(function () { 2669 if (!this.validity.valid) { 2670 $(this).trigger("invalid", this.validity); 2671 } 2672 }); 2673 } 2674 2675 return valid; 2676} 2677/** 2678* Sanitizes user input by removing special characters and accents 2679* @param {string} input - user input 2680* @returns {string} - sanitized user input 2681*/ 2682 2683 2684function sanitizeInput(input, inputID) { 2685 // Mapping of French accent letters to English equivalents 2686 var accentMapping = { 2687 "à ": "a", 2688 "â": "a", 2689 "ä": "a", 2690 "ç": "c", 2691 "é": "e", 2692 "è": "e", 2693 "ê": "e", 2694 "ë": "e", 2695 "î": "i", 2696 "ï": "i", 2697 "ô": "o", 2698 "ö": "o", 2699 "ù": "u", 2700 "û": "u", 2701 "ü": "u", 2702 "ÿ": "y", 2703 "Ã": "A", 2704 "Ã": "A", 2705 "Ã": "A", 2706 "Ã": "C", 2707 "Ã": "E", 2708 "Ã": "E", 2709 "Ã": "E", 2710 "Ã": "E", 2711 "Ã": "I", 2712 "Ã": "I", 2713 "Ã": "O", 2714 "Ã": "O", 2715 "Ã": "U", 2716 "Ã": "U", 2717 "Ã": "U", 2718 "Ÿ": "Y" 2719 }; // Replace accent letters with their English equivalents 2720 2721 var sanitizedInput = input.replace(/[^\w\s-']|_/gi, function (match) { 2722 return accentMapping[match] || ""; 2723 }).normalize("NFD").replace(/[\u0300-\u036f]/g, ""); 2724 2725 if (inputID && inputID.toLowerCase().indexOf("zipcode") > -1) { 2726 // don't allow letters, only numbers 2727 sanitizedInput = sanitizedInput.replace(/[a-zA-Z]/g, ""); 2728 } 2729 2730 return sanitizedInput; 2731} 2732 2733function birthDayIsValid($el) { 2734 var val = $el.val(); 2735 var dates = val.split("/"); 2736 var dd = dates[0]; 2737 var mm = dates[1]; 2738 var yyyy = dates[2]; 2739 var now = new Date(); 2740 2741 if (val === "") { 2742 // if field empty no validation, field is not required 2743 return true; 2744 } else if (yyyy && !yyyy.match(new RegExp("^\\d{4}$"))) { 2745 return false;
2746 } else if (!Number.isNaN(Date.parse("".concat(mm, "/").concat(dd, "/").concat(yyyy))) && new Date("".concat(mm, "/").concat(dd, "/").concat(yyyy)) > now) { 2747 // Check if date string is valid and date is not set in the future 2748 return false; 2749 } else if (!Number.isNaN(Date.parse("".concat(mm, "/").concat(dd, "/").concat(yyyy)))) { 2750 // Check if date is valid and doesn't overflow to next month, case for 31 february becoming march 2751 var dateObj = new Date("".concat(mm, "/").concat(dd, "/").concat(yyyy)); 2752 var dateMonth = dateObj.getMonth() + 1; 2753 return dateMonth === parseInt(mm, 10); 2754 } else { 2755 // Any other case is not valid 2756 return false; 2757 } 2758} 2759/** 2760 * Remove all validation. Should be called every time before revalidating form 2761 * @returns {void} 2762 */ 2763 2764 2765function clearForm() { 2766 $(".form-control.is-invalid").removeClass("is-invalid"); 2767} 2768 2769module.exports = { 2770 /** 2771 * Transforms the input field to uppercase when the user types 2772 */ 2773 transformToUppercase: function transformToUppercase() { 2774 $("form").on("input", ".uppercase-transform", function () { 2775 $(this).val($(this).val().toUpperCase()); 2776 }); 2777 }, 2778 2779 /** 2780 * Validates the input of a form field 2781 * @param {string} inputValue - the value of the form field 2782 * @param {string} sanitizedValue - the sanitized value of the form field 2783 */ 2784 inputValidation: function inputValidation() { 2785 $("form").on("keyup", ".input-validation", function (event) { 2786 var input = $(this); 2787 var inputValue = input.val(); 2788 var inputID = event && event.currentTarget && event.currentTarget.id ? event.currentTarget.id : ""; 2789 var sanitizedValue = sanitizeInput(inputValue, inputID); 2790 input.val(sanitizedValue); 2791 }); 2792 },
2793 invalid: function invalid() { 2794 $("form input, form select").on("invalid", function (e) { 2795 e && e.preventDefault(); 2796 2797 if (!this.validity.valid) { 2798 var validationMessage; 2799 2800 for (var error in this.validity) { 2801 if (this.validity[error]) { 2802 validationMessage = resources[error]; 2803 } 2804 } 2805 2806 if (!validationMessage) { 2807 validationMessage = this.validationMessage; 2808 } 2809 2810 $(this).addClass("is-invalid"); 2811 2812 if (this.validity.patternMismatch && $(this).data("pattern-mismatch")) { 2813 validationMessage = $(this).data("pattern-mismatch"); 2814 } 2815 2816 if ((this.validity.rangeOverflow || this.validity.rangeUnderflow) && $(this).data("range-error")) { 2817 validationMessage = $(this).data("range-error"); 2818 } 2819 2820 if ((this.validity.tooLong || this.validity.tooShort) && $(this).data("range-error")) { 2821 validationMessage = $(this).data("range-error"); 2822 } 2823 2824 if (this.validity.valueMissing && $(this).data("missing-error")) { 2825 validationMessage = $(this).data("missing-error"); 2826 } 2827 2828 var $form = $(this).parents(".form-group").length ? $(this).parents(".form-group") : $(this).parents("form"); 2829 $form.find(".invalid-feedback").removeClass("d-none").addClass("d-block").text(validationMessage); 2830 2831 if ($(".valid-feedback").length) { 2832 $(".valid-feedback").addClass("d-none"); 2833 } 2834 } 2835 }); 2836 }, 2837 submit: function submit() { 2838 $("form").on("submit", function (e) { 2839 return _validateForm.call(this, e); 2840 }); 2841 }, 2842 buttonClick: function buttonClick() { 2843 $("form button[type=\"submit\"], form input[type=\"submit\"]").on("click", function () { 2844 // clear all errors when trying to submit the form 2845 clearForm(); 2846 }); 2847 }, 2848 dateValidation: function dateValidation() { 2849 $(".input-birthDay").on("focusout", function () { 2850 if (!birthDayIsValid($(this))) { 2851 $(this)[0].setCustomValidity(resources["invalidBirthDay"]); 2852 $(this).trigger("invalid"); 2853 } else { 2854 $(this)[0].setCustomValidity(""); 2855 $(this).removeClass("is-invalid"); 2856 } 2857 }); 2858 }, 2859 functions: { 2860 validateForm: function validateForm(form, event) { 2861 _validateForm.call($(form), event || null); 2862 }, 2863 clearForm: clearForm 2864 } 2865}; 2866 2867/***/ }), 2868 2869/***/ 8851: 2870/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2871 2872/* eslint-disable quotes */ 2873var focusHelper = __webpack_require__(7768); 2874/** 2875 * Renders a modal window that will track the users consenting to accepting site tracking policy 2876 */ 2877 2878 2879function showConsentModal() { 2880 if (!$('.tracking-consent').data('caonline')) { 2881 return; 2882 } 2883 2884 var urlContent = $('.tracking-consent').data('url'); 2885 var urlAccept = $('.tracking-consent').data('accept'); 2886 var urlReject = $('.tracking-consent').data('reject'); 2887 var textYes = $('.tracking-consent').data('accepttext'); 2888 var textNo = $('.tracking-consent').data('rejecttext'); 2889 var textHeader = $('.tracking-consent').data('heading'); 2890 var htmlString = '<!-- Modal -->' + '<div class="modal show" id="consent-tracking" aria-modal="true" role="dialog" style="display: block;">' + '<div class="modal-dialog">' + '<!-- Modal content-->' + '<div class="modal-content">' + '<div class="modal-header">' + textHeader + '</div>' + '<div class="modal-body"></div>' + '<div class="modal-footer">' + '<div class="button-wrapper d-flex justify-content-center justify-content-md-end mt-2 m-3 px-3 px-md-5">' + '<button class="decline btn button-secondary mr-3" data-url="' + urlReject + '" data-dismiss="modal" >' + textNo + '</button>' + '<button class="affirm btn button-dark2" data-url="' + urlAccept + '" autofocus data-dismiss="modal">' + textYes + '</button>' + '</div>' + '</div>' + '</div>' + '</div>' + '</div>'; 2891 $('body').append(htmlString); 2892 $.ajax({ 2893 url: urlContent, 2894 type: 'get', 2895 dataType: 'html', 2896 success: function success(response) {
2897 $('#consent-tracking .modal-body').html(response); 2898 $('#consent-tracking').modal('show'); 2899 }, 2900 error: function error() { 2901 $('#consent-tracking').remove(); 2902 } 2903 }); 2904 $('#consent-tracking .button-wrapper button').click(function (e) { 2905 e.preventDefault(); 2906 var url = $(this).data('url'); 2907 $.ajax({ 2908 url: url, 2909 type: 'get', 2910 dataType: 'json', 2911 success: function success() { 2912 $('#consent-tracking').remove(); 2913 }, 2914 error: function error() { 2915 $('#consent-tracking').remove(); 2916 } 2917 }); 2918 }); 2919} 2920 2921module.exports = function () { 2922 if ($('.consented').length === 0 && $('.tracking-consent').hasClass('api-true')) { 2923 showConsentModal(); 2924 } 2925 2926 if ($('.tracking-consent').hasClass('api-true')) { 2927 $('.tracking-consent').click(function () { 2928 showConsentModal(); 2929 }); 2930 } 2931 2932 $('body').on('shown.bs.modal', '#consent-tracking', function () { 2933 $('#consent-tracking').siblings().attr('aria-hidden', 'true'); 2934 $('#consent-tracking .close').focus(); 2935 }); 2936 $('body').on('hidden.bs.modal', '#consent-tracking', function () { 2937 $('#consent-tracking').siblings().attr('aria-hidden', 'false'); 2938 }); 2939 $('body').on('keydown', '#consent-tracking', function (e) { 2940 var focusParams = { 2941 event: e, 2942 containerSelector: '#consent-tracking', 2943 firstElementSelector: '.affirm', 2944 lastElementSelector: '.decline', 2945 nextToLastElementSelector: '.affirm' 2946 }; 2947 focusHelper.setTabNextFocus(focusParams); 2948 }); 2949}; 2950 2951/***/ }), 2952 2953/***/ 8269: 2954/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2955 2956var scrollAnimate = __webpack_require__(1184); 2957 2958var $cache = {}; 2959 2960function initCache() { 2961 $cache = { 2962 body: $("body"), 2963 emailSignupMessage: $(".email-signup-message"), 2964 backToTop: $(".back-to-top"), 2965 footerNewsletterForm: $(".footer-newsletter-form") 2966 }; 2967 return $cache;
2968} 2969/** 2970 * appends params to a url 2971 * @param {string} data - data returned from the server's ajax call 2972 * @param {Object} button - button that was clicked for email sign-up 2973 * @param {Object} $form - form used 2974 */ 2975 2976 2977function displayMessage(data, button, $form) { 2978 $.spinner().stop(); 2979 2980 if (data.success) { 2981 $form.find(".invalid-feedback").removeClass("d-block").addClass("d-none"); 2982 $form.find(".valid-feedback").removeClass("d-none").addClass("d-block").text(data.msg); 2983 } else { 2984 $form.find(".valid-feedback").removeClass("d-block").addClass("d-none"); 2985 $form.find(".invalid-feedback").removeClass("d-none").addClass("d-block").text(data.msg); 2986 } 2987 2988 setTimeout(function () { 2989 $form.find(".valid-feedback").text(""); 2990 $form.find(".invalid-feedback").text(""); 2991 button.removeAttr("disabled"); 2992 }, 4000); 2993} 2994 2995module.exports = function () { 2996 $cache = initCache(); 2997 $cache.backToTop.click(function () { 2998 scrollAnimate(); 2999 }); 3000 $cache.footerNewsletterForm.on("submit", function (e) { 3001 e.preventDefault(); 3002 var $this = $(this); 3003 var url = $this.attr("action"); 3004 var button = $this.find("button[type='submit']"); 3005 var emailId = $this.find("input").val(); 3006 $.spinner().start(); 3007 $this.attr("disabled", true); 3008 $.ajax({ 3009 url: url, 3010 type: "post", 3011 dataType: "json", 3012 data: { 3013 emailId: emailId 3014 }, 3015 success: function success(data) { 3016 displayMessage(data, button, $this); 3017 }, 3018 error: function error(err) { 3019 displayMessage(err, button, $this); 3020 } 3021 }); 3022 }); 3023}; 3024 3025/***/ }), 3026 3027/***/ 2385: 3028/***/ ((module) => { 3029 3030/** 3031 * @description Form field formatters: 3032 * - phones 3033 */ 3034function initPhoneFieldFormatters() { 3035 $('.formatter--phone').mask('0#'); //only numbers will be allowed inside the form field. 3036} 3037 3038function init() { 3039 initPhoneFieldFormatters(); 3040} 3041 3042module.exports = { 3043 init: init, 3044 // semantic symlink 3045 refresh: init, 3046 initPhoneFieldFormatters: initPhoneFieldFormatters 3047}; 3048 3049/***/ }), 3050 3051/***/ 8759: 3052/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3053 3054var debounce = (__webpack_require__(4443).debounce); 3055 3056var utils = __webpack_require__(4443); 3057 3058var $window = $(window); 3059var $body = $("body"); 3060var $header = $("header"); 3061/** 3062* Checks if the header should be sticky or not. In case header is simplified, it doesn`t have sticky functionality 3063*/ 3064 3065function checkSticky() { 3066 var isMobile = utils.isMobile(); 3067 3068 if (!$(".header").hasClass("simple-header")) { 3069 $body.addClass("header-sticky"); 3070 3071 if (isMobile) { 3072 $body.css("padding-top", $header.outerHeight()); 3073 } 3074 } else { 3075 $body.removeClass("header-sticky"); 3076 3077 if (isMobile) { 3078 $body.css("padding-top", ""); 3079 } 3080 } 3081} 3082 3083module.exports = function () { 3084 checkSticky(); 3085 $window.on("scroll", debounce(checkSticky)); 3086 $body.on("touchmove", debounce(checkSticky)); 3087}; 3088 3089/***/ }), 3090 3091/***/ 6087: 3092/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3093 3094"use strict"; 3095 3096 3097var utils = __webpack_require__(4443); 3098 3099var $window = $(window); 3100var $body = $("body"); 3101var $maincontent = $body.find("#maincontent"); 3102var $homeHeader = $body.find(".page[data-action='Home-Show'] header"); 3103var $header = $body.find("header.l-header"); 3104var $homePageSlot = $body.find(".homepage-slots"); 3105var $headerBanner = $body.find(".header-banner"); 3106var $mainHeaderDesktop = $body.find(".main-header-desktop"); 3107var $sectionHeaderDesktop = $mainHeaderDesktop.find(".section-header-desktop"); 3108var $navItems = $body.find(".navigation-l1-item"); 3109var $megaMenus = $navItems.find(".nav-desktop-header-megamenu"); 3110var $openSearchOverlayBtn = $header.find(".section-header-desktop-search .search-display .search-button"); 3111var $closeSearchOverlayBtn = $header.find(".search-overlay-close-button"); 3112var $desktopSearchOverlay = $header.find("div.desktop-search-overlay"); 3113var timeout; 3114var isHovering = false; 3115var COMPUTED_MIDDLE_MAX_HEIGHT = "middleHMaxComputed"; 3116var ADJUSTED_MIDDLE_ITEMS_CLASS = "middleItemsAdjusted"; 3117var isPDP = $(".page[data-action='Product-Show']").length; 3118var menuHeightTransform = 80; 3119/** 3120 * Check all menu elements 3121 * 3122 * @returns {boolean} is one elements not exists 3123 */ 3124 3125function checkElements() { 3126 var elements = [$body, $maincontent, $headerBanner, $mainHeaderDesktop, $sectionHeaderDesktop, $navItems, $megaMenus]; 3127 return elements.every(function (el) { 3128 return el.length; 3129 }); 3130} 3131/** 3132 * Should simplified or not 3133 * 3134 * @returns {Boolean} should simplified or not 3135 */ 3136 3137 3138function shouldSimplify() { 3139 return $window.scrollTop() > menuHeightTransform; 3140} 3141/** 3142 * Toggles the header background color based on the scroll position relative to the slider. 3143 * Adds 'bg-white' class if the bottom of the header passes the bottom of the slider. 3144 */ 3145 3146 3147function onHomePageScroll() { 3148 if (!$homeHeader.length) { 3149 return; 3150 } 3151 3152 setTimeout(function () { 3153 if ($window.scrollTop() > menuHeightTransform) { 3154 $homeHeader.addClass("bg-white"); 3155 } else if (!isHovering) { 3156 $homeHeader.removeClass("bg-white"); 3157 } 3158 }, 80); 3159} 3160/** 3161 * Handles scroll behavior for simplified header 3162 */ 3163 3164 3165function handleDisplayingSimplifiedHeader() { 3166 setTimeout(function () { 3167 if ($desktopSearchOverlay.hasClass("is-open")) { 3168 $desktopSearchOverlay.find("input.search-field").val("").trigger("focus").trigger("blur"); 3169 $desktopSearchOverlay.removeClass("is-open"); 3170 } 3171 3172 if (isPDP) { 3173 var $addToCartFixed = $body.find(".add-to-cart-fixed"); 3174 var isMixedOffer = $addToCartFixed.hasClass("mixed-offer-items__sticky-bar"); 3175 var shouldHideHeader; 3176 3177 if (isMixedOffer) { 3178 shouldHideHeader = $window.scrollTop() > menuHeightTransform; 3179 } else { 3180 shouldHideHeader = $addToCartFixed.length && $addToCartFixed.hasClass("show"); 3181 } 3182 3183 if (shouldHideHeader) { 3184 $header.addClass("hide-header"); 3185 } else { 3186 $header.removeClass("hide-header"); 3187 } 3188 } else { 3189 var isSimplified = shouldSimplify(); 3190 3191 if (isSimplified) { 3192 $sectionHeaderDesktop.addClass("is-simplified"); 3193 } else { 3194 $sectionHeaderDesktop.removeClass("is-simplified"); 3195 } 3196 3197 $window.trigger("resize"); 3198 } 3199 }, 300); 3200} 3201/** 3202 * Initialize desktop header UI events (navigation, mega menu, scroll, 3203 * search overlay, and responsive layout behaviors). 3204 */ 3205 3206 3207function initEvents() { 3208 $navItems.off("mouseenter").on("mouseenter", function () { 3209 var $this = $(this); 3210 clearTimeout(timeout); 3211 $navItems.find("a.navigation-l1-link").css("font-weight", "600"); 3212 $this.find("a.navigation-l1-link").css("font-weight", "700"); 3213 $megaMenus.removeClass("show"); 3214 $homeHeader.removeClass("bg-white"); 3215 var $megaMenu = $this.find(".nav-desktop-header-megamenu"); 3216 3217 if (!$megaMenu.length) { 3218 onHomePageScroll(); 3219 return; 3220 } 3221 3222 isHovering = true; 3223 onHomePageScroll(); 3224 $megaMenu.addClass("show"); 3225 $homeHeader.addClass("bg-white"); 3226 var $middle = $megaMenu.find(".nav-desktop-header-megamenu-maincontent-mid
3226dle"); 3227 computeMiddleMaxHeightIfNecessary($middle); 3228 adjustMiddleItems($middle); 3229 adjustMegaMenuPosition(); 3230 }); 3231 $navItems.off("mouseleave").on("mouseleave", function () { 3232 isHovering = false; 3233 timeout = setTimeout(function () { 3234 $navItems.find("a.navigation-l1-link").css("font-weight", "600"); 3235 $megaMenus.removeClass("show"); 3236 $homeHeader.removeClass("bg-white"); 3237 onHomePageScroll(); 3238 }, 50); 3239 }); 3240 $window.on("load resize", function () { 3241 setTimeout(function () { 3242 $megaMenus.find(".nav-desktop-header-megamenu-maincontent-middle").removeClass(COMPUTED_MIDDLE_MAX_HEIGHT).removeClass(ADJUSTED_MIDDLE_ITEMS_CLASS); 3243 initMainContentPagePosition(); 3244 adjustMegaMenuPosition(); 3245 }, 100); 3246 }); 3247 3248 if ($homeHeader.length) { 3249 $window.off("scroll", onHomePageScroll).on("scroll", onHomePageScroll); 3250 onHomePageScroll(); 3251 } 3252 3253 $window.off("scroll", handleDisplayingSimplifiedHeader).on("scroll", handleDisplayingSimplifiedHeader); 3254 handleDisplayingSimplifiedHeader(); 3255 $body.on("after:close:header-banner", function () { 3256 initHomeSliderPosition(); 3257 initMainContentPagePosition(); 3258 adjustMegaMenuPosition(); 3259 }); 3260 $body.off("search:after:response", onSuggestionsClose).on("search:after:response", onSuggestionsClose); 3261 $openSearchOverlayBtn.off("click").on("click", function () { 3262 if (!shouldSimplify()) { 3263 $sectionHeaderDesktop.addClass("is-simplified"); 3264 } 3265 3266 $desktopSearchOverlay.toggleClass("is-open"); 3267 var $input = $desktopSearchOverlay.find("input.search-field"); 3268 3269 if ($desktopSearchOverlay.hasClass("is-open") && $input.val() === "") { 3270 setTimeout(function () { 3271 $input.trigger("focus"); 3272 }, 200); 3273 } 3274 }); 3275 $closeSearchOverlayBtn.off("click").on("click", function () { 3276 $desktopSearchOverlay.removeClass("is-open"); 3277 $window.trigger("scroll"); 3278 }); 3279 $sectionHeaderDesktop.find(".section-header-desktop-actions .search-field").off("click focus", handleDisplaySearchField).on("click focus", handleDisplaySearchField); 3280} 3281/** 3282 * Triggers the opening of the desktop search overlay. 3283 */ 3284 3285 3286function handleDisplaySearchField() { 3287 $openSearchOverlayBtn.trigger("click"); 3288} 3289/** 3290 * Initializes the suggestions close button functionality. 3291 * When clicked, clears the search field input and triggers a body click event 3292 * to close the suggestions dropdown. 3293 */ 3294 3295 3296function onSuggestionsClose() { 3297 $(".suggestions button.suggestions-close").off("click").on("click", function () { 3298 $body.trigger("click"); 3299 $("input.search-field").val(""); 3300 }); 3301} 3302/** 3303 * Sets the max height of the middle section in the mega menu if not already computed. 3304 * 3305 * @param {jQuery} $middle - jQuery object for the target middle section. 3306 * 3307 * This function assigns a max height to `$middle` if it has at least three items 3308 * and hasn't been processed. The height adjusts iteratively to ensure all items 3309 * align in a single column. 3310 */ 3311 3312 3313function computeMiddleMaxHeightIfNecessary($middle) { 3314 var $middles = $megaMenus.find(".nav-desktop-header-megamenu-maincontent-middle:not(." + COMPUTED_MIDDLE_MAX_HEIGHT + ")"); 3315 3316 if (!$middles.length || !$middle.length || $middle.hasClass(COMPUTED_MIDDLE_MAX_HEIGHT)) { 3317 return; 3318 } 3319 3320 var middleMaxHeightValueDefault = 72; // cf _navigationDesktop.scss 3321 3322 var middleMaxHeightValue = middleMaxHeightValueDefault; 3323 var $items = $middle.find(".item-megamenu"); 3324 3325 if ($items.length < 3) { 3326 $middle.addClass(COMPUTED_MIDDLE_MAX_HEIGHT); 3327 return; 3328 } 3329 3330 $middle.css("max-height", middleMaxHeightValue + "vh"); 3331 3332 while ($($items[0]).position().left === $($items[$items.length - 1]).position().left) { 3333 middleMaxHeightValue -= 5; 3334 $middle.css("max-height", middleMaxHeightValue + "vh"); 3335 } 3336 3337 $middle.addClass(COMPUTED_MIDDLE_MAX_HEIGHT); 3338} 3339/** 3340 * Adjusts the vertical position of mega menus based on the combined heights of 3341 * the header banner and navigation header, plus a small offset. 3342 */ 3343 3344 3345function adjustMegaMenuPosition() { 3346 var topValPx = $("header.l-header").height() + 1; 3347 $megaMenus.css("top", topValPx + "px"); 3348} 3349/** 3350 * Initializes the home slider position by setting the main content's top margin 3351 * based on the header banner's height. If not on the home page, no adjustment is made. 3352 * 3353 * @function initHomeSliderPosition 3354 * @returns {void} 3355 */ 3356 3357 3358function initHomeSliderPosition() { 3359 if (!$homePageSlot.length) { 3360 return; 3361 } 3362 3363 var headerBannerHeight = $headerBanner.length ? $headerBanner.height() : 0; 3364 $maincontent.css("margin-top", headerBannerHeight + "px"); 3365} 3366/** 3367 * Initializes the main content page position by setting its top margin 3368 * based on the header's height. Skips adjustment if on the home page. 3369 * 3370 * @function initMainContentPagePosition 3371 * @returns {void} 3372 */ 3373 3374 3375function initMainContentPagePosition() { 3376 if ($homePageSlot.length) { 3377 return; 3378 } 3379 3380 $maincontent.css("margin-top", $header.height() + "px"); 3381} 3382/** 3383 * Counts the number of unique columns of items in a megamenu. 3384 * It determines the columns based on the left position of each item. 3385 * 3386 * @function nbMiddleItemsColumns 3387 * @param {jQuery}
3387 $currentMiddle - The jQuery object containing the middle items. 3388 * @returns {number|void} - The number of unique columns or undefined if no items are found. 3389 */ 3390 3391 3392function nbMiddleItemsColumns($currentMiddle) { 3393 if (!$currentMiddle || !$currentMiddle.length) { 3394 return; 3395 } 3396 3397 var obj = {}; 3398 $currentMiddle.find(".item-megamenu").each(function () { 3399 var $currentItem = $(this); 3400 var left = $currentItem.position().left; 3401 obj[left + ""] = left; 3402 }); 3403 return Object.keys(obj).length; 3404} 3405/** 3406 * Adjusts margins of middle items in a megamenu to fit within a maximum of two columns. 3407 * If the number of columns exceeds two, reduces bottom margin of items, 3408 * top margin of the "See All" button, and top margin of the item first div 3409 * until the items fit in two columns. 3410 * 3411 * @function adjustMiddleItems 3412 * @param {jQuery} $middle - The jQuery object for the middle items to adjust. 3413 * @returns {void} 3414 */ 3415 3416 3417function adjustMiddleItems($middle) { 3418 var $middles = $megaMenus.find(".nav-desktop-header-megamenu-maincontent-middle:not(." + ADJUSTED_MIDDLE_ITEMS_CLASS + ")"); 3419 3420 if (!$middles.length || !$middle.length || $middle.hasClass(ADJUSTED_MIDDLE_ITEMS_CLASS)) { 3421 return; 3422 } 3423 3424 var $item = $middle.find(".item-megamenu"); 3425 var itemMarginBottomValue = 24; // cf _navigationDesktop.scss 3426 3427 var $seeAllBtn = $item.find(".btn-seeall-secondary"); 3428 var btnSeeAllMarginTopValue = 8; // cf _navigationDesktop.scss 3429 3430 var $firstDiv = $item.find("div:first-of-type"); 3431 var firstDivItemMarginTopValue = 10; // cf _navigationDesktop.scss 3432 3433 $item.css("margin-bottom", itemMarginBottomValue + "px"); 3434 $seeAllBtn.css("margin-top", btnSeeAllMarginTopValue + "px"); 3435 $firstDiv.css("margin-top", firstDivItemMarginTopValue + "px"); 3436 var nbColumns = nbMiddleItemsColumns($middle); 3437 3438 if (nbColumns <= 2) { 3439 $middle.addClass(ADJUSTED_MIDDLE_ITEMS_CLASS); 3440 return; 3441 } 3442 3443 do { 3444 itemMarginBottomValue -= 1; 3445 btnSeeAllMarginTopValue -= 1; 3446 firstDivItemMarginTopValue -= 1; 3447 $item.css("margin-bottom", itemMarginBottomValue + "px"); 3448 $seeAllBtn.css("margin-top", btnSeeAllMarginTopValue + "px"); 3449 $firstDiv.css("margin-top", firstDivItemMarginTopValue + "px"); 3450 nbColumns = nbMiddleItemsColumns($middle); 3451 } while (nbColumns > 2); 3452 3453 $middle.addClass(ADJUSTED_MIDDLE_ITEMS_CLASS); 3454} 3455/** 3456 * Initializes the module by checking if the environment is not mobile and if the required elements are present. 3457 * If both conditions are met, it sets up the necessary event handlers. 3458 * 3459 * @returns {void} 3460 */ 3461 3462 3463function init() { 3464 if (utils.isMobile()) { 3465 return; 3466 } 3467 3468 if (!checkElements()) { 3469 return; 3470 } 3471 3472 initHomeSliderPosition(); 3473 initMainContentPagePosition(); 3474 initEvents(); 3475} 3476 3477module.exports = { 3478 init: init 3479}; 3480 3481/***/ }), 3482 3483/***/ 6277: 3484/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3485 3486"use strict"; 3487 3488 3489var utils = __webpack_require__(4443); 3490 3491var $window = $(window); 3492var $body = $("body"); 3493var $mainHeader = $body.find("header.l-header"); 3494var $mainHeaderMobile = null; 3495var $header = null; 3496var $menu = null; 3497var $blocCenter = null; 3498var $blocRight = null; 3499var $blocSearch = null; 3500var $searchBtn = null; 3501var $btnCloseMenu = null; 3502var $btnMenu = null; 3503var $spanToggle = null; 3504var $toggleArrow = null; 3505var menuHeightTranslate = null; 3506var lastScrollTop = null; 3507/** 3508 * Check all menu elements 3509 * 3510 * @returns {boolean} is one elements not exists 3511 */ 3512 3513function checkElements() { 3514 var elements = [$body, $mainHeader, $mainHeaderMobile, $header, $menu, $blocCenter, $blocRight, $blocSearch, $searchBtn, $btnMenu, $btnCloseMenu, $spanToggle, $toggleArrow]; 3515 return elements.every(function (el) { 3516 return el.length; 3517 }); 3518} 3519/** 3520 * Determines the current scroll direction based on the change in scroll position. 3521 * Updates the global `lastScrollTop` variable to the current scrollTop (clamped to 0 for iOS bounce). 3522 * 3523 * @returns {string} - "toBottom" if scrolling down, "toTop" if scrolling up. 3524 */ 3525 3526 3527function getScrollDirection() { 3528 var scrollTop = window.pageYOffset || document.documentElement.scrollTop; 3529 var direction = null; 3530 3531 if (scrollTop > lastScrollTop) { 3532 direction = "toBottom"; 3533 } else { 3534 direction = "toTop"; 3535 } 3536 3537 lastScrollTop = scrollTop <= 0 ? 0 : scrollTop; // For iOS (bounce effect) 3538 3539 return direction; 3540} 3541/** 3542 * Handles scroll behavior for header 3543 */ 3544 3545 3546function handleDisplayingHeader() { 3547 var dir = getScrollDirection(); 3548 setTimeout(function () { 3549 var shouldHideHeader = dir === "toBottom" && $window.scrollTop() > menuHeightTranslate; 3550 3551 if (shouldHideHeader) { 3552 $mainHeader.addClass("hide-header"); 3553 } else { 3554 $mainHeader.removeClass("hide-header"); 3555 } 3556 }, 300); 3557} 3558/** 3559 * Initialize elements 3560 */ 3561 3562 3563function initEvents() { 3564 $btnMenu.off("click").on("click", function () { 3565 // if menu already open 3566 if (!$menu.hasClass("close")) { 3567 return; 3568 } 3569 3570 $menu.removeClass("close"); 3571 $body.css("overflow", "hidden"); 3572 }); 3573 $btnCloseMenu.off("click").on("click", function () { 3574 // if menu close 3575 if ($menu.hasClass("close")) { 3576 return; 3577 } 3578 3579 $menu.addClass("close"); 3580 $body.css("overflow", "initial"); 3581 });
3582 $blocSearch.find(".reset-button").off("click", function () { 3583 return $body.on("click"); 3584 }).on("click", function () { 3585 return $body.on("click"); 3586 }); 3587 $spanToggle.off("click").on("click", function () { 3588 $(this).siblings("button").trigger("click"); 3589 }); 3590 $toggleArrow.off("click").on("click", function (event) { 3591 event.stopImmediatePropagation(); 3592 var $this = $(this); // Close all other open menus before opening the new one 3593 3594 $toggleArrow.not($this).each(function () { 3595 toggleMenu($(this), "close"); 3596 }); // Open or close the menu depending on its current state 3597 3598 if ($this.hasClass("open")) { 3599 toggleMenu($this, "close"); 3600 } else { 3601 toggleMenu($this, "open"); 3602 } 3603 }); 3604 $body.off("after:minicart:count:updated").on("after:minicart:count:updated", function () { 3605 $menu.animate({ 3606 scrollTop: 0 3607 }, 300); 3608 }); 3609 $window.off("scroll", handleDisplayingHeader).on("scroll", handleDisplayingHeader); 3610 handleDisplayingHeader(); 3611} 3612/** 3613 * Toggles the visibility of a submenu based on the specified action. 3614 * Opens or closes the submenu, updates ARIA attributes, and scrolls to the arrow element if opened. 3615 * 3616 * @param {jQuery} $arrow - The arrow element that triggers the menu toggle. 3617 * @param {string} action - The action to perform ("open" or "close"). 3618 */ 3619 3620 3621function toggleMenu($arrow, action) { 3622 if (!$arrow || !$arrow.length || !action) { 3623 return; 3624 } 3625 3626 var $parentToggle = $arrow.parents(".toggle").eq(0); 3627 var $submenuL2 = $parentToggle.find(".submenu.nav-mobile-l2:first"); 3628 var $signElement = $parentToggle.find(".nav-mobile-body-cat-menu-item-sign:first"); 3629 3630 if (action === "open") { 3631 $submenuL2.removeClass("d-none").addClass("d-block").attr("aria-hidden", "false"); 3632 $signElement.addClass("open"); 3633 $arrow.addClass("open").attr("aria-expanded", "true"); 3634 $menu.animate({ 3635 scrollTop: $arrow[0].offsetTop 3636 }, 300); 3637 } else if (action === "close") { 3638 $submenuL2.removeClass("d-block").addClass("d-none").attr("aria-hidden", "true"); 3639 $signElement.removeClass("open"); 3640 $arrow.removeClass("open").attr("aria-expanded", "false"); 3641 } 3642} 3643/** 3644 * Initialize mobile menu 3645 * 3646 * @returns {void} 3647 */ 3648 3649 3650function init() { 3651 if (!utils.isMobile()) { 3652 return; 3653 } // For iPhone, to avoid issue about input focus (zoom) 3654 3655 3656 $("<meta name='viewport' content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no'>").appendTo(document.head); // Move #nav-mobile after .main-header-mobile .section-header-mobile 3657 3658 $(function () { 3659 var $navMobile = $("#nav-mobile"); 3660 var $navMobileHeader = $(".main-header-mobile .section-header-mobile"); 3661 3662 if ($navMobile.length && $navMobileHeader.length) { 3663 $navMobile.insertAfter($navMobileHeader); 3664 } 3665 }); 3666 $mainHeaderMobile = $mainHeader.find(".main-header-mobile"); 3667 $header = $mainHeaderMobile.find("section.section-header-mobile"); 3668 $menu = $(".nav-mobile"); 3669 $blocCenter = $header.find(".section-header-mobile-center"); 3670 $blocRight = $header.find(".section-header-mobile-right"); 3671 $blocSearch = $mainHeaderMobile.find("div.search"); 3672 $searchBtn = $blocSearch.find(".search-button"); 3673 $btnCloseMenu = $menu.find("button.navbar-close"); 3674 $btnMenu = $header.find("#navbar-toggler"); 3675 $spanToggle = $menu.find(".nav-mobile-body-cat li.toggle > span.nav-mobile-body-cat-menu-item-title"); 3676 $toggleArrow = $menu.find(".nav-mobile-body-cat .toggle .nav-mobile-body-cat-menu-item-sign"); 3677 menuHeightTranslate = $mainHeader.height(); 3678 lastScrollTop = $window.scrollTop(); 3679 3680 if (!checkElements()) { 3681 return; 3682 } 3683 3684 initEvents(); 3685} 3686 3687module.exports = { 3688 init: init 3689}; 3690 3691/***/ }), 3692 3693/***/ 9063: 3694/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3695 3696var cart = __webpack_require__(754); 3697 3698var utils = __webpack_require__(4443); 3699 3700var updateMiniCart = true; 3701 3702var getMinicart = function getMinicart() { 3703 var $miniCart = $(".minicart.section-header-desktop-cart"); 3704 3705 if (!$miniCart.length) { 3706 $miniCart = $(".minicart"); 3707 } 3708 3709 var url = $miniCart.data("action-url"); 3710 $(".minicart .minicart-content").addClass("show"); 3711 $(".minicart .minicart-content").spinner().start(); 3712 $.get(url, function (data) { 3713 $(".minicart .minicart-content").empty(); 3714 $(".minicart .minicart-content").append(data); 3715 $(document).trigger("miniCartReinintSelect", [$(".select-minicart-quantity:not(.selectToBox, .selectToQty)")]); 3716 updateMiniCart = false;
3717 $.spinner().stop(); 3718 }); 3719}; 3720 3721module.exports = function () { 3722 cart(); 3723 $("body").on("product:afterAddToCart", function () { 3724 if (window.Foundation.MediaQuery.atLeast("md")) { 3725 getMinicart(); 3726 setTimeout(function () { 3727 $(".minicart .minicart-content").removeClass("show"); 3728 }, 3000); 3729 } 3730 }); 3731 $(".minicart").on("count:update", function (event, count) { 3732 if (count && $.isNumeric(count.quantityTotal)) { 3733 $(".minicart .minicart-quantity").text(utils.displayCartQty(count.quantityTotal)); 3734 $(".minicart .minicart-link").attr({ 3735 "aria-label": count.minicartCountOfItems, 3736 title: count.minicartCountOfItems 3737 }); 3738 $("body").trigger("after:minicart:count:updated"); 3739 } 3740 }); 3741 $(".minicart").on("mouseenter focusin touchstart", function () { 3742 var count = parseInt($(".minicart .minicart-quantity").text(), 10); 3743 3744 if (count !== 0 && $(".minicart .minicart-content.show").length === 0) { 3745 if (!updateMiniCart) { 3746 $(".minicart .minicart-content").addClass("show"); 3747 return; 3748 } 3749 3750 getMinicart(); 3751 } 3752 }); 3753 $("body").on("touchstart click", function (e) { 3754 if (!$(".minicart").has(e.target).length) { 3755 $(".minicart .minicart-content").removeClass("show"); 3756 } 3757 }); 3758 $(".minicart").on("mouseleave", function (event) { 3759 // Check if mouseleave is inside minicart by checking destination element 3760 // IE returns null relatedTarget when mouseleave happens on option element so use event.target for this case 3761 var inMiniCart = event.relatedTarget ? !!$(".minicart").has(event.relatedTarget).length : !!$(".minicart").has(event.target).length; 3762 3763 if (inMiniCart) { 3764 event.stopPropagation(); 3765 return; 3766 } 3767 3768 $(".minicart .minicart-content").removeClass("show"); 3769 }); 3770 $("body").on("change", ".minicart .quantity", function () { 3771 if ($(this).parents(".bonus-product-line-item").length && $(".cart-page").length) { 3772 location.reload(); 3773 } 3774 }); 3775 $("body").on("product:afterAddToCart", function () { 3776 updateMiniCart = true; 3777 }); 3778 $("body").on("cart:update", function () { 3779 updateMiniCart = true; 3780 }); 3781}; 3782 3783/***/ }), 3784 3785/***/ 4990: 3786/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 3787 3788var utils = __webpack_require__(4443); 3789 3790$(function () { 3791 if (!document.querySelector(".pd-carousel")) { 3792 return; 3793 } 3794 3795 var carouselTrack = document.querySelector(".carousel"); 3796 var prevBtn = document.querySelector(".prev"); 3797 var nextBtn = document.querySelector(".next"); 3798 var slideWidth; 3799 /** 3800 * Recalculates slide width and updates navigation arrows. 3801 * Called when carousel dimensions change (e.g., window resize). 3802 */ 3803 3804 function updateSlideWidth() { 3805 slideWidth = carouselTrack.querySelector(".slide").offsetWidth; 3806 updateArrows(); 3807 } 3808 3809 window.addEventListener("resize", updateSlideWidth); 3810 updateSlideWidth(); 3811 /** 3812 * Shows/hides navigation arrows based on carousel scroll position. 3813 * Hides prev arrow at start and next arrow at end of carousel. 3814 */ 3815 3816 function updateArrows() { 3817 var atStart = carouselTrack.scrollLeft === 0; 3818 var atEnd = carouselTrack.scrollLeft + carouselTrack.offsetWidth >= carouselTrack.scrollWidth - 1; // "-1" to tolerate very small pixel differences 3819 3820 prevBtn.style.visibility = atStart ? "hidden" : "visible"; 3821 nextBtn.style.visibility = atEnd ? "hidden" : "visible"; 3822 } // Buttons 3823 3824 3825 prevBtn.addEventListener("click", function (e) { 3826 e.preventDefault(); 3827 carouselTrack.scrollBy({ 3828 left: -slideWidth, 3829 behavior: "smooth" 3830 }); 3831 setTimeout(updateArrows, 600); // The adjustment is made after the scroll animation ends. 3832 }); 3833 nextBtn.addEventListener("click", function (e) { 3834 e.preventDefault(); 3835 carouselTrack.scrollBy({ 3836 left: slideWidth, 3837 behavior: "smooth" 3838 }); 3839 setTimeout(updateArrows, 600); 3840 }); 3841 carouselTrack.addEventListener("scroll", updateArrows); // Check arrows avaibility 3842 // Mouse dragging (desktop) 3843 3844 var isDown = false; 3845 var startX; 3846 var scrollLeft; 3847 carouselTrack.addEventListener("mousedown", function (e) { 3848 isDown = true; 3849 carouselTrack.classList.add("dragging"); 3850 startX = e.clientX; 3851 scrollLeft = carouselTrack.scrollLeft; 3852 }); 3853 carouselTrack.addEventListener("mouseleave", function () { 3854 isDown = false;
3855 carouselTrack.classList.remove("dragging"); 3856 }); 3857 carouselTrack.addEventListener("mouseup", function () { 3858 isDown = false; 3859 carouselTrack.classList.remove("dragging"); 3860 }); 3861 carouselTrack.addEventListener("mousemove", function (e) { 3862 if (!isDown) return; 3863 e.preventDefault(); 3864 var x = e.clientX; 3865 var walk = x - startX; 3866 carouselTrack.scrollLeft = scrollLeft - walk; 3867 }); 3868 /** 3869 * Adjusts carousel layout based on content fit and screen size. 3870 * Centers slides and hides navigation on desktop when all slides fit in viewport. 3871 */ 3872 3873 function checkSlidesFit() { 3874 var isMobile = utils.isMobile(); 3875 var totalSlidesWidth = carouselTrack.scrollWidth; 3876 var containerWidth = carouselTrack.clientWidth; 3877 3878 if (isMobile) { 3879 prevBtn.style.display = "none"; 3880 nextBtn.style.display = "none"; 3881 } else { 3882 if (!isMobile && totalSlidesWidth <= containerWidth) { 3883 carouselTrack.style.justifyContent = "center"; // centered only on desktop if not enough slides 3884 3885 prevBtn.style.display = "none"; 3886 nextBtn.style.display = "none"; 3887 } else { 3888 carouselTrack.style.justifyContent = "flex-start"; 3889 prevBtn.style.display = "block"; 3890 nextBtn.style.display = "block"; 3891 } 3892 } 3893 } 3894 3895 window.addEventListener("load", checkSlidesFit); 3896 window.addEventListener("resize", checkSlidesFit); 3897}); 3898 3899/***/ }), 3900 3901/***/ 7210: 3902/***/ ((module) => { 3903 3904/** 3905 * Sorts the <select> options in ascending order by the numeric value of data-attr-value. 3906 * @param {jQuery} $select - The <select> element to sort. 3907 */ 3908function sortOptionsByCapacity($select) { 3909 if (!$select.hasClass("select-Contenance")) { 3910 return; 3911 } 3912 3913 var $first = $select.find("option").first(); 3914 var $options = $select.find("option").not(":first").get(); 3915 $options.sort(function (a, b) { 3916 var capA = parseFloat($(a).data("attr-value")) || 0; 3917 var capB = parseFloat($(b).data("attr-value")) || 0; 3918 return capA - capB; 3919 }); 3920 $select.empty().append($first).append($options); 3921} 3922/** 3923 * Initializes the SelectToBox plugin, transforming select elements with the 3924 * "selectToBox" class into button groups for enhanced UI interaction. 3925 * 3926 * This function iterates over each select element with the "selectToBox" class, 3927 * converting them into a set of buttons that represent the options of the select. 3928 * It also sets up event listeners to synchronize the state between the original 3929 * select element and the generated buttons. 3930 * 3931 * The function does not take any parameters and does not return any value. 3932 * It modifies the DOM by hiding the original select elements and inserting 3933 * a new container with buttons. 3934 * 3935 * Side Effects: 3936 * - Alters the DOM by hiding select elements and adding button containers. 3937 * - Attaches event listeners to manage interactions and state synchronization. 3938 * 3939 * Exceptions: 3940 * - None explicitly thrown, but relies on jQuery and may fail if jQuery is not available. 3941 */ 3942 3943 3944function init() { 3945 // Plugin SelectToBox - Automatically transforms selects with the "selectToBox" class into buttons 3946 $(".selectToBox").each(function () { 3947 initSelectToBox($(this)); 3948 }); 3949 /** 3950 * Initializes a select element as a SelectToBox button group. 3951 * @param {jQuery} $select - The select element to transform. 3952 */ 3953 3954 function initSelectToBox($select) { 3955 if ($select.data("selecttobox-initialized")) { 3956 return; 3957 } 3958 3959 sortOptionsByCapacity($select); 3960 $select.data("selecttobox-initialized", true); 3961 $select.hide(); 3962 var selectId = $select.attr("id"); 3963 var $container = $("<div>", { 3964 "class": "selecttobox-buttons-container", 3965 "data-select-id": selectId 3966 }); 3967 var $wrapper = $("<div>", { 3968 "class": "selecttobox-buttons-wrapper" 3969 }); 3970 $select.find("option").each(function (index) { 3971 var $option = $(this); 3972 3973 if (index === 0) { 3974 return; 3975 } 3976 3977 var $button = $("<button>", { 3978 type: "button", 3979 "class": "selecttobox-btn" + ($option.attr("selected") ? " selected" : "") + ($option.attr("disabled") ? " disabled" : ""), 3980 "data-option-index": index, 3981 "data-option-value": $option.val(), 3982 "data-attr-value": $option.data("attr-value"), 3983 disabled: $option.prop("disabled") || $select.prop("disabled"), 3984 text: $option.text() 3985 }); 3986 $wrapper.append($button); 3987 }); 3988 $container.append($wrapper); 3989 $select.after($container); 3990 bindSelectToBoxEvents($select, $container); 3991 } 3992 /** 3993 * Binds event handlers for a SelectToBox instance. 3994 * @param {jQuery} $select - The original select element. 3995 * @param {jQuery} $container - The generated buttons container. 3996 */ 3997 3998 3999 function bindSelectToBoxEvents($select, $container) { 4000 var $buttons = $container.find(".selecttobox-btn"); 4001 $buttons.on("click", function (e) { 4002 e.preventDefault(); 4003 var $button = $(this); 4004 4005 if ($button.hasClass("disabled") || $button.prop("disabled")) { 4006 return; 4007 } 4008 4009 if ($button.hasClass("selected")) { 4010 $buttons.removeClass("selected"); 4011 $select.prop("selectedIndex", 0); 4012 $select.trigger("change"); 4013 } else { 4014 $buttons.removeClass("selected"); 4015 $button.addClass("selected"); 4016 var optionIndex = $button.data("option-index"); 4017 $select.prop("selectedIndex", optionIndex); 4018 $select.trigger("change"); 4019 } 4020 }); // Synchronisation select -> buttons 4021 4022 $select.on("change.selecttobox", function () { 4023 var selectedIndex = $select.prop("selectedIndex"); 4024 $buttons.removeClass("selected"); 4025 4026 if (selectedIndex > 0) { 4027 var $targetButton = $buttons.filter("[data-option-index=\"".concat(selectedIndex, "\"]")); 4028 $targetButton.addClass("selected"); 4029 } 4030 }); // Synchronisation of disabled states 4031 4032 $select.on("change.selecttobox-state", function () { 4033 updateButtonStates($select, $buttons); 4034 }); 4035 4036 if (window.MutationObserver) { 4037 var observer = new MutationObserver(function (mutations) { 4038 mutations.forEach(function (mutation) { 4039 if (mutation.type === "attributes") { 4040 if (mutation.attributeName === "disabled") { 4041 updateButtonStates($select, $buttons); 4042 } 4043 } else if (mutation.type === "childList") { 4044 recreateButtons($select, $container); 4045 } 4046 }); 4047 }); 4048 observer.observe($select[0], { 4049 attributes: true, 4050 childList: true, 4051 subtree: true 4052 }); 4053 $select.data("selecttobox-observer", observer); 4054 } 4055 } 4056 /** 4057 * Updates the disabled state of all buttons based on the select and options state. 4058 * @param {jQuery} $select - The original select element. 4059 * @param {jQuery} $buttons - The generated buttons. 4060 */ 4061 4062 4063 function updateButtonStates($select, $buttons) { 4064 var selectDisabled = $select.prop("disabled"); 4065 $buttons.each(function () { 4066 var $button = $(this); 4067 var optionIndex = $button.data("option-index"); 4068 var $option = $select.find("option").eq(optionIndex); 4069 var optionDisabled = $option.prop("disabled"); 4070 4071 if (selectDisabled || optionDisabled) { 4072 $button.addClass("disabled").prop("disabled", true); 4073 } else { 4074 $button.removeClass("disabled").prop("disabled", false); 4075 } 4076 }); 4077 } 4078 /** 4079 * Recreates buttons when the original select options change. 4080 * @param {jQuery} $select - The original select element. 4081 * @param {jQuery} $container - The buttons container. 4082 */ 4083 4084 4085 function recreateButtons($select, $container) { 4086 $container.find(".selecttobox-buttons-wrapper").empty(); 4087 var $wrapper = $container.find(".selecttobox-buttons-wrapper"); 4088 $select.find("option").each(function (index) { 4089 var $option = $(this); 4090 4091 if (index === 0) { 4092 return; 4093 } 4094 4095 var $button = $("<button>", { 4096 type: "button", 4097 "class": "selecttobox-btn" + ($option.prop("selected") ? " selected" : "") + ($option.prop("disabled") ? " disabled" : ""), 4098 "data-option-index": index, 4099 "data-option-value": $option.val(), 4100 "data-attr-value": $option.data("attr-value"), 4101 disabled: $option.prop("disabled") || $select.prop("disabled"), 4102 text: $option.text() 4103 }); 4104 $wrapper.append($button); 4105 }); 4106 bindSelectToBoxEvents($select, $container); 4107 } 4108 /** 4109 * Public API: Initializes SelectToBox on dynamically added elements. 4110 * @param {string} selector - jQuery selector for select elements to initialize. 4111 */ 4112 4113 4114 window.initSelectToBox = function (selector) { 4115 $(selector).each(function () { 4116 initSelectToBox($(this)); 4117 }); 4118 }; 4119 /** 4120 * Public API: Destroys SelectToBox instance and restores original select element. 4121 * @param {string} selector - jQuery selector for SelectToBox instances to destroy. 4122 */ 4123 4124 4125 window.destroySelectToBox = function (selector) { 4126 $(selector).each(function () { 4127 var $select = $(this); 4128 var selectId = $select.attr("id"); 4129 var $container = $("[data-select-id=\"".concat(selectId, "\"]")); 4130 var observer = $select.data("selecttobox-observer"); 4131 4132 if (observer) { 4133 observer.disconnect(); 4134 } 4135 4136 $select.off(".selecttobox"); 4137 $container.remove(); 4138 $select.show(); 4139 $select.removeData("selecttobox-initialized"); 4140 }); 4141 }; 4142} 4143 4144module.exports = { 4145 init: init 4146}; 4147 4148/***/ }), 4149 4150/***/ 4039: 4151/***/ ((module) => { 4152 4153"use strict"; 4154 4155/** 4156 * Dynamically processes elements with the class "readmore-text" to truncate content 4157 * beyond a specified number of lines and provides a toggle button to expand/collapse the text. 4158 * 4159 * Steps performed for each ".readmore-text" element: 4160 * 1. Calculates the line height and maximum allowed lines (from data-max-lines attribute or defaults to 5). 4161 * 2. If the full content height does not exceed the collapsed height, no action is taken. 4162 * 3. Otherwise: 4163 * - Truncates the text by setting a max-height and adds the "collapsed" class. 4164 * - Inserts a "Read more" button after the element. 4165 * 4. Handles button click events to toggle between expanded/collapsed
4165states: 4166 * - Expands to full height and changes button text to "Read less". 4167 * - Collapses the text and scrolls the page to align the element neatly below the header. 4168 * 4169 * Dependencies: 4170 * - Requires jQuery for DOM manipulation and event handling. 4171 * - Relies on CSS for styling (e.g., line-height, transitions if needed). 4172 * 4173 * Notes: 4174 * - The scroll animation on collapse accounts for a fixed header (adjust selector if necessary). 4175 * - Uses inline styles for max-height; ensure no conflicting CSS rules. 4176 */ 4177 4178function process() { 4179 var readMoreTxt = $("input[name='labelReadMore']").val() || "Lire plus"; 4180 var readLessTxt = $("input[name='labelReadLess']").val() || "Lire moins"; 4181 $(".readmore-text").each(function () { 4182 var $text = $(this); // Avoid twice process 4183 4184 if ($text.data("readmore-initialized")) { 4185 return; 4186 } // Already processed 4187 4188 4189 $text.data("readmore-initialized", true); 4190 var lineHeight = parseFloat($text.css("line-height")) || 20; 4191 var maxLines = parseInt($text.data("max-lines") || 5, 10); 4192 var collapsedHeight = Math.floor(lineHeight * maxLines); 4193 var fullHeight = $text.prop("scrollHeight"); 4194 4195 if (fullHeight <= collapsedHeight) { 4196 return; 4197 } 4198 4199 $text.addClass("collapsed").css("max-height", collapsedHeight + "px"); 4200 var $btn = $("<button class=\"readmore-btn\">" + readMoreTxt + "</button>"); 4201 $btn.insertAfter($text); 4202 var expanded = false; 4203 $btn.on("click", function () { 4204 expanded = !expanded; 4205 4206 if (expanded) { 4207 $text.removeClass("collapsed").css("max-height", fullHeight + "px"); 4208 $btn.text(readLessTxt); 4209 } else { 4210 $text.addClass("collapsed").css("max-height", collapsedHeight + "px"); 4211 $btn.text(readMoreTxt); 4212 $("html, body").animate({ 4213 scrollTop: $text.offset().top - $("header.l-header").height() - 120 4214 }, 300, "swing"); 4215 } 4216 }); 4217 }); 4218} 4219 4220function init() { 4221 $(function () { 4222 process(); 4223 }); 4224} 4225 4226module.exports = { 4227 init: init 4228}; 4229 4230/***/ }), 4231 4232/***/ 2973: 4233/***/ ((module) => { 4234 4235var resources = $('#resources').data('resources'); 4236module.exports = resources; 4237 4238/***/ }), 4239 4240/***/ 6074: 4241/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4242 4243function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 4244 4245var utils = __webpack_require__(4443); 4246 4247var debounce = __webpack_require__(613); 4248 4249var endpoint = $(".suggestions-wrapper").data("url"); 4250var minChars = 3; 4251var UP_KEY = 38; 4252var DOWN_KEY = 40; 4253var DIRECTION_DOWN = 1; 4254var DIRECTION_UP = -1; 4255/** 4256 * Retrieves Suggestions element relative to scope 4257 * 4258 * @param {Object} scope - Search input field DOM element 4259 * @return {JQuery} - .suggestions-wrapper element 4260 */ 4261 4262function getSuggestionsWrapper(scope) { 4263 return $(scope).parents(".site-search").siblings(".suggestions-wrapper"); 4264} 4265/** 4266 * Determines whether DOM element is inside the .search-mobile class 4267 * 4268 * @param {Object} scope - DOM element, usually the input.search-field element 4269 * @return {boolean} - Whether DOM element is inside div.search-mobile 4270 */ 4271 4272 4273function isMobileSearch(scope) { 4274 return !!$(scope).closest(".search-mobile").length; 4275} 4276/** 4277 * Remove modal classes needed for mobile suggestions 4278 * 4279 */ 4280 4281 4282function clearModals() { 4283 $("body").removeClass("modal-open"); 4284 $("header").siblings().attr("aria-hidden", "false"); 4285 $(".suggestions").removeClass("modal"); 4286} 4287/** 4288 * Apply modal classes needed for mobile suggestions 4289 * 4290 * @param {Object} scope - Search input field DOM element 4291 */ 4292 4293 4294function applyModals(scope) { 4295 if (isMobileSearch(scope)) { 4296 $("body").addClass("modal-open"); 4297 $("header").siblings().attr("aria-hidden", "true"); 4298 getSuggestionsWrapper(scope).find(".suggestions").addClass("modal"); 4299 } 4300} 4301/** 4302 * Tear down Suggestions panel 4303 */ 4304 4305 4306function tearDownSuggestions() { 4307 $("input.search-field").val(""); 4308 clearModals(); 4309 $(".search-mobile .suggestions").unbind("scroll"); 4310 $(".suggestions-wrapper").empty(); 4311} 4312/**
4313 * Toggle search field icon from search to close and vice-versa 4314 * 4315 * @param {string} action - Action to toggle to 4316 */ 4317 4318 4319function toggleSuggestionsIcon(action) { 4320 var mobileSearchIcon = ".search-mobile button."; 4321 var iconSearch = "fa-search"; 4322 var iconSearchClose = "fa-close"; 4323 4324 if (action === "close") { 4325 $(mobileSearchIcon + iconSearch).removeClass(iconSearch).addClass(iconSearchClose).attr("type", "button"); 4326 } else { 4327 $(mobileSearchIcon + iconSearchClose).removeClass(iconSearchClose).addClass(iconSearch).attr("type", "submit"); 4328 } 4329} 4330/** 4331 * Determines whether the "More Content Below" icon should be displayed 4332 * 4333 * @param {Object} scope - DOM element, usually the input.search-field element 4334 */ 4335 4336 4337function handleMoreContentBelowIcon(scope) { 4338 if ($(scope).scrollTop() + $(scope).innerHeight() >= $(scope)[0].scrollHeight) { 4339 $(".more-below").fadeOut(); 4340 } else { 4341 $(".more-below").fadeIn(); 4342 } 4343} 4344/** 4345 * Positions Suggestions panel on page 4346 * 4347 * @param {Object} scope - DOM element, usually the input.search-field element 4348 */ 4349 4350 4351function positionSuggestions(scope) { 4352 var outerHeight; 4353 var $scope; 4354 var $suggestions; 4355 var top; 4356 4357 if (isMobileSearch(scope)) { 4358 $scope = $(scope); 4359 top = $scope.offset().top; 4360 outerHeight = $scope.outerHeight(); 4361 $suggestions = getSuggestionsWrapper(scope).find(".suggestions"); 4362 $suggestions.css("top", top + outerHeight); 4363 handleMoreContentBelowIcon(scope); // Unfortunately, we have to bind this dynamically, as the live scroll event was not 4364 // properly detecting dynamic suggestions element's scroll event 4365 4366 $suggestions.scroll(function () { 4367 handleMoreContentBelowIcon(this); 4368 }); 4369 } 4370} 4371/** 4372 * Process Ajax response for SearchServices-GetSuggestions 4373 * 4374 * @param {Object|string} response - Empty object literal if null response or string with rendered 4375 * suggestions template contents 4376 */ 4377 4378 4379function processResponse(response) { 4380 var $suggestionsWrapper = getSuggestionsWrapper(this).empty(); 4381 4382 if (_typeof(response) !== "object") { 4383 $suggestionsWrapper.append(response).show(); 4384 positionSuggestions(this); 4385 4386 if (isMobileSearch(this)) { 4387 toggleSuggestionsIcon("close"); 4388 applyModals(this); 4389 } // Trigger screen reader by setting aria-describedby with the new suggestion message. 4390 4391 4392 var suggestionsList = $(".suggestions .item"); 4393 4394 if ($(suggestionsList).length) { 4395 $("input.search-field").attr("aria-describedby", "search-result-count"); 4396 } else { 4397 $("input.search-field").removeAttr("aria-describedby"); 4398 } 4399 4400 $("body").trigger("search:after:response", $suggestionsWrapper); 4401 } else { 4402 $suggestionsWrapper.hide(); 4403 } 4404} 4405/** 4406 * Retrieve suggestions 4407 * 4408 * @param {Object} scope - Search field DOM element 4409 */ 4410 4411 4412function getSuggestions(scope) { 4413 if ($(scope).val().length >= minChars) { 4414 $.ajax({ 4415 context: scope, 4416 url: endpoint + encodeURIComponent($(scope).val()), 4417 method: "GET", 4418 success: processResponse 4419 }); 4420 } else { 4421 toggleSuggestionsIcon("search"); 4422 $(scope).siblings(".reset-button").removeClass("d-sm-block"); 4423 clearModals(); 4424 getSuggestionsWrapper(scope).empty(); 4425 } 4426} 4427/** 4428 * Handle Search Suggestion Keyboard Arrow Keys 4429 * 4430 * @param {Integer} direction takes positive or negative number constant, DIRECTION_UP (-1) or DIRECTION_DOWN (+1) 4431 */ 4432 4433 4434function handleArrow(direction) { 4435 // get all li elements in the suggestions list 4436 var suggestionsList = $(".suggestions .item"); 4437 4438 if (suggestionsList.filter(".selected").length === 0) { 4439 suggestionsList.first().addClass("selected"); 4440 $("input.search-field").each(function () { 4441 $(this).attr("aria-activedescendant", suggestionsList.first()[0].id); 4442 }); 4443 } else { 4444 suggestionsList.each(function (index) { 4445 var idx = index + direction; 4446 4447 if ($(this).hasClass("selected")) { 4448 $(this).removeClass("selected"); 4449 $(this).removeAttr("aria-selected"); 4450 4451 if (suggestionsList.eq(idx).length !== 0) { 4452 suggestionsList.eq(idx).addClass("selected"); 4453 suggestionsList.eq(idx).attr("aria-selected", true); 4454 $(this).removeProp("aria-selected"); 4455 $("input.search-field").each(function () { 4456 $(this).attr("aria-activedescendant", suggestionsList.eq(idx)[0].id); 4457 }); 4458 } else { 4459 suggestionsList.first().addClass("selected"); 4460 suggestionsList.first().attr("aria-selected", true); 4461 $("input.search-field").each(function () { 4462 $(this).attr("aria-activedescendant", suggestionsList.first()[0].id); 4463 }); 4464 } 4465 4466 return false;
4467 } 4468 4469 return true; 4470 }); 4471 } 4472} 4473/** 4474 * Initializes the original search behavior. 4475 * 4476 * Binds form submission handling, search input events with debounced 4477 * suggestions loading, keyboard navigation (arrow keys), mobile close 4478 * actions, reset button behavior, and product click redirection inside 4479 * search suggestions. 4480 */ 4481 4482 4483function initOriginal() { 4484 $("form[name=\"simpleSearch\"]").submit(function (e) { 4485 var suggestionsList = $(".suggestions .item"); 4486 4487 if (suggestionsList.filter(".selected").length !== 0) { 4488 e.preventDefault(); 4489 suggestionsList.filter(".selected").find("a")[0].click(); 4490 } 4491 }); 4492 $("input.search-field").each(function () { 4493 /** 4494 * Use debounce to avoid making an Ajax call on every single key press by waiting a few 4495 * hundred milliseconds before making the request. Without debounce, the user sees the 4496 * browser blink with every key press. 4497 */ 4498 var debounceSuggestions = debounce(getSuggestions, 300); 4499 $(this).on("keyup focus", function (e) { 4500 // Capture Down/Up Arrow Key Events 4501 switch (e.which) { 4502 case DOWN_KEY: 4503 handleArrow(DIRECTION_DOWN); 4504 e.preventDefault(); // prevent moving the cursor 4505 4506 break; 4507 4508 case UP_KEY: 4509 handleArrow(DIRECTION_UP); 4510 e.preventDefault(); // prevent moving the cursor 4511 4512 break; 4513 4514 default: 4515 debounceSuggestions(this, e); 4516 } 4517 }); 4518 }); 4519 $("body").on("click touchend", ".search-mobile button.fa-close", function (e) { 4520 e.preventDefault(); 4521 $(".suggestions").hide(); 4522 toggleSuggestionsIcon("search"); 4523 tearDownSuggestions(); 4524 }); 4525 $(".site-search .reset-button").on("click", function () { 4526 $(this).removeClass("d-sm-block"); 4527 }); 4528 $("body").on("click", ".suggestions .product-detail-image", function () { 4529 $(this).closest(".product-detail").find(".product-detail-infos a")[0].click(); 4530 }); 4531} 4532/** 4533 * Initializes mobile search interactions. 4534 * 4535 * Handles opening the search popin when the search field is focused 4536 * and closing it via the return button. 4537 */ 4538 4539 4540function initMobile() { 4541 var $mainHeaderMobile = $(".main-header-mobile"); 4542 var $inputSearch = $mainHeaderMobile.find(".search-display .search-field"); 4543 4544 if (!$inputSearch.length) { 4545 return; 4546 } 4547 4548 var $popinSearch = $mainHeaderMobile.find(".search-popin"); 4549 4550 if (!$popinSearch.length) { 4551 return; 4552 } 4553 4554 $inputSearch.off("click focus").on("click focus", function () { 4555 $popinSearch.removeClass("d-none"); 4556 $popinSearch.find(".search-field").trigger("focus"); 4557 }); 4558 var $returnBtn = $mainHeaderMobile.find(".return-button"); 4559 4560 if (!$returnBtn.length) { 4561 return; 4562 } 4563 4564 $returnBtn.off("click").on("click", function () { 4565 $popinSearch.addClass("d-none"); 4566 }); 4567} 4568/** 4569 * Initialize search 4570 */ 4571 4572 4573function init() { 4574 $(function () { 4575 var isMobile = utils.isMobile(); 4576 4577 if (isMobile) { 4578 initMobile(); 4579 } 4580 4581 initOriginal(); 4582 }); 4583} 4584 4585module.exports = { 4586 init: init 4587}; 4588 4589/***/ }), 4590 4591/***/ 3119: 4592/***/ ((module) => { 4593 4594// Plugin SelectToQty - Automatically transforms selects with the "selectToQty" class into buttons 4595 4596/** 4597 * Initializes a select element as a SelectToQty component. 4598 * @param {jQuery} $select - The select element to transform. 4599 */ 4600function initSelectToQty($select) { 4601 if ($select.data("qty-transformed")) { 4602 return; 4603 } // Retrieve option values 4604 4605 4606 var options = []; 4607 var selectedValue = 0; 4608 var minValue = 0; 4609 var maxValue = 999; 4610 var isDisabled = !!$select.attr("disabled"); 4611 $select.find("option").each(function () { 4612 var value = parseInt($(this).val(), 10) || 0; 4613 options.push(value); 4614 4615 if ($(this).is(":selected")) { 4616 selectedValue = value; 4617 } 4618 }); // Set min and max 4619 4620 if (options.length > 0) { 4621 minValue = Math.min.apply(Math, options); 4622 maxValue = Math.max.apply(Math, options); 4623 } // Check data attributes for custom min/max 4624 4625 4626 if ($select.data("min") !== undefined) { 4627 minValue = parseInt($select.data("min"), 10); 4628 } 4629 4630 if ($select.data("max") !== undefined) { 4631 maxValue = parseInt($select.data("max"), 10); 4632 } // Create the wrapper and quantity component 4633 4634 4635 var $wrapper = $("<div class=\"qty-wrapper\"></div>"); 4636 var $qtyComponent = $("\n <div class=\"qty-component".concat(selectedValue ? " active" : "", "\">\n <button type=\"button\" class=\"qty-btn qty-decrease\" ").concat(selectedValue <= minValue || isDisabled ? "disabled" : "", ">\u2212</button>\n <input type=\"number\" class=\"qty-input\" value=\"").concat(selectedValue, "\" min=\"").concat(minValue, "\" max=\"").concat(maxValue, "\" ").concat(isDisabled ? "disabled" : "", ">\n <button type=\"button\" class=\"qty-btn qty-increase\" ").concat(selectedValue >= maxValue || isDisabled ? "disabled" : "", ">+</button>\n </div>\n ")); 4637 var $input = $qtyComponent.find(".qty-input"); 4638 var $decreaseBtn = $qtyComponent.find(".qty-decrease"); 4639 var $increaseBtn = $qtyComponent.find(".qty-increase"); // Function to update buttons 4640 4641 function updateButtons(value) { 4642 $decreaseBtn.prop("disabled", value <= minValue); 4643 $increaseBtn.prop("disabled", value >= maxValue); 4644 4645 if (value > 0) { 4646 $qtyComponent.addClass("active"); 4647 } else { 4648 $qtyComponent.removeClass("active"); 4649 } 4650 } // Function to validate and adjust the value 4651 4652 4653 function validateValue(value) { 4654 value = parseInt(value, 10) || 0; 4655 if (value < minValue) value = minValue; 4656 if (value > maxValue) value = maxValue; 4657 return value; 4658 } // Function to synchronize with the original select 4659 4660 4661 function syncSelect(value) { 4662 $select.val(value); // Trigger the change event on the original select 4663 4664 $select.trigger("change"); 4665 } 4666 4667 function handlerOnClick() { 4668 var increase = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; 4669 var currentValue = parseInt($input.val(), 10) || 0; 4670 var newValue = increase ? Math.min(currentValue + 1, maxValue) : Math.max(currentValue - 1, minValue); 4671 $input.val(newValue); 4672 updateButtons(newValue); 4673 syncSelect(newValue); 4674 } // Event handlers 4675 4676 4677 $decreaseBtn.on("click", function () { 4678 handlerOnClick(false); 4679 }); 4680 $increaseBtn.on("click", function () { 4681 handlerOnClick(true); 4682 }); 4683 $input.on("input change", function () { 4684 var $this = $(this); 4685 var value = $this.val(); // Allow empty input temporarily 4686 4687 if (value === "") { 4688 updateButtons(0); 4689 return; 4690 } 4691 4692 value = validateValue(value); 4693 $this.val(value); 4694 updateButtons(value); 4695 syncSelect(value); 4696 }); // Handle focus loss to ensure there is always a valid value 4697 4698 $input.on("blur", function () { 4699 if ($(this).val() === "") { 4700 $(this).val(minValue); 4701 updateButtons(minValue); 4702 syncSelect(minValue); 4703 } 4704 }); // Prevent entry of non-numeric characters 4705 4706 $input.on("keypress", function (e) { 4707 // Allow: backspace, delete, tab, escape, enter 4708 if ([8, 9, 27, 13, 46].indexOf(e.keyCode) !== -1 || // Allow: Ctrl+A, Ctrl+C, Ctrl+V, Ctrl+X 4709 e.keyCode === 65 && e.ctrlKey === true || e.keyCode === 67 && e.ctrlKey === true || e.keyCode === 86 && e.ctrlKey === true || e.keyCode === 88 && e.ctrlKey === true) { 4710 return; 4711 } // Make sure it's a number 4712 4713 4714 if ((e.shiftKey || e.keyCode < 48 || e.keyCode > 57) && (e.keyCode < 96 || e.keyCode > 105)) { 4715 e.preventDefault(); 4716 } 4717 }); // Wrap the original select in the wrapper 4718 4719 $select.wrap($wrapper); 4720 var $actualWrapper = $select.parent(".qty-wrapper"); // Add the component to the wrapper (after the hidden select) 4721 4722 $actualWrapper.append($qtyComponent); // Mark as transformed 4723 4724 $select.data("qty-transformed", true); // Store references 4725 4726 $select.data("qty-component", $qtyComponent); 4727 $select.data("qty-wrapper", $actualWrapper); // If the original select changes (programming), update the component 4728 4729 $select.on("selectToQty.update", function () { 4730 var newValue = validateValue($select.val()); 4731 $input.val(newValue); 4732 updateButtons(newValue); 4733 }); 4734} // Observe for dynamically added elements 4735 4736 4737if (window.MutationObserver) { 4738 var observer = new MutationObserver(function (mutations) { 4739 mutations.forEach(function (mutation) { 4740 $(mutation.addedNodes).find(".selectToQty").addBack(".selectToQty").each(function () { 4741 if (!$(this).data("qty-transformed")) { 4742 initSelectToQty($(this)); 4743 } 4744 }); 4745 }); 4746 }); 4747 observer.observe(document.body, { 4748 childList: true, 4749 subtree: true 4750 }); 4751} 4752/** 4753 * Reinitialize tranformed select to qty-wrapper 4754 * @param {jQuery} $select - select to reinitialize 4755 */ 4756 4757 4758function resetSelectToQty($select) { 4759 if (!$select.data("qty-transformed")) { 4760 return; 4761 } 4762 4763 var $wrapper = $select.data("qty-wrapper"); 4764 4765 if ($wrapper && $wrapper.length) { 4766 $select.insertBefore($wrapper); 4767 $wrapper.remove(); 4768 } // clean 4769 4770 4771 $select.removeData("qty-transformed"); 4772 $select.removeData("qty-component"); 4773 $select.removeData("qty-wrapper"); 4774 $select.off("selectToQty.update"); 4775} 4776/** 4777 * reset All SelectToQty 4778 */ 4779 4780 4781function resetAllSelectToQty() { 4782 $(".selectToQty").each(function () { 4783 resetSelectToQty($(this)); 4784 }); 4785} 4786
4787function init() { 4788 resetAllSelectToQty(); 4789 $(".selectToQty").each(function () { 4790 initSelectToQty($(this)); 4791 }); 4792} 4793 4794module.exports = { 4795 init: init, 4796 resetAllSelectToQty: resetAllSelectToQty 4797}; 4798 4799/***/ }), 4800 4801/***/ 1825: 4802/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4803 4804/* global dataLayer */ 4805var gtmHelper = __webpack_require__(6589); 4806/** 4807 * @description Push layer with add product to the Cart data 4808 */ 4809 4810 4811function addProductToCart() { 4812 $('body').on('gtm:afterAddToCart', function (e, eventData) { 4813 if (!eventData.data || typeof dataLayer === 'undefined') { 4814 return; 4815 } 4816 4817 dataLayer.push(eventData.data); 4818 }); 4819} 4820/** 4821 * @description Push layer with remove product from the Cart data 4822 */ 4823 4824 4825function removeProductFromCart() { 4826 $('body').on('gtm:afterRemoveFromCart', function (e, eventData) { 4827 if (!eventData.data || typeof dataLayer === 'undefined') { 4828 return; 4829 } 4830 4831 dataLayer.push(eventData.data); 4832 }); 4833} 4834/** 4835 * @description Push layer with submit Shipping data 4836 */ 4837 4838 4839function submitShipping() { 4840 $('body').on('gtm:submitShipping', function (e, eventData) { 4841 if (!eventData.data || typeof dataLayer === 'undefined') { 4842 return; 4843 } 4844 4845 dataLayer.push(eventData.data); 4846 }); 4847} 4848/** 4849 * @description Push layer with productClick data 4850 */ 4851 4852 4853function productClick() { 4854 $(document).on('click', 'a.product-tile-href-js', function (e) { 4855 e.preventDefault(); 4856 var productClickDataLayer = gtmHelper.getProductClickDataLayer($(this)); 4857 4858 if (productClickDataLayer && typeof dataLayer !== 'undefined') { 4859 dataLayer.push(productClickDataLayer); 4860 } 4861 4862 window.location.href = $(this).attr('href'); 4863 }); 4864} 4865/** 4866 * @description Push layer with productList data 4867 */ 4868 4869 4870function productList() { 4871 $(document).ready(function () { 4872 gtmHelper.addGtmProductList(); 4873 }); 4874} 4875 4876module.exports = { 4877 addProductToCart: addProductToCart, 4878 removeProductFromCart: removeProductFromCart, 4879 submitShipping: submitShipping, 4880 productClick: productClick, 4881 productList: productList 4882}; 4883 4884/***/ }), 4885 4886/***/ 6589: 4887/***/ ((module) => { 4888 4889/* global dataLayer */ 4890 4891/** 4892 * add GTM productList dataLayer 4893 */ 4894function addGtmProductList() { 4895 var $dataGtmProductList = $('[data-gtm-product-list]'); 4896 var gtmProductListObj = null; 4897 4898 if ($dataGtmProductList.length) { 4899 gtmProductListObj = $dataGtmProductList.last().data('gtm-product-list'); 4900 } 4901 4902 if (gtmProductListObj) { 4903 var pageCategoryStr = $('div.grid-footer').data('gtm-page-category'); 4904 4905 if (pageCategoryStr) { 4906 gtmProductListObj.pageCategory = pageCategoryStr; 4907 } 4908 4909 dataLayer.push(gtmProductListObj); 4910 } 4911} 4912/** 4913 * Gets ProductClick DataLayer Obj 4914 * @param {Object} - jQuery target element Obj 4915 * @returns {Object} ProductClick DataLayer Obj 4916 */ 4917 4918 4919function getProductClickDataLayer($target) { 4920 if (!$target) { 4921 return; 4922 } 4923 4924 var gtmProductClickObj = $target.data('gtm-product-click'); 4925 4926 if (!gtmProductClickObj) { 4927 return; 4928 } 4929 4930 var pageCategoryStr = $('div.grid-footer').data('gtm-page-category'); 4931 4932 if (pageCategoryStr) { 4933 gtmProductClickObj.pageCategory = pageCategoryStr; 4934 } 4935 4936 return gtmProductClickObj; 4937} 4938 4939module.exports = { 4940 addGtmProductList: addGtmProductList, 4941 getProductClickDataLayer: getProductClickDataLayer 4942}; 4943 4944/***/ }), 4945 4946/***/ 6110: 4947/***/ ((module) => { 4948 4949var secondPopinOpened; 4950 4951function initCache() { 4952 var $cache = { 4953 window: $(window), 4954 docEl: $('html'), 4955 docsEl: $('html, body'), 4956 header: $('.l-header__container'), 4957 content: $('.page'), 4958 contentEl: document.getElementsByClassName('page')[0] 4959 }; 4960 return $cache;
4961} 4962 4963function toggleWindowScroll(action) { 4964 var $cache = initCache(); 4965 var headerHeight = $cache.header.outerHeight(); 4966 var scrollFromTop = window.pageYOffset; 4967 var contentScrollTop = Math.abs(parseFloat(window.getComputedStyle($cache.contentEl).getPropertyValue('top'))); 4968 $cache.window.trigger('scrollToggled'); 4969 4970 if (action == 'lock') { 4971 if ($cache.docEl.hasClass('js-no-scroll')) { 4972 secondPopinOpened = true; 4973 } else { 4974 // eslint-disable-next-line 4975 if (Foundation.MediaQuery.atLeast('md')) { 4976 $cache.docEl.addClass('js-no-scroll'); 4977 } else { 4978 $cache.docsEl.addClass('js-no-scroll'); 4979 4980 if (scrollFromTop > ($cache.header.length ? headerHeight : '0')) { 4981 $cache.content.css({ 4982 top: -scrollFromTop 4983 }); 4984 $cache.header.addClass('l-header__container--scrolled'); 4985 } 4986 } 4987 } 4988 } else { 4989 if (secondPopinOpened) { 4990 secondPopinOpened = false; 4991 } else { 4992 // eslint-disable-next-line 4993 if (Foundation.MediaQuery.atLeast('md')) { 4994 $cache.docEl.removeClass('js-no-scroll'); 4995 window.scrollTo(0, scrollFromTop); 4996 } else { 4997 $cache.docsEl.removeClass('js-no-scroll'); 4998 $cache.content.css({ 4999 top: '' 5000 }); 5001 window.scrollTo(0, contentScrollTop); 5002 $cache.header.removeClass('l-header__container--scrolled'); 5003 } 5004 } 5005 } 5006} 5007 5008module.exports = { 5009 toggleWindowScroll: toggleWindowScroll 5010}; 5011 5012/***/ }), 5013 5014/***/ 5863: 5015/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 5016 5017"use strict"; 5018 5019 5020var processInclude = __webpack_require__(7199); 5021 5022var utils = __webpack_require__(4443); 5023 5024$(document).ready(function () { 5025 processInclude((__webpack_require__(3307).newsletter)); 5026}); 5027var NL_STORAGE = { 5028 LS: { 5029 TIMER_FINISHED: "newsletter_timer_finished", 5030 FREQUENCY_OK: "newsletter_frequency_ok", 5031 LAST_OPENED: "newsletter_last_opened", 5032 OPENINGS_COUNT: "newsletter_openings_count", 5033 CURRENT_DISPLAY_INDEX: "newsletter_current_display_index" 5034 }, 5035 SS: { 5036 ALREADY_SCROLLED: "newsletter_already_scrolled", 5037 PAGE_COUNT: "newsletter_page_count", 5038 VISITED_PAGES_OK: "newsletter_visited_pages_ok" 5039 } 5040}; 5041var $newsletterModal = $("#newsletter-modal"); 5042var $newsletterRules = $("[name='newsletterRules']"); 5043var rules = $newsletterRules.length && JSON.parse($newsletterRules.val()); 5044var currentDisplayPopinRuleIndex = getCurrentDisplayPopinIndex(); // index of rules array 5045 5046/** 5047 * Apply popin position 5048 */ 5049 5050function applyPositionStyling() { 5051 var currentRule = rules[currentDisplayPopinRuleIndex]; 5052 var position = currentRule.position || { 5053 x: "center", 5054 y: "middle" 5055 }; 5056 position.x = position.x || "center"; 5057 position.y = position.y || "middle"; // Mapping positions to Bootstrap classes 5058 5059 var positionClasses = { 5060 x: { 5061 "left": "mr-auto", 5062 "center": "mx-auto", 5063 "right": "ml-auto" 5064 }, 5065 y: { 5066 "top": "align-self-start", 5067 "middle": "align-self-center", 5068 "bottom": "align-self-end" 5069 } 5070 }; 5071 var $modalContent = $newsletterModal.find(".modal-dialog"); 5072 $modalContent.removeClass("mr-auto mx-auto ml-auto align-self-start align-self-center align-self-end"); 5073 5074 if (positionClasses.x[position.x]) { 5075 $modalContent.addClass(positionClasses.x[position.x]); 5076 } 5077 5078 if (positionClasses.y[position.y]) { 5079 $modalContent.addClass(positionClasses.y[position.y]); 5080 } 5081} 5082/** 5083 * Get current display popin index 5084 * @returns {Number} current display popin index 5085 */ 5086 5087 5088function getCurrentDisplayPopinIndex() { 5089 var storedValue = localStorage.getItem(NL_STORAGE.LS.CURRENT_DISPLAY_INDEX); 5090 var dIndex = Number(storedValue); 5091 5092 if (storedValue === null || Number.isNaN(dIndex)) { 5093 localStorage.setItem(NL_STORAGE.LS.CURRENT_DISPLAY_INDEX, "0"); 5094 return 0; 5095 } 5096 5097 return dIndex; 5098} 5099/** 5100 * Manage Top Content Asset Displaying 5101 */ 5102 5103 5104function manageContentDisplaying() { 5105 $(".newsletter-content").addClass("d-none"); 5106 $("#top-content-" + currentDisplayPopinRuleIndex).removeClass("d-none"); 5107} 5108/** 5109 * Get good storage attribute 5110 * 5111 * @param {String} value 5112 * @returns {String|null} result 5113 */ 5114 5115 5116function getStorageType(value) { 5117 if (Object.values(NL_STORAGE.LS).includes(value)) { 5118 return "LS"; 5119 } 5120 5121 if (Object.values(NL_STORAGE.SS).includes(value)) { 5122 return "SS"; 5123 } 5124 5125 return null; 5126} 5127/** 5128 * Get current status of given rule and initialize to false if first time 5129 * 5130 * @param {string} rule 5131 * @param {string} idStorageItem 5132 * 5133 * @returns {boolean|null} - status of rule, null if this rule is not present in custom pref for current displaying popin 5134 */ 5135 5136 5137function getRuleStatus(rule, idStorageItem) { 5138 if (!rules[currentDisplayPopinRuleIndex][rule]) { 5139 return null; 5140 } 5141 5142 var storageType = getStorageType(idStorageItem); 5143 var currentStorage = storageType && storageType === "LS" ? localStorage : sessionStorage; 5144 5145 if (!currentStorage.getItem(idStorageItem + "_" + currentDisplayPopinRuleIndex)) { 5146 currentStorage.setItem(idStorageItem + "_" + currentDisplayPopinRuleIndex, false); 5147 return false;
5148 } 5149 5150 return utils.getBoolean(currentStorage.getItem(idStorageItem + "_" + currentDisplayPopinRuleIndex)); 5151} 5152/** 5153 * Check if current page action is allowed 5154 * Priority: onlyAuthorizedActions > excludedActions 5155 * @returns {boolean} - true if current action can display the popin 5156 */ 5157 5158 5159function isCurrentActionAllowed() { 5160 var currentRule = rules[currentDisplayPopinRuleIndex]; 5161 var currentAction = $newsletterModal.data("action"); // If onlyAuthorizedActions is defined and not empty, it takes absolute priority. 5162 5163 if (currentRule && currentRule.onlyAuthorizedActions && Array.isArray(currentRule.onlyAuthorizedActions) && currentRule.onlyAuthorizedActions.length > 0) { 5164 if (!currentAction) { 5165 return false; 5166 } 5167 5168 return currentRule.onlyAuthorizedActions.includes(currentAction); 5169 } // Otherwise, we check excludedActions (existing behavior) 5170 5171 5172 if (!currentRule || !currentRule.excludedActions || !Array.isArray(currentRule.excludedActions) || currentRule.excludedActions.length === 0) { 5173 return true; 5174 } 5175 5176 if (!currentAction) { 5177 return true; 5178 } 5179 5180 return !currentRule.excludedActions.includes(currentAction); 5181} 5182/** 5183 * Initialize frequency rule 5184 * @returns {void} 5185 */ 5186 5187 5188function initFrequencyRule() { 5189 var currentRule = "frequency"; 5190 var freq = rules[currentDisplayPopinRuleIndex][currentRule]; 5191 5192 if (!freq || !freq.type) { 5193 return; 5194 } 5195 5196 var lastOpened = parseInt(localStorage.getItem(NL_STORAGE.LS.LAST_OPENED + "_" + currentDisplayPopinRuleIndex) || "0", 10); 5197 5198 if (!lastOpened) { 5199 localStorage.setItem(NL_STORAGE.LS.FREQUENCY_OK + "_" + currentDisplayPopinRuleIndex, true); 5200 $(document).trigger("newsletter:check:display"); 5201 return; 5202 } 5203 5204 freq.maxDisplays = freq.maxDisplays || 1; 5205 var currentOpeningsCount = parseInt(localStorage.getItem(NL_STORAGE.LS.OPENINGS_COUNT + "_" + currentDisplayPopinRuleIndex) || "0", 10); 5206 var lastOpenedDate = new Date(lastOpened); 5207 var now = new Date();
5207 // Check the minimum time between two displays 5208 5209 if (freq.minTimeBetween && freq.maxDisplays > 1) { 5210 var timeSinceLastOpening = Math.floor((now.getTime() - lastOpenedDate.getTime()) / 1000); // in seconds 5211 5212 if (timeSinceLastOpening < freq.minTimeBetween) { 5213 localStorage.setItem(NL_STORAGE.LS.FREQUENCY_OK + "_" + currentDisplayPopinRuleIndex, false); 5214 return; 5215 } 5216 } // Calculate the start of the current period according to the type 5217 5218 5219 var periodStart; 5220 var dayOfWeek; 5221 var diff; 5222 5223 switch (freq.type) { 5224 case "one": 5225 // A period that never resets. 5226 periodStart = new Date(0); // 1st january 1970 5227 5228 break; 5229 5230 case "daily": 5231 periodStart = new Date(now.getFullYear(), now.getMonth(), now.getDate()); 5232 break; 5233 5234 case "weekly": 5235 // Start of the week (Monday) 5236 dayOfWeek = now.getDay(); 5237 diff = dayOfWeek === 0 ? 6 : dayOfWeek - 1; // Sunday = 0, we want Monday 5238 5239 periodStart = new Date(now); 5240 periodStart.setDate(now.getDate() - diff); 5241 periodStart.setHours(0, 0, 0, 0); 5242 break; 5243 5244 case "monthly": 5245 periodStart = new Date(now.getFullYear(), now.getMonth(), 1); 5246 break; 5247 } // If the last opening was before the start of the current period, 5248 // we reset the counter 5249 5250 5251 if (lastOpenedDate < periodStart) { 5252 localStorage.setItem(NL_STORAGE.LS.FREQUENCY_OK + "_" + currentDisplayPopinRuleIndex, true); 5253 $(document).trigger("newsletter:check:display"); 5254 return; 5255 } // Otherwise, check if the limit has been reached. 5256 5257 5258 if (currentOpeningsCount >= freq.maxDisplays) { 5259 localStorage.setItem(NL_STORAGE.LS.FREQUENCY_OK + "_" + currentDisplayPopinRuleIndex, false); // We move on to the next index of rules, if one exists: 5260 5261 if (rules[currentDisplayPopinRuleIndex + 1]) { 5262 localStorage.setItem(NL_STORAGE.LS.CURRENT_DISPLAY_INDEX, "" + +(currentDisplayPopinRuleIndex + 1)); 5263 currentDisplayPopinRuleIndex++; 5264 } 5265 } else { 5266 localStorage.setItem(NL_STORAGE.LS.FREQUENCY_OK + "_" + currentDisplayPopinRuleIndex, true); 5267 $(document).trigger("newsletter:check:display"); 5268 } 5269} 5270/** 5271 * Initialize Timer rule 5272 * @returns {void} 5273 */ 5274 5275 5276function initTimerRule() { 5277 var ruleStatus = getRuleStatus("displayAfterSeconds", NL_STORAGE.LS.TIMER_FINISHED); 5278 5279 if (ruleStatus === null || ruleStatus === true) { 5280 return; 5281 } 5282 5283 var delay = parseInt(rules[currentDisplayPopinRuleIndex]["displayAfterSeconds"], 10); 5284 setTimeout(function () { 5285 localStorage.setItem(NL_STORAGE.LS.TIMER_FINISHED + "_" + currentDisplayPopinRuleIndex, true); 5286 $(document).trigger("newsletter:check:display"); 5287 }, delay * 1000); 5288} 5289/** 5290 * Initialize scroll Rule 5291 * @returns {void} 5292 */ 5293 5294 5295function initScrollRule() { 5296 var ruleStatus = getRuleStatus("displayAfterScrollPercent", NL_STORAGE.SS.ALREADY_SCROLLED); 5297 5298 if (ruleStatus === null || ruleStatus === true) { 5299 return; 5300 } 5301 5302 var minScroll = parseInt(rules[currentDisplayPopinRuleIndex]["displayAfterScrollPercent"] || 0, 10); 5303 5304 var scrollHandler = function scrollHandler() { 5305 var docHeight = document.documentElement.scrollHeight - window.innerHeight; 5306 var scrolled = docHeight > 0 ? window.scrollY / docHeight * 100 : 100; 5307 5308 if (scrolled >= minScroll) { 5309 sessionStorage.setItem(NL_STORAGE.SS.ALREADY_SCROLLED + "_" + currentDisplayPopinRuleIndex, true); 5310 window.removeEventListener("scroll", scrollHandler); 5311 $(document).trigger("newsletter:check:display"); 5312 } 5313 }; 5314 5315 window.addEventListener("scroll", scrollHandler, { 5316 passive: true 5317 }); 5318} 5319/** 5320 * Initialize page count rule 5321 * @returns {void} 5322 */ 5323 5324 5325function initPageCountRule() { 5326 var ruleStatus = getRuleStatus("displayAfterPages", NL_STORAGE.SS.VISITED_PAGES_OK); 5327 5328 if (ruleStatus === null || ruleStatus === true) { 5329 return; 5330 } 5331 5332 var minPages = parseInt(rules[currentDisplayPopinRuleIndex]["displayAfterPages"] || 1, 10); 5333 var currentPageCount = parseInt(sessionStorage.getItem(NL_STORAGE.SS.PAGE_COUNT + "_" + currentDisplayPopinRuleIndex) || "0", 10); 5334 5335 if (currentPageCount >= minPages) { 5336 sessionStorage.setItem(NL_STORAGE.SS.VISITED_PAGES_OK + "_" + currentDisplayPopinRuleIndex, true); 5337 $(document).trigger("newsletter:check:display"); 5338 } 5339} 5340/** 5341 * Display current Popin 5342 */ 5343 5344 5345function displayPopin() { 5346 $newsletterModal.modal("show"); 5347 localStorage.setItem(NL_STORAGE.LS.LAST_OPENED + "_" + currentDisplayPopinRuleIndex, Date.now().toString()); 5348 localStorage.setItem(NL_STORAGE.LS.OPENINGS_COUNT + "_" + currentDisplayPopinRuleIndex, parseInt(localStorage.getItem(NL_STORAGE.LS.OPENINGS_COUNT + "_" + currentDisplayPopinRuleIndex) || "0", 10) + 1); 5349} 5350/** 5351 * Initialize events 5352 */ 5353 5354 5355function initEvents() { 5356 $(document).on("newsletter:check:display", function () { 5357 var rulesForConditionOk = [NL_STORAGE.LS.TIMER_FINISHED, NL_STORAGE.SS.ALREADY_SCROLLED, NL_STORAGE.SS.VISITED_PAGES_OK, NL_STORAGE.LS.FREQUENCY_OK]; 5358 var allConditionsMet = rulesForConditionOk.every(function (idStorageItem) { 5359 var storageType = getStorageType(idStorageItem); 5360 var currentStorage = storageType && storageType === "LS" ? localStorage : sessionStorage; 5361 var rule = utils.getBoolean(currentStorage.getItem(idStorageItem + "_" + currentDisplayPopinRuleIndex)); 5362 return rule === true || rule === null; 5363 }); 5364 5365 if (allConditionsMet) { 5366 displayPopin(); 5367 } 5368 }); 5369} 5370/** 5371 * Initialization 5372 * @returns 5373 */ 5374 5375
5376function init() { 5377 var isRegistered = $newsletterModal.data("is-registered"); 5378 var isSubscribed = $newsletterModal.data("is-unsubscribed"); 5379 5380 if (!rules.length || !rules[currentDisplayPopinRuleIndex] || !$newsletterModal.length || isRegistered && isSubscribed || !isCurrentActionAllowed()) { 5381 return; 5382 } 5383 5384 initEvents(); 5385 manageContentDisplaying(); 5386 applyPositionStyling(); // increment Page count 5387 5388 sessionStorage.setItem(NL_STORAGE.SS.PAGE_COUNT + "_" + currentDisplayPopinRuleIndex, parseInt(sessionStorage.getItem(NL_STORAGE.SS.PAGE_COUNT + "_" + currentDisplayPopinRuleIndex) || "0", 10) + 1); // init timer popin rule 5389 5390 initTimerRule(); // init scroll rule 5391 5392 initScrollRule(); // init page count rule before display current popin 5393 5394 initPageCountRule(); // init frequency rule 5395 5396 initFrequencyRule(); 5397} 5398 5399$(function () { 5400 init(); 5401}); 5402 5403/***/ }), 5404 5405/***/ 2658: 5406/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5407 5408var focusHelper = __webpack_require__(7768); 5409 5410var utils = __webpack_require__(4443); 5411 5412var readMore = __webpack_require__(4039); 5413 5414var selectToQty = __webpack_require__(3119); 5415 5416var ATTRIBUTE = { 5417 quantity: "quantity", 5418 color: "color" 5419}; 5420/** 5421 * Retrieves the relevant pid value 5422 * @param {jquery} $el - DOM container for a given add to cart button 5423 * @return {string} - value to be used when adding product to cart 5424 */ 5425 5426function getPidValue($el) { 5427 var pid; 5428 5429 if ($("#quickViewModal").hasClass("show") && !$(".product-set").length) { 5430 pid = $($el).closest(".modal-content").find(".product-quickview").data("pid"); 5431 } else if ($(".product-set-detail").length || $(".product-set").length) { 5432 pid = $($el).closest(".product-detail").find(".product-id").text(); 5433 } else { 5434 pid = $(".product-detail:not(\".bundle-item\")").data("pid"); 5435 } 5436 5437 if (pid === undefined) { 5438 pid = $el.data("pid"); 5439 } 5440 5441 return pid; 5442} 5443/** 5444 * Retrieve contextual quantity selector 5445 * @param {jquery} $el - DOM container for the relevant quantity 5446 * @return {jquery} - quantity selector DOM container 5447 */ 5448 5449 5450function getQuantitySelector($el) { 5451 if ($el) { 5452 var $parent = $el.parents(".quickViewModal"); 5453 5454 if ($parent.length) { 5455 return $parent.find("select.quantity-select"); 5456 } 5457 } 5458 5459 return $("select.quantity-select"); 5460} 5461/** 5462 * Retrieves the value associated with the Quantity pull-down menu 5463 * @param {jquery} $el - DOM container for the relevant quantity 5464 * @return {string} - value found in the quantity input 5465 */ 5466 5467 5468function getQuantitySelected($el) { 5469 var isMixedOffer = $(".mixed_offer-js").length && !$el.parents(".quickViewModal").length; 5470 return isMixedOffer ? 1 : parseInt(getQuantitySelector($el).val(), 10); 5471} 5472/** 5473 * Process the attribute values for an attribute that has image swatches 5474 * 5475 * @param {Object} attr - Attribute 5476 * @param {string} attr.id - Attribute ID 5477 * @param {Object[]} attr.values - Array of attribute value objects 5478 * @param {string} attr.values.value - Attribute coded value 5479 * @param {string} attr.values.url - URL to de/select an attribute value of the product 5480 * @param {boolean} attr.values.isSelectable - Flag as to whether an attribute value can be 5481 * selected. If there is no variant that corresponds to a specific combination of attribute 5482 * values, an attribute may be disabled in the Product Detail Page 5483 * @param {jQuery} $productContainer - DOM container for a given product 5484 * @param {Object} msgs - object containing resource messages 5485 */ 5486 5487 5488function processSwatchValues(attr, $productContainer, msgs) { 5489 attr.values.forEach(function (attrValue) { 5490 var $attrValue = $productContainer.find("[data-attr=\"" + attr.id + "\"] [data-attr-value=\"" + attrValue.value + "\"]"); 5491 var $swatchButton = $attrValue.parent(); 5492 5493 if (attrValue.selected) { 5494 $attrValue.addClass("selected"); 5495 $attrValue.siblings(".selected-assistive-text").text(msgs.assistiveSelectedText); 5496 } else { 5497 $attrValue.removeClass("selected"); 5498 $attrValue.siblings(".selected-assistive-text").empty(); 5499 } 5500 5501 if (attrValue.url) { 5502 $swatchButton.attr("data-url", attrValue.url); 5503 } else { 5504 $swatchButton.removeAttr("data-url"); 5505 } // Disable if not selectable 5506 5507 5508 $attrValue.removeClass("selectable unselectable"); 5509 $attrValue.addClass(attrValue.selectable ? "selectable" : "unselectable"); 5510 }); 5511} 5512/** 5513 * Process attribute values associated with an attribute that does not have image swatches 5514 * 5515 * @param {Object} attr - Attribute 5516 * @param {string} attr.id - Attribute ID 5517 * @param {Object[]} attr.values - Array of attribute value objects 5518 * @param {string} attr.values.value - Attribute coded value 5519 * @param {string}
5519 attr.values.url - URL to de/select an attribute value of the product 5520 * @param {boolean} attr.values.isSelectable - Flag as to whether an attribute value can be 5521 * selected. If there is no variant that corresponds to a specific combination of attribute 5522 * values, an attribute may be disabled in the Product Detail Page 5523 * @param {jQuery} $productContainer - DOM container for a given product 5524 */ 5525 5526 5527function processNonSwatchValues(attr, $productContainer) { 5528 var $attr = "[data-attr=\"" + attr.id + "\"]"; 5529 var $defaultOption = $productContainer.find($attr + " .select-" + attr.id + " option:first"); 5530 $defaultOption.attr("value", attr.resetUrl); 5531 attr.values.forEach(function (attrValue) { 5532 var $attrValue = $productContainer.find($attr + " [data-attr-value=\"" + attrValue.value + "\"]"); 5533 $attrValue.attr("value", attrValue.url).removeAttr("disabled"); 5534 5535 if (!attrValue.selectable) { 5536 $attrValue.attr("disabled", true); 5537 } 5538 }); 5539} 5540/** 5541 * Routes the handling of attribute processing depending on whether the attribute has image 5542 * swatches or not 5543 * 5544 * @param {Object} attrs - Attribute 5545 * @param {string} attr.id - Attribute ID 5546 * @param {jQuery} $productContainer - DOM element for a given product 5547 * @param {Object} msgs - object containing resource messages 5548 */ 5549 5550 5551function updateAttrs(attrs, $productContainer, msgs) { 5552 // Currently, the only attribute type that has image swatches is Color. 5553 var attrsWithSwatches = ["color"]; 5554 attrs.forEach(function (attr) { 5555 if (attrsWithSwatches.indexOf(attr.id) > -1) { 5556 processSwatchValues(attr, $productContainer, msgs); 5557 } else { 5558 processNonSwatchValues(attr, $productContainer); 5559 } 5560 }); 5561} 5562/** 5563 * Updates the availability status in the Product Detail Page 5564 * 5565 * @param {Object} response - Ajax response object after an 5566 * attribute value has been [de]selected 5567 * @param {jQuery} $productContainer - DOM element for a given product 5568 */ 5569 5570 5571function updateAvailability(response, $productContainer) { 5572 var available = response.product.readyToOrder; // Enable add to cart button and remove back in stock text 5573 5574 if (available) { 5575 $(".add-to-cart", $productContainer).prop("disabled", false).removeClass("disabled"); 5576 $(".availability-wrapper", $productContainer).remove(); 5577 } // Case for unavailable should not be treated, user shouldn't be able to select an unavailable variant 5578 // Landing on an unavailable variant handles the case from isml 5579 5580} 5581/** 5582 * @typedef UpdatedOptionValue 5583 * @type Object 5584 * @property {string} id - Option value ID for look up 5585 * @property {string} url - Updated option value selection URL 5586 */ 5587 5588/** 5589 * @typedef OptionSelectionResponse 5590 * @type Object 5591 * @property {string} priceHtml - Updated price HTML code 5592 * @property {Object} options - Updated Options 5593 * @property {string} options.id - Option ID 5594 * @property {UpdatedOptionValue[]} options.values - Option values 5595 */ 5596 5597/** 5598 * Updates DOM using post-option selection Ajax response 5599 * 5600 * @param {OptionSelectionResponse} optionsHtml - Ajax response optionsHtml from selecting a product option 5601 * @param {jQuery} $productContainer - DOM element for current product 5602 */ 5603 5604 5605function updateOptions(optionsHtml, $productContainer) { 5606 // Update options 5607 $productContainer.find(".product-options").empty().html(optionsHtml); 5608} 5609/** 5610 * Updates product detail page content based on variant selection response. 5611 * Excludes elements within .bundle-items-track from updates to preserve bundle product data. 5612 * 5613 * @param {Object} response - Server response containing product variant data 5614 * @param {jQuery} $productContainer - jQuery object of the product container element 5615 * @param {string|null} attributeChanged - Name of the attribute that triggered the update (optional) 5616 */ 5617 5618 5619function handleVariantResponse(response, $productContainer) { 5620 var _response$product; 5621 5622 var attributeChanged = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; 5623 var isChoiceOfBonusProducts = $productContainer.parents(".choose-bonus-product-dialog").length > 0; 5624 var isVaraint; 5625 5626 if (response.product.variationAttributes) {
5627 updateAttrs(response.product.variationAttributes, $productContainer, response.resources); 5628 isVaraint = response.product.productType === "variant"; 5629 5630 if (isChoiceOfBonusProducts && isVaraint) { 5631 $productContainer.parent(".bonus-product-item").data("pid", response.product.id); 5632 $productContainer.parent(".bonus-product-item").data("ready-to-order", response.product.readyToOrder); 5633 } 5634 } // Update primary images 5635 5636 5637 if (attributeChanged !== ATTRIBUTE.quantity) { 5638 var primaryImageUrls = response.product.images.large; 5639 createCarousel(primaryImageUrls, $productContainer); 5640 } // Update pricing 5641 5642 5643 if (!isChoiceOfBonusProducts) { 5644 var $priceSelector = $(".prices .price", $productContainer).not(".bundle-items-track .prices .price").length ? $(".prices .price", $productContainer).not(".bundle-items-track .prices .price") : $(".prices .price").not(".bundle-items-track .prices .price"); 5645 $priceSelector.replaceWith(response.product.price.html); 5646 } // Update promotions 5647 5648 5649 $productContainer.children(".promotions").empty().html(response.product.promotionsHtml); 5650 5651 if ($productContainer.children(".promotions").length === 0) { 5652 $productContainer.find(".promotions").not(".bundle-items-track .promotions").empty().html(response.product.promotionsHtml); 5653 } // Update product name 5654 5655 5656 $productContainer.children(".product-name").text(response.product.productName); 5657 5658 if ($productContainer.children(".product-name").length === 0) { 5659 $productContainer.find(".product-name").not(".bundle-items-track .product-name").text(response.product.productName); 5660 } // Update product capacity 5661 5662 5663 var attributes = response.product.attributes; 5664 var capacity = attributes && attributes.storefront && attributes.storefront.displayCapacity ? attributes.storefront.displayCapacity.value : null; 5665 var $capacityLabel = $productContainer.children(".product-details-capacity").find(".label"); 5666 var $capacityValue = $productContainer.children(".product-details-capacity").find(".value"); 5667 5668 if ($capacityLabel.length === 0) { 5669 $capacityLabel = $productContainer.find(".product-details-capacity .label").not(".bundle-items-track .product-details-capacity .label"); 5670 $capacityValue = $productContainer.find(".product-details-capacity .value").not(".bundle-items-track .product-details-capacity .value"); 5671 } 5672 5673 $capacityLabel.toggleClass("d-none", !capacity); 5674 $capacityValue.text(capacity ? capacity : ""); // Update product description 5675 5676 $productContainer.children(".product-shortdescription").html(response.product.shortDescription); 5677 5678 if ($productContainer.children(".product-shortdescription").length === 0) { 5679 $productContainer.find(".product-shortdescription").not(".bundle-items-track .product-shortdescription").html(response.product.shortDescription); 5680 } // Product flag 5681 5682 5683 if (response.flagHtml) { 5684 var $flagContainer = $(".product-image-section .container-flags", $productContainer).not(".bundle-items-track .product-image-section .container-flags"); 5685 $flagContainer.replaceWith(response.flagHtml); 5686 } 5687 5688 updateAvailability(response, $productContainer); // Update add-to-cart buttons 5689 5690 var $addToCartBtn = $("button.add-to-cart", $productContainer).not(".bundle-items-track button.add-to-cart"); 5691 $addToCartBtn.attr("data-pid", response.product.id); 5692 $addToCartBtn.attr("data-readytoorder", response.product.readyToOrder); 5693 5694 if (isChoiceOfBonusProducts) { 5695 var $selectButton = $productContainer.find(".select-bonus-product"); 5696 $selectButton.trigger("bonusproduct:updateSelectButton", { 5697 product: response.product, 5698 $productContainer: $productContainer 5699 }); 5700 } else { 5701 // Enable "Add to Cart" button if all required attributes have been selected 5702 var $addToCartButtons = $("button.add-to-cart, button.add-to-cart-global, button.update-cart-product-global").not(".bundle-items-track button.add-to-cart, .bundle-items-track button.add-to-cart-global, .bundle-items-track button.update-cart-product-global"); 5703 $addToCartButtons.trigger("product:updateAddToCart", { 5704 product: response.product,
5705 $productContainer: $productContainer 5706 }).trigger("product:statusUpdate", response.product); 5707 } // Update prices in add-to-cart section 5708 5709 5710 var $prices = $(".product-detail .add-to-cart .prices").not(".bundle-items-track .prices"); 5711 $prices.find(".value").text(response.product.totalPriceFormatted).attr("content", response.product.totalPrice); 5712 5713 if ((_response$product = response.product) !== null && _response$product !== void 0 && _response$product.oldTotalPrice) { 5714 $prices.find("del .strike-through .value").text(response.product.oldTotalPriceFormatted).attr("content", response.product.oldTotalPrice); 5715 } 5716} 5717/** 5718 * Dynamically creates Bootstrap carousel from response containing images 5719 * @param {Object[]} imgs - Array of large product images,along with related information 5720 * @param {jQuery} $productContainer - DOM element for a given product 5721 */ 5722 5723 5724function createCarousel(imgs, $productContainer) { 5725 var $carousel = $(".product-image-slider", $productContainer); 5726 var $singleImage = $(".product-image-wrap", $productContainer); 5727 5728 if ($carousel.length && $carousel.hasClass("slick-initialized")) { 5729 $carousel.slick("unslick"); 5730 } 5731 5732 $(".product-image-section .listbox", $productContainer).remove(); 5733 var $container = $carousel.length ? $carousel : $singleImage; 5734 5735 if (imgs.length && $container.length) { 5736 imgs.forEach(function (img) { 5737 $container.append($("<div class=\"listbox\"><img src=\"".concat(img.url, "\" class=\"d-block img-fluid product-detail-image\"/></div>"))); 5738 }); 5739 } 5740 5741 if (imgs.length > 1) { 5742 $container.slick({ 5743 arrows: true, 5744 slidesToShow: 1, 5745 slidesToScroll: 1, 5746 infinite: true, 5747 lazyLoad: "ondemand" 5748 }); 5749 } 5750} 5751/** 5752 * @typespec UpdatedQuantity 5753 * @type Object 5754 * @property {boolean} selected - Whether the quantity has been selected 5755 * @property {string} value - The number of products to purchase 5756 * @property {string} url - Compiled URL that specifies variation attributes, product ID, options, 5757 * etc. 5758 */ 5759 5760/** 5761 * Updates the quantity DOM elements post Ajax call 5762 * @param {UpdatedQuantity[]} quantities - 5763 * @param {jQuery} $productContainer - DOM container for a given product 5764 */ 5765 5766 5767function updateQuantities(quantities, $productContainer) {
5768 if (!$productContainer.parent(".bonus-product-item").length) { 5769 var optionsHtml = quantities.map(function (quantity) { 5770 var selected = quantity.selected ? " selected " : ""; 5771 return "<option value=\"" + quantity.value + "\" data-url=\"" + quantity.url + "\"" + selected + ">" + quantity.value + "</option>"; 5772 }).join(""); 5773 getQuantitySelector($productContainer).empty().html(optionsHtml); 5774 } 5775} 5776/** 5777 * updates the product view when a product attribute is selected or deselected or when 5778 * changing quantity 5779 * @param {string} selectedValueUrl - the Url for the selected variation value 5780 * @param {jQuery} $productContainer - DOM element for current product 5781 * @param {string} attributeChanged - attribute edited 5782 */ 5783 5784 5785function attributeSelect(selectedValueUrl, $productContainer) { 5786 var attributeChanged = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; 5787 5788 if (selectedValueUrl) { 5789 $("body").trigger("product:beforeAttributeSelect", { 5790 url: selectedValueUrl, 5791 container: $productContainer 5792 }); 5793 $.ajax({ 5794 url: selectedValueUrl, 5795 method: "GET", 5796 success: function success(data) { 5797 handleVariantResponse(data, $productContainer, attributeChanged); 5798 updateOptions(data.product.optionsHtml, $productContainer); 5799 updateQuantities(data.product.quantities, $productContainer); 5800 $("body").trigger("product:afterAttributeSelect", { 5801 data: data, 5802 container: $productContainer 5803 }); 5804 readMore.init(); 5805 selectToQty.init(); 5806 $.spinner().stop(); 5807 }, 5808 error: function error() { 5809 $.spinner().stop(); 5810 } 5811 }); 5812 } 5813} 5814/** 5815 * Retrieves url to use when adding a product to the cart 5816 * 5817 * @return {string} - The provided URL to use when adding a product to the cart 5818 */ 5819 5820 5821function getAddToCartUrl() { 5822 return $(".add-to-cart-url").val(); 5823} 5824/** 5825 * Parses the html for a modal window 5826 * @param {string} html - representing the body and footer of the modal window 5827 * 5828 * @return {Object} - Object with properties body and footer. 5829 */ 5830 5831 5832function parseHtml(html) { 5833 var $html = $("<div>").append($.parseHTML(html)); 5834 var body = $html.find(".choice-of-bonus-product"); 5835 var footer = $html.find(".modal-footer").children(); 5836 return { 5837 body: body, 5838 footer: footer 5839 }; 5840} 5841/** 5842 * Retrieves url to use when adding a product to the cart 5843 * 5844 * @param {Object} data - data object used to fill in dynamic portions of the html 5845 */ 5846 5847 5848function chooseBonusProducts(data) { 5849 if ($("#chooseBonusProductModal").length !== 0) { 5850 $("#chooseBonusProductModal").remove(); 5851 } 5852 5853 var bonusUrl; 5854 5855 if (data.bonusChoiceRuleBased) { 5856 bonusUrl = data.showProductsUrlRuleBased; 5857 } else { 5858 bonusUrl = data.showProductsUrlListBased; 5859 } 5860 5861 var htmlString = "<!-- Modal -->" + "<div class=\"modal fade\" id=\"chooseBonusProductModal\" tabindex=\"-1\" role=\"dialog\">" + "<span class=\"enter-message sr-only\" ></span>" + "<div class=\"modal-dialog choose-bonus-product-dialog\" " + "data-total-qty=\"" + data.maxBonusItems + "\"" + "data-UUID=\"" + data.uuid + "\"" + "data-pliUUID=\"" + data.pliUUID + "\"" + "data-addToCartUrl=\"" + data.addToCartUrl + "\"" + "data-pageStart=\"0\"" + "data-pageSize=\"" + data.pageSize + "\"" + "data-moreURL=\"" + data.showProductsUrlRuleBased + "\"" + "data-bonusChoiceRuleBased=\"" + data.bonusChoiceRuleBased + "\">" + "<!-- Modal content-->" + "<div class=\"modal-content\">" + "<div class=\"modal-header d-flex flex-nowrap justify-content-between\">" + " <h5 class=\"p-3 px-md-5 m-0 flex-grow-1\">" + data.labels.selectprods + "</h5>" + " <button type=\"button\" class=\"close fs34 px-3\" data-dismiss=\"modal\" aria-label=\"Close\">" + " <span aria-hidden=\"true\">Ã</span>" + " </button>" + "</div>" + "<hr class=\"m-0\">" + "<div class=\"modal-body\"></div>" + "<div class=\"modal-footer\"></div>" + "</div>" + "</div>" + "</div>"; 5862 $("body").append(htmlString); 5863 $.ajax({ 5864 url: bonusUrl, 5865 method: "GET", 5866 dataType: "json", 5867 success: function success(response) { 5868 var parsedHtml = parseHtml(response.renderedTemplate); 5869 $("#chooseBonusProductModal .modal-body").empty(); 5870 $("#chooseBonusProductModal .enter-message").text(response.enterDialogMessage); 5871 $("#chooseBonusProductModal .modal-header .close .sr-only").text(response.closeButtonText); 5872 $("#chooseBonusProductModal .modal-body").html(parsedHtml.body); 5873 $("#chooseBonusProductModal .modal-footer").html(parsedHtml.footer); 5874 $("#chooseBonusProductModal").modal("show"); 5875 var $imageCarousels = $("#chooseBonusProductModal .product-image-slider"); 5876 $imageCarousels.each(function () { 5877 if ($(".listbox", $(this)).length > 1) { 5878 $(this).slick({ 5879 arrows: true, 5880 slidesToShow: 1, 5881 slidesToScroll: 1, 5882 lazyLoad: "ondemand" 5883 }); 5884 } 5885 }); 5886 $(document).trigger("reinitSelect", [$("#chooseBonusProductModal")]); 5887 } 5888 }); 5889} 5890/** 5891 * Updates the Mini-Cart quantity value after the customer has pressed the "Add to Cart" button 5892 * @param {string} response - ajax response from clicking the add to cart button 5893 */ 5894 5895 5896function handlePostCartAdd(response) { 5897 $(".minicart").trigger("count:update", response); 5898 var messageType = response.error ? "alert-danger" : "alert-success"; // show add to cart toast 5899 5900 if (response.newBonusDiscountLineItem && Object.keys(response.newBonusDiscountLineItem).length !== 0) {
5901 chooseBonusProducts(response.newBonusDiscountLineItem); 5902 } else { 5903 if ($(".add-to-cart-messages").length === 0) { 5904 $("body").append("<div class=\"add-to-cart-messages\"></div>"); 5905 } 5906 5907 $(".add-to-cart-messages").append("<div class=\"alert " + messageType + " add-to-basket-alert text-center\" role=\"alert\">" + response.message + "</div>"); 5908 setTimeout(function () { 5909 $(".add-to-basket-alert").remove(); 5910 }, 5000); 5911 } 5912} 5913/** 5914 * Retrieves the kit product items ID's for the Controller to replace bundle placeholder product 5915 * items with their selected Kit products 5916 * or 5917 * retrieves the bundle product item ID's for the Controller to replace bundle master product 5918 * items with their selected variants 5919 * 5920 * @param {Object} $mixedOffer - The jQuery Obj for 'mixedOffer' element 5921 * @return {string[]} - Stringified list of selected kit or bundle products data or empty array 5922 */ 5923 5924 5925function getChildProducts($mixedOffer) { 5926 var childProducts = []; 5927 var isMixedOffer = $mixedOffer.length; 5928 5929 if (isMixedOffer) { 5930 var mixedOfferQuantity = $mixedOffer.data("mixedoffer-quantity"); 5931 var mixedOfferSum = 0; 5932 var i = 1; 5933 $(".mixed_offer-js select :selected").each(function () { 5934 if ($(this).val() > 0) { 5935 mixedOfferSum = mixedOfferSum + Number($(this).val()); 5936 childProducts.push({ 5937 pid: $(this).closest(".mixed-offer-item").data("pid"), 5938 quantity: $(this).val(), 5939 placeholderBundledId: $mixedOffer.data("bundled-placeholder-id") + i, 5940 sequenceNumber: $(this).closest(".mixed-offer-item").data("sequence-number") 5941 }); 5942 i++; 5943 5944 if (i > mixedOfferQuantity) { 5945 return false; // break loop 5946 } 5947 } 5948 }); 5949 } else { 5950 // Get childProducts for bundle 5951 $(".bundle-item").each(function () { 5952 childProducts.push({ 5953 pid: $(this).data("product-id").toString(), 5954 quantity: parseInt($(this).data("quantity"), 10) 5955 }); 5956 }); 5957 } 5958 5959 return childProducts.length ? JSON.stringify(childProducts) : []; 5960} 5961/** 5962 * Display mixedOffer Modal (Popup) 5963 * 5964 * @param {number} mixedOfferQuantity - The number of required mixedOffer products 5965 * @return {boolean} - true if mixedOffer mixedOffer Modal is shown 5966 */ 5967 5968 5969function mixedOfferModal(mixedOfferQuantity) { 5970 if (!mixedOfferQuantity) { 5971 return true; 5972 } 5973 5974 var mixedOfferSum = 0; 5975 var $mixedOfferModalMsg = $(".mixed_offer-modal-msg-js"); 5976 $(".mixed_offer-js select :selected").each(function () { 5977 if ($(this).val() > 0) { 5978 mixedOfferSum += Number($(this).val()); 5979 } 5980 }); 5981 5982 if (mixedOfferSum !== mixedOfferQuantity) { 5983 var val, txt; 5984 5985 if (mixedOfferSum < mixedOfferQuantity) { 5986 val = mixedOfferQuantity - mixedOfferSum; 5987 txt = $mixedOfferModalMsg.data("incompletebox-msg").replace("##", val); 5988 } else if (mixedOfferSum > mixedOfferQuantity) { 5989 val = mixedOfferSum - mixedOfferQuantity; 5990 txt = $mixedOfferModalMsg.data("overflowingbox-msg").replace("##", val); 5991 } 5992 5993 if (val > 1) { 5994 txt = txt.replaceAll("{1}", "s"); 5995 } else { 5996 txt = txt.replaceAll("{1}", ""); 5997 } 5998 5999 $mixedOfferModalMsg.text(txt); 6000 $(".mixed_offer-popup-js").modal("toggle"); 6001 return true; 6002 } 6003 6004 return false; 6005} 6006/** 6007 * Retrieve product options 6008 * 6009 * @param {jQuery} $productContainer - DOM element for current product 6010 * @return {string} - Product options and their selected values 6011 */ 6012 6013 6014function getOptions($productContainer) { 6015 var options = $productContainer.find(".product-option").map(function () { 6016 var $elOption = $(this).find(".options-select"); 6017 var urlValue = $elOption.val(); 6018 var selectedValueId = $elOption.find("option[value=\"" + urlValue + "\"]").data("value-id"); 6019 return { 6020 optionId: $(this).data("option-id"), 6021 selectedValueId: selectedValueId 6022 }; 6023 }).toArray(); 6024 return JSON.stringify(options); 6025} 6026/** 6027 * Makes a call to the server to report the event of adding an item to the cart 6028 * 6029 * @param {string | boolean} url - a string representing the end point to hit so that the event can be recorded, or false 6030 */ 6031 6032 6033function miniCartReportingUrl(url) { 6034 if (url) { 6035 $.ajax({ 6036 url: url, 6037 method: "GET", 6038 success: function success() {// reporting urls hit on the server 6039 }, 6040 error: function error() {// no reporting urls hit on the server 6041 } 6042 }); 6043 } 6044} 6045/** 6046 * Redirect PDP page to the good variant or master product 6047 * 6048 * @param {object} $select - jquery object 6049 * @returns {null|void} 6050 */ 6051 6052 6053function onCapacityChange(args) { 6054 args = args || null; 6055 6056 if (!args || args.length < 2) { 6057 return null; 6058 } 6059 6060 var $select = $(args[1]); 6061 6062 if (!$select || !$select.length) { 6063 return null; 6064 } 6065 6066 var $parent = $select.parents("div.row-capacity"); 6067 6068 if (!$parent || !$parent.length) { 6069 return null; 6070 } 6071 6072 var $options = $parent.find("select option:selected"); 6073 var $productCapacities = $select.parents(".product-detail").find("#productCapacities"); 6074 6075 if (!$productCapacities || !$productCapacities.length) { 6076 return null; 6077 } 6078 6079 var productCapacities = JSON.parse($productCapacities.val()); 6080 6081 for (var i = 0, ln = productCapacities.length; i < ln; i++) { 6082 for (var j = 0, ln2 = $options.length; j < ln2; j++) { 6083 var $option = $($options[j]); 6084 6085 if ($option.data("attr-value") === productCapacities[i].capacity) { 6086 window.location = productCapacities[i].url; 6087 } 6088 } 6089 } 6090} 6091 6092$(document).ready(function () { 6093 $(".select-capacity option[selected=\"selected\"]").each(function () { 6094 $(this).removeAttr("selected"); 6095 }); // mark the first option as selected 6096 6097 $(".select-capacity option:first").attr("selected", "selected"); 6098 $(document).trigger("reinitSelect", [$(".select-capacity")]); 6099 $(document).on("document:change:product:attribute", function () { 6100 onCapacityChange(arguments); 6101 }); 6102}); 6103module.exports = { 6104 attributeSelect: attributeSelect, 6105 methods: { 6106 editBonusProducts: function editBonusProducts(data) { 6107 chooseBonusProducts(data); 6108 }, 6109 createCarousel: createCarousel
6110 }, 6111 focusChooseBonusProductModal: function focusChooseBonusProductModal() { 6112 $("body").on("shown.bs.modal", "#chooseBonusProductModal", function () { 6113 $("#chooseBonusProductModal").siblings().attr("aria-hidden", "true"); 6114 $("#chooseBonusProductModal .close").focus(); 6115 }); 6116 }, 6117 onClosingChooseBonusProductModal: function onClosingChooseBonusProductModal() { 6118 $("body").on("hidden.bs.modal", "#chooseBonusProductModal", function () { 6119 $("#chooseBonusProductModal").siblings().attr("aria-hidden", "false"); 6120 }); 6121 }, 6122 trapChooseBonusProductModalFocus: function trapChooseBonusProductModalFocus() { 6123 $("body").on("keydown", "#chooseBonusProductModal", function (e) { 6124 var focusParams = { 6125 event: e, 6126 containerSelector: "#chooseBonusProductModal", 6127 firstElementSelector: ".close", 6128 lastElementSelector: ".add-bonus-products" 6129 }; 6130 focusHelper.setTabNextFocus(focusParams); 6131 }); 6132 }, 6133 colorAttribute: function colorAttribute() { 6134 $(document).on("click", "[data-attr=\"color\"] button", function (e) { 6135 e.preventDefault(); 6136 6137 if ($(this).attr("disabled")) { 6138 return; 6139 } 6140 6141 var $productContainer = $(this).closest(".set-item"); 6142
6143 if (!$productContainer.length) { 6144 $productContainer = $(this).closest(".product-detail"); 6145 } 6146 6147 attributeSelect($(this).attr("data-url"), $productContainer, ATTRIBUTE.color); 6148 }); 6149 }, 6150 selectAttribute: function selectAttribute() { 6151 $(document).on("change", ".attributes select[class*=\"select-\"], .options-select", function (e) { 6152 e.preventDefault(); 6153 var $this = $(this); 6154 $(document).trigger("document:change:product:attribute", $this); 6155 var $productContainer = $(this).closest(".set-item"); 6156 6157 if (!$productContainer.length) { 6158 $productContainer = $(this).closest(".product-detail"); 6159 } 6160 6161 attributeSelect(e.currentTarget.value, $productContainer); 6162 }); 6163 }, 6164 availability: function availability() { 6165 $(document).on("change", ".quantity-select", function (e) { 6166 e.preventDefault(); 6167 var $productContainer = $(this).closest(".product-detail"); 6168 6169 if (!$productContainer.length) { 6170 $productContainer = $(this).closest(".modal-content").find(".product-quickview"); 6171 } 6172 6173 attributeSelect($(e.currentTarget).find("option:selected").data("url"), $productContainer, ATTRIBUTE.quantity); 6174 }); 6175 }, 6176 addToCart: function addToCart() { 6177 $(document).off("click", "button.add-to-cart, button.add-to-cart-global").on("click", "button.add-to-cart, button.add-to-cart-global", function () { 6178 var addToCartUrl; 6179 var pid; 6180 var pidsObj; 6181 var setPids; 6182 var $mixedOffer = $(".mixed_offer-js"); 6183 var isMixedOffer = $mixedOffer.length; 6184 var mixedOfferQuantity = 0; 6185 var $this = $(this); // Block the call if product is not ready for ordering 6186 6187 if (!$this.data("readytoorder")) { 6188 if ($this.parents(".add-to-cart-wrapper").find(".add-to-cart-error").length) { 6189 $this.parents(".add-to-cart-wrapper").find(".add-to-cart-error").removeClass("d-none"); 6190 } else if ($this.siblings(".add-to-cart-error").length) { 6191 $this.siblings(".add-to-cart-error").removeClass("d-none"); 6192 } 6193 6194 return; 6195 } 6196 6197 if (isMixedOffer) { 6198 if (!$this.parents(".quickViewModal").length) { 6199 mixedOfferQuantity = Number($mixedOffer.data("mixedoffer-quantity")); 6200 var isMixedOfferModal = mixedOfferModal(mixedOfferQuantity); 6201 6202 if (isMixedOfferModal) { 6203 return; 6204 } 6205 } 6206 } 6207 6208 $("body").trigger("product:beforeAddToCart", this); 6209 6210 if ($(".set-items").length && $(this).hasClass("add-to-cart-global")) { 6211 setPids = []; 6212 $(".product-detail").each(function () { 6213 if (!$(this).hasClass("product-set-detail")) { 6214 setPids.push({ 6215 pid: $(this).find(".product-id").text(), 6216 qty: $(this).find(".quantity-select").val(), 6217 options: getOptions($(this)) 6218 }); 6219 } 6220 }); 6221 pidsObj = JSON.stringify(setPids); 6222 } 6223 6224 pid = getPidValue($(this)); 6225 var $productContainer = $(this).closest(".product-detail"); 6226
6227 if (!$productContainer.length) { 6228 $productContainer = $(this).closest(".quick-view-dialog").find(".product-detail"); 6229 } 6230 6231 addToCartUrl = getAddToCartUrl(); 6232 var form = { 6233 pid: pid, 6234 pidsObj: pidsObj, 6235 childProducts: getChildProducts($mixedOffer), 6236 quantity: getQuantitySelected($(this)), 6237 type: $(this).closest(".product-quickview").length > 0 ? "button.addtocart.variant" : "" 6238 }; 6239 6240 if (!$(".bundle-item").length) { 6241 form.options = getOptions($productContainer); 6242 } 6243 6244 $(this).trigger("updateAddToCartFormData", form); 6245 6246 if (addToCartUrl) { 6247 $.ajax({ 6248 url: addToCartUrl, 6249 method: "POST", 6250 data: form, 6251 success: function success(data) { 6252 if (!data.error) { 6253 var _data$cart; 6254 6255 $("body").trigger("product:onCartUpdateQty", [data === null || data === void 0 ? void 0 : (_data$cart = data.cart) === null || _data$cart === void 0 ? void 0 : _data$cart.items]); 6256 handlePostCartAdd(data); 6257 $.spinner().stop(); 6258 $("body").trigger("product:afterAddToCart", data); 6259 $("body").trigger("gtm:afterAddToCart", { 6260 data: data.gtmAddToCart 6261 }); 6262 miniCartReportingUrl(data.reportingURL); 6263 } else { 6264 $.spinner().stop(); 6265 6266 if (data.quantityExceeded) { 6267 $this.parents(".add-to-cart-wrapper").find(".add-to-cart-error").text(data.message).removeClass("d-none"); 6268 } 6269 } 6270 }, 6271 error: function error() { 6272 $.spinner().stop(); 6273 } 6274 }); 6275 } 6276 }); 6277 }, 6278 selectBonusProduct: function selectBonusProduct() { 6279 $(document).on("click", ".select-bonus-product", function () { 6280 var $choiceOfBonusProduct = $(this).parents(".choice-of-bonus-product"); 6281 var pid = $(this).data("pid"); 6282 var maxPids = $(".choose-bonus-product-dialog").data("total-qty"); 6283 var submittedQty = parseInt($choiceOfBonusProduct.find(".bonus-quantity-select").val(), 10); 6284 var totalQty = 0; 6285 $.each($("#chooseBonusProductModal .selected-bonus-products .selected-pid"), function () { 6286 totalQty += $(this).data("qty"); 6287 }); 6288 totalQty += submittedQty; 6289 var optionID = $choiceOfBonusProduct.find(".product-option").data("option-id"); 6290 var valueId = $choiceOfBonusProduct.find(".options-select option:selected").data("valueId"); 6291 6292 if (totalQty <= maxPids) { 6293 var selectedBonusProductHtml = "" + "<div class=\"selected-pid row\" " + "data-pid=\"" + pid + "\"" + "data-qty=\"" + submittedQty + "\"" + "data-optionID=\"" + (optionID || "") + "\"" + "data-option-selected-value=\"" + (valueId || "") + "\"" + ">" + "<div class=\"col-sm-11 col-9 bonus-product-name\" >" + $choiceOfBonusProduct.find(".product-name").html() + "</div>" + "<div class=\"col-1\"><i class=\"fa fa-times\" aria-hidden=\"true\"></i></div>" + "</div>"; 6294 $("#chooseBonusProductModal .selected-bonus-products").append(selectedBonusProductHtml); 6295 $(".pre-cart-products").html(totalQty); 6296 $(".selected-bonus-products .bonus-summary").removeClass("alert-danger"); 6297 } else { 6298 $(".selected-bonus-products .bonus-summary").addClass("alert-danger"); 6299 } 6300 }); 6301 }, 6302 removeBonusProduct: function removeBonusProduct() { 6303 $(document).on("click", ".selected-pid", function () { 6304 $(this).remove(); 6305 var $selected = $("#chooseBonusProductModal .selected-bonus-products .selected-pid"); 6306 var count = 0; 6307 6308 if ($selected.length) { 6309 $selected.each(function () { 6310 count += parseInt($(this).data("qty"), 10); 6311 }); 6312 } 6313 6314 $(".pre-cart-products").html(count); 6315 $(".selected-bonus-products .bonus-summary").removeClass("alert-danger"); 6316 }); 6317 }, 6318 enableBonusProductSelection: function enableBonusProductSelection() { 6319 $("body").on("bonusproduct:updateSelectButton", function (e, response) {
6320 $("button.select-bonus-product", response.$productContainer).attr("disabled", !response.product.readyToOrder || !response.product.available); 6321 var pid = response.product.id; 6322 $("button.select-bonus-product", response.$productContainer).data("pid", pid); 6323 }); 6324 }, 6325 showMoreBonusProducts: function showMoreBonusProducts() { 6326 $(document).on("click", ".show-more-bonus-products", function () { 6327 var url = $(this).data("url"); 6328 $(".modal-content").spinner().start(); 6329 $.ajax({ 6330 url: url, 6331 method: "GET", 6332 success: function success(html) { 6333 var parsedHtml = parseHtml(html); 6334 $(".modal-body").append(parsedHtml.body); 6335 $(".show-more-bonus-products:first").remove(); 6336 $(".modal-content").spinner().stop(); 6337 }, 6338 error: function error() { 6339 $(".modal-content").spinner().stop(); 6340 } 6341 }); 6342 }); 6343 }, 6344 addBonusProductsToCart: function addBonusProductsToCart() { 6345 $(document).on("click", ".add-bonus-products", function () { 6346 var $readyToOrderBonusProducts = $(".choose-bonus-product-dialog .selected-pid"); 6347 var queryString = "?pids="; 6348 var url = $(".choose-bonus-product-dialog").data("addtocarturl"); 6349 var pidsObject = { 6350 bonusProducts: [] 6351 }; 6352 $.each($readyToOrderBonusProducts, function () { 6353 var qtyOption = parseInt($(this).data("qty"), 10); 6354 var option = null; 6355 6356 if (qtyOption > 0) { 6357 if ($(this).data("optionid") && $(this).data("option-selected-value")) { 6358 option = {}; 6359 option.optionId = $(this).data("optionid"); 6360 option.productId = $(this).data("pid"); 6361 option.selectedValueId = $(this).data("option-selected-value"); 6362 } 6363 6364 pidsObject.bonusProducts.push({ 6365 pid: $(this).data("pid"), 6366 qty: qtyOption, 6367 options: [option] 6368 }); 6369 pidsObject.totalQty = parseInt($(".pre-cart-products").html(), 10); 6370 } 6371 }); 6372 queryString += JSON.stringify(pidsObject); 6373 queryString = queryString + "&uuid=" + $(".choose-bonus-product-dialog").data("uuid"); 6374 queryString = queryString + "&pliuuid=" + $(".choose-bonus-product-dialog").data("pliuuid"); 6375 $.spinner().start(); 6376 $.ajax({ 6377 url: url + queryString, 6378 method: "POST", 6379 success: function success(data) { 6380 $.spinner().stop(); 6381 6382 if (data.error) { 6383 $("#chooseBonusProductModal").modal("hide"); 6384 6385 if ($(".add-to-cart-messages").length === 0) { 6386 $("body").append("<div class=\"add-to-cart-messages\"></div>"); 6387 } 6388 6389 $(".add-to-cart-messages").append("<div class=\"alert alert-danger add-to-basket-alert text-center\"" + " role=\"alert\">" + data.errorMessage + "</div>"); 6390 setTimeout(function () { 6391 $(".add-to-basket-alert").remove(); 6392 }, 3000); 6393 } else { 6394 $(".configure-bonus-product-attributes").html(data); 6395 $(".bonus-products-step2").removeClass("hidden-xl-down"); 6396 $("#chooseBonusProductModal").modal("hide"); 6397 6398 if ($(".add-to-cart-messages").length === 0) { 6399 $("body").append("<div class=\"add-to-cart-messages\"></div>"); 6400 } 6401 6402 $(".minicart-quantity").html(utils.displayCartQty(data.totalQty)); 6403 $(".add-to-cart-messages").append("<div class=\"alert alert-success add-to-basket-alert text-center\"" + " role=\"alert\">" + data.msgSuccess + "</div>"); 6404 setTimeout(function () { 6405 $(".add-to-basket-alert").remove(); 6406 6407 if ($(".cart-page").length) { 6408 location.reload(); 6409 } 6410 }, 1500); 6411 $("body").trigger("product:afterAddToCart", data); 6412 } 6413 }, 6414 error: function error() { 6415 $.spinner().stop(); 6416 } 6417 }); 6418 }); 6419 }, 6420 getPidValue: getPidValue, 6421 getQuantitySelected: getQuantitySelected, 6422 miniCartReportingUrl: miniCartReportingUrl 6423}; 6424 6425/***/ }), 6426 6427/***/ 1601: 6428/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6429 6430"use strict"; 6431 6432 6433var base = __webpack_require__(2658); 6434 6435var focusHelper = __webpack_require__(7768); 6436 6437var selectToBox = __webpack_require__(7210); 6438/** 6439 * Generates the modal window on the first call. 6440 * 6441 */ 6442 6443 6444function getModalHtmlElement() { 6445 if ($("#quickViewModal").length !== 0) { 6446 $("#quickViewModal").remove(); 6447 } 6448 6449 var htmlString = "<!-- Modal -->" + "<div class=\"modal fade quickViewModal\" id=\"quickViewModal\" role=\"dialog\">" + "<span class=\"enter-message sr-only\" ></span>" + "<div class=\"modal-dialog quick-view-dialog\">" + "<!-- Modal content-->" + "<div class=\"modal-content\">" + "<div class=\"modal-header\">" + " <a class=\"full-pdp-link\" href=\"\"></a>" + " <button type=\"button\" class=\"close pull-right\" data-dismiss=\"modal\">
6449" + " <span aria-hidden=\"true\">×</span>" + " <span class=\"sr-only\"> </span>" + " </button>" + "</div>" + "<div class=\"modal-body\"></div>" + "<div class=\"modal-footer\"></div>" + "</div>" + "</div>" + "</div>"; 6450 $("body").append(htmlString); 6451} 6452/** 6453 * @typedef {Object} QuickViewHtml 6454 * @property {string} body - Main Quick View body 6455 * @property {string} footer - Quick View footer content 6456 */ 6457 6458/** 6459 * Parse HTML code in Ajax response 6460 * 6461 * @param {string} html - Rendered HTML from quickview template 6462 * @return {QuickViewHtml} - QuickView content components 6463 */ 6464 6465 6466function parseHtml(html) { 6467 var $html = $("<div>").append($.parseHTML(html)); 6468 var body = $html.find(".product-quickview"); 6469 var footer = $html.find(".modal-footer").children(); 6470 return { 6471 body: body, 6472 footer: footer 6473 }; 6474} 6475/** 6476 * replaces the content in the modal window on for the selected product variation. 6477 * @param {string} selectedValueUrl - url to be used to retrieve a new product model 6478 */ 6479 6480 6481function fillModalElement(selectedValueUrl) { 6482 $("#quickViewModal .modal-body").spinner().start(); 6483 $.ajax({ 6484 url: selectedValueUrl, 6485 method: "GET", 6486 dataType: "json", 6487 success: function success(data) { 6488 var parsedHtml = parseHtml(data.renderedTemplate); 6489 $("#quickViewModal .modal-body").empty(); 6490 $("#quickViewModal .modal-body").html(parsedHtml.body); 6491 $("#quickViewModal .modal-footer").html(parsedHtml.footer); 6492 $(".full-pdp-link").text(data.quickViewFullDetailMsg); 6493 $("#quickViewModal .full-pdp-link").attr("href", data.productUrl); 6494 $("#quickViewModal .size-chart").attr("href", data.productUrl); 6495 $("#quickViewModal .modal-header .close .sr-only").text(data.closeButtonText); 6496 $("#quickViewModal .enter-message").text(data.enterDialogMessage); 6497 $("#quickViewModal").modal("show"); 6498 $("body").trigger("quickview:ready"); 6499 $(document).trigger("reinitSelect", [$("#quickViewModal")]); 6500 $(document).trigger("quickViewReinitSelect", [$(".product-quickview .quantity-select")]); 6501 var $modalContainer = $("#quickViewModal"); 6502 var $productContainer = $modalContainer.find(".product-detail"); 6503 var primaryImageUrls = data.product.images.large; 6504 base.methods.createCarousel(primaryImageUrls, $productContainer); 6505 selectToBox.init(); 6506 $.spinner().stop(); 6507 }, 6508 error: function error() { 6509 $.spinner().stop(); 6510 } 6511 }); 6512} 6513 6514module.exports = { 6515 showQuickview: function showQuickview() { 6516 $("body").off("click", ".quickview").on("click", ".quickview", function (e) { 6517 e.preventDefault(); 6518 var selectedValueUrl = $(this).closest(".quickview").attr("data-href"); 6519 $(e.target).trigger("quickview:show"); 6520 getModalHtmlElement(); 6521 fillModalElement(selectedValueUrl); 6522 }); 6523 }, 6524 focusQuickview: function focusQuickview() { 6525 $("body").on("shown.bs.modal", "#quickViewModal", function () { 6526 $("#quickViewModal .close").focus(); 6527 }); 6528 }, 6529 trapQuickviewFocus: function trapQuickviewFocus() { 6530 $("body").on("keydown", "#quickViewModal", function (e) { 6531 var focusParams = { 6532 event: e, 6533 containerSelector: "#quickViewModal", 6534 firstElementSelector: ".full-pdp-link", 6535 lastElementSelector: ".add-to-cart-global", 6536 nextToLastElementSelector: ".modal-footer .quantity-select" 6537 }; 6538 focusHelper.setTabNextFocus(focusParams); 6539 }); 6540 }, 6541 availability: base.availability, 6542 addToCart: base.addToCart, 6543 showSpinner: function showSpinner() { 6544 $("body").on("product:beforeAddToCart", function (e, data) { 6545 $(data).closest(".modal-content").spinner().start(); 6546 }); 6547 }, 6548 hideDialog: function hideDialog() { 6549 $("body").on("product:afterAddToCart", function () { 6550 $("#quickViewModal").modal("hide"); 6551 }); 6552 }, 6553 beforeUpdateAttribute: function beforeUpdateAttribute() { 6554 $("body").on("product:beforeAttributeSelect", function () { 6555 $(".modal.show .modal-content").spinner().start(); 6556 }); 6557 }, 6558 updateAttribute: function updateAttribute() { 6559 $("body").on("product:afterAttributeSelect", function (e, response) { 6560 if ($(".modal.show .product-quickview>.bundle-items").length) { 6561 $(".modal.show").find(response.container).data("pid", response.data.product.id); 6562 $(".modal.show").find(response.container).find(".product-id").text(response.data.product.id); 6563 } else if ($(".set-items").length) { 6564 response.container.find(".product-id").text(response.data.product.id); 6565 } else { 6566 $(".modal.show .product-quickview").data("pid", response.data.product.id); 6567 $(".modal.show .full-pdp-link").attr("href", response.data.product.selectedProductUrl); 6568 $(".modal.show .add-to-cart").data("readytoorder", response.data.product.readyToOrder); 6569 } 6570 }); 6571 }, 6572 updateAddToCart: function updateAddToCart() { 6573 $("body").on("product:updateAddToCart", function (response) {
6574 $(".add-to-cart-error", response.$productContainer).addClass("d-none"); 6575 }); 6576 }, 6577 updateAvailability: function updateAvailability() { 6578 $("body").on("product:updateAvailability", function (e, response) { 6579 // bundle individual products 6580 $(".product-availability", response.$productContainer).data("ready-to-order", response.product.readyToOrder).data("available", response.product.available).find(".availability-msg").empty().html(response.message); 6581 var dialog = $(response.$productContainer).closest(".quick-view-dialog"); 6582 6583 if ($(".product-availability", dialog).length) { 6584 // bundle all products 6585 var allAvailable = $(".product-availability", dialog).toArray().every(function (item) { 6586 return $(item).data("available"); 6587 }); 6588 var allReady = $(".product-availability", dialog).toArray().every(function (item) { 6589 return $(item).data("ready-to-order"); 6590 }); 6591 $(".global-availability", dialog).data("ready-to-order", allReady).data("available", allAvailable); 6592 $(".global-availability .availability-msg", dialog).empty().html(allReady ? response.message : response.resources.info_selectforstock); 6593 } else { 6594 // single product 6595 $(".global-availability", dialog).data("ready-to-order", response.product.readyToOrder).data("available", response.product.available).find(".availability-msg").empty().html(response.message); 6596 } 6597 }); 6598 } 6599}; 6600 6601/***/ }), 6602 6603/***/ 8433: 6604/***/ (() => { 6605 6606function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 6607 6608!function ($) { 6609 "use strict"; 6610 6611 var FOUNDATION_VERSION = "6.2.4"; // Global Foundation object 6612 // This is attached to the window, or used as a module for AMD/Browserify 6613 6614 var Foundation = { 6615 version: FOUNDATION_VERSION, 6616 6617 /** 6618 * Stores initialized plugins. 6619 */ 6620 _plugins: {}, 6621 6622 /** 6623 * Stores generated unique ids for plugin instances 6624 */ 6625 _uuids: [], 6626 6627 /** 6628 * Returns a boolean for RTL support 6629 */ 6630 rtl: function rtl() { 6631 return $("html").attr("dir") === "rtl"; 6632 }, 6633 6634 /** 6635 * Defines a Foundation plugin, adding it to the `Foundation` namespace and the list of plugins to initialize when reflowing. 6636 * @param {Object} plugin - The constructor of the plugin. 6637 */ 6638 plugin: function plugin(_plugin, name) { 6639 // Object key to use when adding to global Foundation object 6640 // Examples: Foundation.Reveal, Foundation.OffCanvas 6641 var className = name || functionName(_plugin); // Object key to use when storing the plugin, also used to create the identifying data attribute for the plugin 6642 // Examples: data-reveal, data-off-canvas 6643 6644 var attrName = hyphenate(className); // Add to the Foundation object and the plugins list (for reflowing) 6645 6646 this._plugins[attrName] = this[className] = _plugin; 6647 }, 6648 6649 /** 6650 * @function 6651 * Populates the _uuids array with pointers to each individual plugin instance. 6652 * Adds the `zfPlugin` data-attribute to programmatically created plugins to allow use of $(selector).foundation(method) calls. 6653 * Also fires the initialization event for each plugin, consolidating repetitive code. 6654 * @param {Object} plugin - an instance of a plugin, usually `this` in context. 6655 * @param {String} name - the name of the plugin, passed as a camelCased string. 6656 * @fires Plugin#init 6657 */ 6658 registerPlugin: function registerPlugin(plugin, name) { 6659 var pluginName = name ? hyphenate(name) : functionName(plugin.constructor).toLowerCase(); 6660 plugin.uuid = this.GetYoDigits(6, pluginName); 6661 6662 if (!plugin.$element.attr("data-" + pluginName)) { 6663 plugin.$element.attr("data-" + pluginName, plugin.uuid); 6664 } 6665 6666 if (!plugin.$element.data("zfPlugin")) { 6667 plugin.$element.data("zfPlugin", plugin); 6668 } 6669 /** 6670 * Fires when the plugin has initialized. 6671 * @event Plugin#init 6672 */ 6673 6674 6675 plugin.$element.trigger("init.zf." + pluginName); 6676 6677 this._uuids.push(plugin.uuid); 6678 6679 return; 6680 }, 6681 6682 /** 6683 * @function 6684 * Removes the plugins uuid from the _uuids array.
6685 * Removes the zfPlugin data attribute, as well as the data-plugin-name attribute. 6686 * Also fires the destroyed event for the plugin, consolidating repetitive code. 6687 * @param {Object} plugin - an instance of a plugin, usually `this` in context. 6688 * @fires Plugin#destroyed 6689 */ 6690 unregisterPlugin: function unregisterPlugin(plugin) { 6691 var pluginName = hyphenate(functionName(plugin.$element.data("zfPlugin").constructor)); 6692 6693 this._uuids.splice(this._uuids.indexOf(plugin.uuid), 1); 6694 6695 plugin.$element.removeAttr("data-" + pluginName).removeData("zfPlugin") 6696 /** 6697 * Fires when the plugin has been destroyed. 6698 * @event Plugin#destroyed 6699 */ 6700 .trigger("destroyed.zf." + pluginName); 6701 6702 for (var prop in plugin) { 6703 plugin[prop] = null; //clean up script to prep for garbage collection. 6704 } 6705 6706 return; 6707 }, 6708 6709 /** 6710 * @function 6711 * Causes one or more active plugins to re-initialize, resetting event listeners, recalculating positions, etc. 6712 * @param {String} plugins - optional string of an individual plugin key, attained by calling `$(element).data('pluginName')`, or string of a plugin class i.e. `'dropdown'` 6713 * @default If no argument is passed, reflow all currently active plugins. 6714 */ 6715 reInit: function reInit(plugins) { 6716 var isJQ = plugins instanceof $; 6717 6718 try { 6719 if (isJQ) { 6720 plugins.each(function () { 6721 $(this).data("zfPlugin")._init(); 6722 }); 6723 } else { 6724 var type = _typeof(plugins), 6725 _this = this, 6726 fns = { 6727 "object": function object(plgs) { 6728 plgs.forEach(function (p) { 6729 p = hyphenate(p); 6730 $("[data-" + p + "]").foundation("_init"); 6731 }); 6732 }, 6733 "string": function string() { 6734 plugins = hyphenate(plugins); 6735 $("[data-" + plugins + "]").foundation("_init"); 6736 }, 6737 "undefined": function undefined() { 6738 this["object"](Object.keys(_this._plugins)); 6739 } 6740 }; 6741 6742 fns[type](plugins); 6743 } 6744 } catch (err) { 6745 console.error(err); 6746 } finally { 6747 return plugins; 6748 } 6749 }, 6750 6751 /** 6752 * returns a random base-36 uid with namespacing 6753 * @function 6754 * @param {Number} length - number of random base-36 digits desired. Increase for more random strings. 6755 * @param {String} namespace - name of plugin to be incorporated in uid, optional. 6756 * @default {String} '' - if no plugin name is provided, nothing is appended to the uid. 6757 * @returns {String} - unique id 6758 */ 6759 GetYoDigits: function GetYoDigits(length, namespace) { 6760 length = length || 6; 6761 return Math.round(Math.pow(36, length + 1) - Math.random() * Math.pow(36, length)).toString(36).slice(1) + (namespace ? "-" + namespace : ""); 6762 }, 6763 6764 /** 6765 * Initialize plugins on any elements within `elem` (and `elem` itself) that aren't already initialized. 6766 * @param {Object} elem - jQuery object containing the element to check inside. Also checks the element itself, unless it's the `document` object. 6767 * @param {String|Array} plugins - A list of plugins to initialize. Leave this out to initialize everything. 6768 */ 6769 reflow: function reflow(elem, plugins) { 6770 // If plugins is undefined, just grab everything 6771 if (typeof plugins === "undefined") { 6772 plugins = Object.keys(this._plugins); 6773 } // If plugins is a string, convert it to an array with one item 6774 else if (typeof plugins === "string") { 6775 plugins = [plugins]; 6776 } 6777 6778 var _this = this; // Iterate through each plugin 6779 6780 6781 $.each(plugins, function (i, name) { 6782 // Get the current plugin 6783 var plugin = _this._plugins[name]; // Localize the search to all elements inside elem, as well as elem itself, unless elem === document 6784 6785 var $elem = $(elem).find("[data-" + name + "]").addBack("[data-" + name + "]"); // For each plugin found, initialize it 6786 6787 $elem.each(function () { 6788 var $el = $(this), 6789 opts = {}; // Don't double-dip on plugins 6790 6791 if ($el.data("zfPlugin")) { 6792 console.warn("Tried to initialize " + name + " on an element that already has a Foundation plugin."); 6793 return; 6794 } 6795 6796 if ($el.attr("data-options")) { 6797 var thing = $el.attr("data-options").split(";").forEach(function (e, i) { 6798 var opt = e.split(":").map(function (el) { 6799 return el.trim(); 6800 }); 6801 if (opt[0]) opts[opt[0]] = parseValue(opt[1]); 6802 }); 6803 } 6804 6805 try { 6806 $el.data("zfPlugin", new plugin($(this), opts)); 6807 } catch (er) { 6808 console.error(er); 6809 } finally { 6810 return; 6811 } 6812 }); 6813 }); 6814 }, 6815 getFnName: functionName, 6816 transitionend: function transitionend($elem) { 6817 var transitions = { 6818 "transition": "transitionend", 6819 "WebkitTransition": "webkitTransitionEnd", 6820 "MozTransition": "transitionend", 6821 "OTransition": "otransitionend" 6822 }; 6823 var elem = document.createElement("div"), 6824 end; 6825 6826 for (var t in transitions) { 6827 if (typeof elem.style[t] !== "undefined") { 6828 end = transitions[t]; 6829 } 6830 } 6831 6832 if (end) { 6833 return end; 6834 } else { 6835 end = setTimeout(function () { 6836 $elem.triggerHandler("transitionend", [$elem]); 6837 }, 1); 6838 return "transitionend"; 6839 } 6840 } 6841 }; 6842 Foundation.util = { 6843 /** 6844 * Function for applying a debounce effect to a function call. 6845 * @function 6846 * @param {Function} func - Function to be called at end of timeout. 6847 * @param {Number} delay - Time in ms to delay the call of `func`. 6848 * @returns function 6849 */ 6850 throttle: function throttle(func, delay) { 6851 var timer = null; 6852 return function () { 6853 var context = this, 6854 args = arguments; 6855 6856 if (timer === null) { 6857 timer = setTimeout(function () {
6858 func.apply(context, args); 6859 timer = null; 6860 }, delay); 6861 } 6862 }; 6863 } 6864 }; // TODO: consider not making this a jQuery function 6865 // TODO: need way to reflow vs. re-initialize 6866 6867 /** 6868 * The Foundation jQuery method. 6869 * @param {String|Array} method - An action to perform on the current jQuery object. 6870 */ 6871 6872 var foundation = function foundation(method) { 6873 var type = _typeof(method), 6874 $meta = $("meta.foundation-mq"), 6875 $noJS = $(".no-js"); 6876 6877 if (!$meta.length) { 6878 $("<meta class=\"foundation-mq\">").appendTo(document.head); 6879 } 6880 6881 if ($noJS.length) { 6882 $noJS.removeClass("no-js"); 6883 } 6884 6885 if (type === "undefined") { 6886 //needs to initialize the Foundation object, or an individual plugin. 6887 Foundation.MediaQuery._init(); 6888 6889 Foundation.reflow(this); 6890 } else if (type === "string") { 6891 //an individual method to invoke on a plugin or group of plugins 6892 var args = Array.prototype.slice.call(arguments, 1); //collect all the arguments, if necessary 6893 6894 var plugClass = this.data("zfPlugin"); //determine the class of plugin 6895 6896 if (plugClass !== undefined && plugClass[method] !== undefined) { 6897 //make sure both the class and method exist 6898 if (this.length === 1) { 6899 //if there's only one, call it directly. 6900 plugClass[method].apply(plugClass, args); 6901 } else { 6902 this.each(function (i, el) { 6903 //otherwise loop through the jQuery collection and invoke the method on each 6904 plugClass[method].apply($(el).data("zfPlugin"), args); 6905 }); 6906 } 6907 } else { 6908 //error for no class or no method 6909 throw new ReferenceError("We're sorry, '" + method + "' is not an available method for " + (plugClass ? functionName(plugClass) : "this element") + "."); 6910 } 6911 } else { 6912 //error for invalid argument type 6913 throw new TypeError("We're sorry, " + type + " is not a valid parameter. You must use a string representing the method you wish to invoke."); 6914 } 6915 6916 return this; 6917 }; 6918 6919 window.Foundation = Foundation; 6920 $.fn.foundation = foundation; // Polyfill for requestAnimationFrame 6921 6922 (function () { 6923 if (!Date.now || !window.Date.now) window.Date.now = Date.now = function () { 6924 return new Date().getTime(); 6925 }; 6926 var vendors = ["webkit", "moz"]; 6927 6928 for (var i = 0; i < vendors.length && !window.requestAnimationFrame; ++i) { 6929 var vp = vendors[i]; 6930 window.requestAnimationFrame = window[vp + "RequestAnimationFrame"]; 6931 window.cancelAnimationFrame = window[vp + "CancelAnimationFrame"] || window[vp + "CancelRequestAnimationFrame"]; 6932 } 6933 6934 if (/iP(ad|hone|od).*OS 6/.test(window.navigator.userAgent) || !window.requestAnimationFrame || !window.cancelAnimationFrame) { 6935 var lastTime = 0; 6936 6937 window.requestAnimationFrame = function (callback) { 6938 var now = Date.now(); 6939 var nextTime = Math.max(lastTime + 16, now); 6940 return setTimeout(function () { 6941 callback(lastTime = nextTime); 6942 }, nextTime - now); 6943 }; 6944 6945 window.cancelAnimationFrame = clearTimeout; 6946 } 6947 /** 6948 * Polyfill for performance.now, required by rAF 6949 */ 6950 6951 6952 if (!window.performance || !window.performance.now) { 6953 window.performance = { 6954 start: Date.now(), 6955 now: function now() { 6956 return Date.now() - this.start; 6957 } 6958 }; 6959 } 6960 })(); 6961 6962 if (!Function.prototype.bind) { 6963 Function.prototype.bind = function (oThis) { 6964 if (typeof this !== "function") { 6965 // closest thing possible to the ECMAScript 5 6966 // internal IsCallable function 6967 throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable"); 6968 } 6969 6970 var aArgs = Array.prototype.slice.call(arguments, 1), 6971 fToBind = this, 6972 fNOP = function fNOP() {}, 6973 fBound = function fBound() { 6974 return fToBind.apply(this instanceof fNOP ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments))); 6975 }; 6976 6977 if (this.prototype) { 6978 // native functions don't have a prototype 6979 fNOP.prototype = this.prototype; 6980 } 6981 6982 fBound.prototype = new fNOP(); 6983 return fBound; 6984 }; 6985 } // Polyfill to get the name of a function in IE9 6986 6987 6988 function functionName(fn) { 6989 if (Function.prototype.name === undefined) { 6990 var funcNameRegex = /function\s([^(]{1,})\(/; 6991 var results = funcNameRegex.exec(fn.toString()); 6992 return results && results.length > 1 ? results[1].trim() : ""; 6993 } else if (fn.prototype === undefined) { 6994 return fn.constructor.name; 6995 } else { 6996 return fn.prototype.constructor.name; 6997 } 6998 } 6999 7000 function parseValue(str) { 7001 if (/true/.test(str)) return true;else if (/false/.test(str)) return false;else if (!isNaN(str * 1)) return parseFloat(str); 7002 return str; 7003 } // Convert PascalCase to kebab-case 7004 // Thank you: http://stackoverflow.com/a/8955580 7005 7006 7007 function hyphenate(str) { 7008 return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase(); 7009 } 7010}(jQuery); 7011 7012/***/ }), 7013 7014/***/ 1719: 7015/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { 7016 7017"use strict"; 7018 7019 7020function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 7021 7022function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); } 7023 7024function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } } 7025 7026function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; } 7027 7028function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; } 7029 7030function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } 7031 7032var toggleWindowScroll = __webpack_require__(6110); 7033 7034!function ($) { 7035 /** 7036 * Reveal module. 7037 * @module foundation.reveal 7038 * @requires foundation.util.keyboard 7039 * @requires foundation.util.box 7040 * @requires foundation.util.triggers 7041 * @requires foundation.util.mediaQuery 7042 * @requires foundation.util.motion if using animations 7043 */ 7044 var Reveal = /*#__PURE__*/function () { 7045 /** 7046 * Creates a new instance of Reveal. 7047 * @class 7048 * @param {jQuery} element - jQuery object to use for the modal. 7049 * @param {Object} options - optional parameters. 7050 */ 7051 function Reveal(element, options) { 7052 _classCallCheck(this, Reveal); 7053 7054 this.$element = element; 7055 this.options = $.extend({}, Reveal.defaults, this.$element.data(), options); 7056 7057 this._init(); 7058 7059 Foundation.registerPlugin(this, "Reveal"); 7060 Foundation.Keyboard.register("Reveal", { 7061 "ENTER": "open", 7062 "SPACE": "open", 7063 "ESCAPE": "close", 7064 "TAB": "tab_forward", 7065 "SHIFT_TAB": "tab_backward" 7066 }); 7067 } 7068 /** 7069 * Initializes the modal by adding the overlay and close buttons, (if selected). 7070 * @private 7071 */ 7072 7073 7074 _createClass(Reveal, [{ 7075 key: "_init", 7076 value: function _init() { 7077 this.id = this.$element.attr("id"); 7078 this.isActive = false;
7079 this.cached = { 7080 mq: Foundation.MediaQuery.current 7081 }; 7082 this.isMobile = mobileSniff(); 7083 this.$anchor = $("[data-open=\"".concat(this.id, "\"]")).length ? $("[data-open=\"".concat(this.id, "\"]")) : $("[data-toggle=\"".concat(this.id, "\"]")); 7084 this.$anchor.attr({ 7085 "aria-controls": this.id, 7086 "aria-haspopup": true, 7087 "tabindex": 0 7088 }); 7089 7090 if (this.options.fullScreen || this.$element.hasClass("full")) { 7091 this.options.fullScreen = true; 7092 this.options.overlay = false; 7093 } 7094 7095 if (this.options.overlay && !this.$overlay) { 7096 this.$overlay = this._makeOverlay(this.id); 7097 } 7098 7099 this.$element.attr({ 7100 "role": "dialog", 7101 "aria-hidden": true, 7102 "data-yeti-box": this.id, 7103 "data-resize": this.id 7104 }); 7105 7106 if (this.$overlay) { 7107 this.$element.detach().appendTo(this.$overlay); 7108 } else { 7109 this.$element.detach().appendTo($("body")); 7110 this.$element.addClass("without-overlay"); 7111 } 7112 7113 this._events(); 7114 7115 if (this.options.deepLink && window.location.hash === "#".concat(this.id)) { 7116 $(window).one("load.zf.reveal", this.open.bind(this)); 7117 } 7118 } 7119 /** 7120 * Creates an overlay div to display behind the modal. 7121 * @private 7122 */ 7123 7124 }, { 7125 key: "_makeOverlay", 7126 value: function _makeOverlay(id) {
7127 var $overlay = $("<div></div>").addClass("reveal-overlay").appendTo("body"); 7128 return $overlay; 7129 } 7130 /** 7131 * Updates position of modal 7132 * TODO: Figure out if we actually need to cache these values or if it doesn't matter 7133 * @private 7134 */ 7135 7136 }, { 7137 key: "_updatePosition", 7138 value: function _updatePosition() { 7139 var width = this.$element.outerWidth(); 7140 var outerWidth = $(window).width(); 7141 var height = this.$element.outerHeight(); 7142 var outerHeight = $(window).height(); 7143 var left, top; 7144 7145 if (this.options.hOffset === "auto") { 7146 left = parseInt((outerWidth - width) / 2, 10); 7147 } else { 7148 left = parseInt(this.options.hOffset, 10); 7149 } 7150 7151 if (this.options.vOffset === "auto") { 7152 if (height > outerHeight) { 7153 top = parseInt(Math.min(100, outerHeight / 10), 10); 7154 } else { 7155 top = parseInt((outerHeight - height) / 4, 10); 7156 } 7157 } else { 7158 top = parseInt(this.options.vOffset, 10); 7159 } 7160 7161 this.$element.css({ 7162 top: top + "px" 7163 }); // only worry about left if we don't have an overlay or we havea horizontal offset, 7164 // otherwise we're perfectly in the middle 7165 7166 if (!this.$overlay || this.options.hOffset !== "auto") { 7167 this.$element.css({ 7168 left: left + "px" 7169 }); 7170 this.$element.css({ 7171 margin: "0px" 7172 }); 7173 } 7174 } 7175 /** 7176 * Adds event handlers for the modal. 7177 * @private 7178 */ 7179 7180 }, { 7181 key: "_events", 7182 value: function _events() { 7183 var _this2 = this; 7184 7185 var _this = this; 7186 7187 this.$element.on({ 7188 "open.zf.trigger": this.open.bind(this), 7189 "close.zf.trigger": function closeZfTrigger(event, $element) { 7190 if (event.target === _this.$element[0] || $(event.target).parents("[data-closable]")[0] === $element) { 7191 // only close reveal when it's explicitly called 7192 return _this2.close.apply(_this2); 7193 } 7194 }, 7195 "toggle.zf.trigger": this.toggle.bind(this), 7196 "resizeme.zf.trigger": function resizemeZfTrigger() { 7197 _this._updatePosition(); 7198 } 7199 }); 7200 7201 if (this.$anchor.length) { 7202 this.$anchor.on("keydown.zf.reveal", function (e) { 7203 if (e.which === 13 || e.which === 32) { 7204 e.stopPropagation(); 7205 e.preventDefault(); 7206 7207 _this.open(); 7208 } 7209 }); 7210 } 7211 7212 if (this.options.closeOnClick && this.options.overlay) { 7213 this.$overlay.off(".zf.reveal").on("click.zf.reveal", function (e) { 7214 if (e.target === _this.$element[0] || $.contains(_this.$element[0], e.target) || !$.contains(document, e.target)) { 7215 return; 7216 } 7217 7218 _this.close(); 7219 }); 7220 } 7221 7222 if (this.options.deepLink) { 7223 $(window).on("popstate.zf.reveal:".concat(this.id), this._handleState.bind(this)); 7224 } 7225 } 7226 /** 7227 * Handles modal methods on back/forward button clicks or any other event that triggers popstate. 7228 * @private 7229 */ 7230 7231 }, { 7232 key: "_handleState", 7233 value: function _handleState(e) { 7234 if (window.location.hash === "#" + this.id && !this.isActive) { 7235 this.open(); 7236 } else { 7237 this.close(); 7238 } 7239 } 7240 /** 7241 * Opens the modal controlled by `this.$anchor`, and closes all others by default. 7242 * @function 7243 * @fires Reveal#closeme 7244 * @fires Reveal#open 7245 */ 7246 7247 }, { 7248 key: "open", 7249 value: function open() { 7250 var _this3 = this; 7251 7252 if (this.options.deepLink) { 7253 var hash = "#".concat(this.id); 7254 7255 if (window.history.pushState) { 7256 window.history.pushState(null, null, hash); 7257 } else { 7258 window.location.hash = hash; 7259 } 7260 } 7261 7262 this.isActive = true; // Make elements invisible, but remove display: none so we can get size and positioning 7263 7264 this.$element.css({ 7265 "visibility": "hidden" 7266 }).show(); 7267 7268 if (this.options.overlay) { 7269 this.$overlay.css({ 7270 "visibility": "hidden" 7271 }).show(); 7272 } 7273 7274 this._updatePosition(); 7275 7276 this.$element.hide().css({ 7277 "visibility": "" 7278 }); 7279 7280 if (this.$overlay) { 7281 this.$overlay.css({ 7282 "visibility": "" 7283 }).hide(); 7284 7285 if (this.$element.hasClass("fast")) { 7286 this.$overlay.addClass("fast"); 7287 } else if (this.$element.hasClass("slow")) { 7288 this.$overlay.addClass("slow"); 7289 } 7290 } 7291 7292 if (!this.options.multipleOpened) { 7293 /** 7294 * Fires immediately before the modal opens. 7295 * Closes any other modals that are currently open 7296 * @event Reveal#closeme 7297 */ 7298 this.$element.trigger("closeme.zf.reveal", this.id); 7299 } // Motion UI method of reveal 7300 7301 7302 if (this.options.animationIn) { 7303 var afterAnimationFocus = function afterAnimationFocus() { 7304 _this.$element.attr({ 7305 "aria-hidden": false, 7306 "tabindex": -1 7307 }).focus(); 7308 }; 7309 7310 var _this = this; 7311 7312 if (this.options.overlay) { 7313 Foundation.Motion.animateIn(this.$overlay, "fade-in"); 7314 } 7315 7316 Foundation.Motion.animateIn(this.$element, this.options.animationIn, function () { 7317 _this3.focusableElements = Foundation.Keyboard.findFocusable(_this3.$element); 7318 afterAnimationFocus(); 7319 }); 7320 } // jQuery method of reveal 7321 else { 7322 if (this.options.overlay) { 7323 this.$overlay.show(0); 7324 } 7325 7326 this.$element.show(this.options.showDelay); 7327 } // handle accessibility 7328 7329 7330 this.$element.attr({ 7331 "aria-hidden": false, 7332 "tabindex": -1 7333 }).focus(); 7334 /** 7335 * Fires when the modal has successfully opened. 7336 * @event Reveal#open 7337 */ 7338 7339 this.$element.trigger("open.zf.reveal"); 7340 toggleWindowScroll.toggleWindowScroll("lock"); 7341 setTimeout(function () { 7342 _this3._extraHandlers(); 7343 }, 0); 7344 } 7345 /** 7346 * Adds extra event handlers for the body and window if necessary. 7347 * @private 7348 */ 7349 7350 }, {
7351 key: "_extraHandlers", 7352 value: function _extraHandlers() { 7353 var _this = this; 7354 7355 this.focusableElements = Foundation.Keyboard.findFocusable(this.$element); 7356 7357 if (!this.options.overlay && this.options.closeOnClick && !this.options.fullScreen) { 7358 $("body").on("click.zf.reveal", function (e) { 7359 if (e.target === _this.$element[0] || $.contains(_this.$element[0], e.target) || !$.contains(document, e.target)) { 7360 return; 7361 } 7362 7363 _this.close(); 7364 }); 7365 } 7366 7367 if (this.options.closeOnEsc) { 7368 $(window).on("keydown.zf.reveal", function (e) { 7369 Foundation.Keyboard.handleKey(e, "Reveal", { 7370 close: function close() { 7371 if (_this.options.closeOnEsc) { 7372 _this.close(); 7373 7374 _this.$anchor.focus(); 7375 } 7376 } 7377 }); 7378 }); 7379 } // lock focus within modal while tabbing 7380 7381 7382 this.$element.on("keydown.zf.reveal", function (e) { 7383 var $target = $(this); // handle keyboard event with keyboard util 7384 7385 Foundation.Keyboard.handleKey(e, "Reveal", { 7386 tab_forward: function tab_forward() { 7387 _this.focusableElements = Foundation.Keyboard.findFocusable(_this.$element); 7388 7389 if (_this.$element.find(":focus").is(_this.focusableElements.eq(-1))) { 7390 // left modal downwards, setting focus to first element 7391 _this.focusableElements.eq(0).focus(); 7392 7393 return true; 7394 } 7395 7396 if (_this.focusableElements.length === 0) { 7397 // no focusable elements inside the modal at all, prevent tabbing in general 7398 return true; 7399 } 7400 }, 7401 tab_backward: function tab_backward() { 7402 _this.focusableElements = Foundation.Keyboard.findFocusable(_this.$element); 7403 7404 if (_this.$element.find(":focus").is(_this.focusableElements.eq(0)) || _this.$element.is(":focus")) { 7405 // left modal upwards, setting focus to last element 7406 _this.focusableElements.eq(-1).focus(); 7407 7408 return true; 7409 } 7410 7411 if (_this.focusableElements.length === 0) { 7412 // no focusable elements inside the modal at all, prevent tabbing in general 7413 return true; 7414 } 7415 }, 7416 open: function open() { 7417 if (_this.$element.find(":focus").is(_this.$element.find("[data-close]"))) { 7418 setTimeout(function () { 7419 // set focus back to anchor if close button has been activated 7420 _this.$anchor.focus(); 7421 }, 1); 7422 } else if ($target.is(_this.focusableElements)) { 7423 // dont't trigger if acual element has focus (i.e. inputs, links, ...) 7424 _this.open(); 7425 } 7426 }, 7427 close: function close() { 7428 if (_this.options.closeOnEsc) { 7429 _this.close(); 7430 7431 _this.$anchor.focus(); 7432 } 7433 }, 7434 handled: function handled(preventDefault) { 7435 if (preventDefault) { 7436 e.preventDefault(); 7437 } 7438 } 7439 }); 7440 }); 7441 } 7442 /** 7443 * Closes the modal. 7444 * @function 7445 * @fires Reveal#closed 7446 */ 7447 7448 }, { 7449 key: "close", 7450 value: function close() { 7451 if (!this.isActive || !this.$element.is(":visible")) { 7452 return false; 7453 } 7454 7455 var _this = this; // Motion UI method of hiding 7456 7457 7458 if (this.options.animationOut) { 7459 if (this.options.overlay) { 7460 Foundation.Motion.animateOut(this.$overlay, "fade-out", finishUp); 7461 } else { 7462 finishUp(); 7463 } 7464 7465 Foundation.Motion.animateOut(this.$element, this.options.animationOut); 7466 } // jQuery method of hiding 7467 else { 7468 if (this.options.overlay) { 7469 this.$overlay.hide(0, finishUp); 7470 } else { 7471 finishUp(); 7472 } 7473 7474 this.$element.hide(this.options.hideDelay); 7475 } // Conditionals to remove extra event listeners added on open 7476 7477 7478 if (this.options.closeOnEsc) { 7479 $(window).off("keydown.zf.reveal"); 7480 } 7481 7482 if (!this.options.overlay && this.options.closeOnClick) {
7483 $("body").off("click.zf.reveal"); 7484 } 7485 7486 this.$element.off("keydown.zf.reveal"); 7487 7488 function finishUp() { 7489 toggleWindowScroll.toggleWindowScroll("unlock"); 7490 7491 _this.$element.attr("aria-hidden", true); 7492 /** 7493 * Fires when the modal is done closing. 7494 * @event Reveal#closed 7495 */ 7496 7497 7498 _this.$element.trigger("closed.zf.reveal"); 7499 } 7500 /** 7501 * Resets the modal content 7502 * This prevents a running video to keep going in the background 7503 */ 7504 7505 7506 if (this.options.resetOnClose) { 7507 this.$element.html(this.$element.html()); 7508 } 7509 7510 this.isActive = false; 7511 7512 if (_this.options.deepLink) { 7513 if (window.history.replaceState) { 7514 window.history.replaceState("", document.title, window.location.pathname); 7515 } else { 7516 window.location.hash = ""; 7517 } 7518 } 7519 } 7520 /** 7521 * Toggles the open/closed state of a modal. 7522 * @function 7523 */ 7524 7525 }, { 7526 key: "toggle", 7527 value: function toggle() { 7528 if (this.isActive) { 7529 this.close(); 7530 } else { 7531 this.open(); 7532 } 7533 } 7534 /** 7535 * Destroys an instance of a modal. 7536 * @function 7537 */ 7538 7539 }, { 7540 key: "destroy", 7541 value: function destroy() { 7542 if (this.options.overlay) { 7543 this.$element.appendTo($("body")); // move $element outside of $overlay to prevent error unregisterPlugin() 7544 7545 this.$overlay.hide().off().remove(); 7546 } 7547 7548 this.$element.hide().off(); 7549 this.$anchor.off(".zf"); 7550 $(window).off(".zf.reveal:".concat(this.id)); 7551 Foundation.unregisterPlugin(this); 7552 } 7553 }]); 7554 7555 return Reveal; 7556 }(); 7557 7558 Reveal.defaults = { 7559 /** 7560 * Motion-UI class to use for animated elements. If none used, defaults to simple show/hide. 7561 * @option 7562 * @example 'slide-in-left' 7563 */ 7564 animationIn: "", 7565 7566 /** 7567 * Motion-UI class to use for animated elements. If none used, defaults to simple show/hide. 7568 * @option 7569 * @example 'slide-out-right' 7570 */ 7571 animationOut: "", 7572 7573 /** 7574 * Time, in ms, to delay the opening of a modal after a click if no animation used. 7575 * @option 7576 * @example 10 7577 */ 7578 showDelay: 0, 7579 7580 /** 7581 * Time, in ms, to delay the closing of a modal after a click if no animation used. 7582 * @option 7583 * @example 10 7584 */ 7585 hideDelay: 0, 7586 7587 /** 7588 * Allows a click on the body/overlay to close the modal. 7589 * @option 7590 * @example true 7591 */ 7592 closeOnClick: true, 7593 7594 /** 7595 * Allows the modal to close if the user presses the `ESCAPE` key. 7596 * @option 7597 * @example true 7598 */ 7599 closeOnEsc: true, 7600 7601 /** 7602 * If true, allows multiple modals to be displayed at once. 7603 * @option 7604 * @example false 7605 */ 7606 multipleOpened: false, 7607 7608 /** 7609 * Distance, in pixels, the modal should push down from the top of the screen. 7610 * @option 7611 * @example auto 7612 */ 7613 vOffset: "auto", 7614 7615 /** 7616 * Distance, in pixels, the modal should push in from the side of the screen. 7617 * @option 7618 * @example auto 7619 */ 7620 hOffset: "auto", 7621 7622 /** 7623 * Allows the modal to be fullscreen, completely blocking out the rest of the view. JS checks for this as well. 7624 * @option 7625 * @example false 7626 */ 7627 fullScreen: false, 7628 7629 /** 7630 * Percentage of screen height the modal should push up from the bottom of the view. 7631 * @option 7632 * @example 10 7633 */ 7634 btmOffsetPct: 10, 7635 7636 /** 7637 * Allows the modal to generate an overlay div, which will cover the view when modal opens. 7638 * @option 7639 * @example true 7640 */ 7641 overlay: true, 7642 7643 /** 7644 * Allows the modal to remove and reinject markup on close. Should be true if using video elements w/o using provider's api, otherwise, videos will continue to play in the background. 7645 * @option 7646 * @example false 7647 */ 7648 resetOnClose: false, 7649 7650 /** 7651 * Allows the modal to alter the url on open/close, and allows the use of the `back` button to close modals. ALSO, allows a modal to auto-maniacally open on page load IF the hash === the modal'
7651s user-set id. 7652 * @option 7653 * @example false 7654 */ 7655 deepLink: false 7656 }; // Window exports 7657 7658 Foundation.plugin(Reveal, "Reveal"); 7659 7660 function iPhoneSniff() { 7661 return /iP(ad|hone|od).*OS/.test(window.navigator.userAgent); 7662 } 7663 7664 function androidSniff() { 7665 return /Android/.test(window.navigator.userAgent); 7666 } 7667 7668 function mobileSniff() { 7669 return iPhoneSniff() || androidSniff(); 7670 } 7671}(jQuery); 7672 7673/***/ }), 7674 7675/***/ 365: 7676/***/ (() => { 7677 7678"use strict"; 7679 7680 7681var _createClass = function () { 7682 function defineProperties(target, props) { 7683 for (var i = 0; i < props.length; i++) { 7684 var descriptor = props[i]; 7685 descriptor.enumerable = descriptor.enumerable || false; 7686 descriptor.configurable = true; 7687 if ("value" in descriptor) descriptor.writable = true; 7688 Object.defineProperty(target, descriptor.key, descriptor); 7689 } 7690 } 7691 7692 return function (Constructor, protoProps, staticProps) { 7693 if (protoProps) defineProperties(Constructor.prototype, protoProps); 7694 if (staticProps) defineProperties(Constructor, staticProps); 7695 return Constructor; 7696 }; 7697}(); 7698 7699function _classCallCheck(instance, Constructor) { 7700 if (!(instance instanceof Constructor)) { 7701 throw new TypeError("Cannot call a class as a function"); 7702 } 7703} 7704 7705!function ($) { 7706 /** 7707 * Sticky module. 7708 * @module foundation.sticky 7709 * @requires foundation.util.triggers 7710 * @requires foundation.util.mediaQuery 7711 */ 7712 var Sticky = function () { 7713 /** 7714 * Creates a new instance of a sticky thing. 7715 * @class 7716 * @param {jQuery} element - jQuery object to make sticky. 7717 * @param {Object} options - options object passed when creating the element programmatically. 7718 */ 7719 function Sticky(element, options) { 7720 _classCallCheck(this, Sticky); 7721 7722 this.$element = element; 7723 this.options = $.extend({}, Sticky.defaults, this.$element.data(), options); 7724 7725 this._init(); 7726 7727 Foundation.registerPlugin(this, "Sticky"); 7728 } 7729 /** 7730 * Initializes the sticky element by adding classes, getting/setting dimensions, breakpoints and attributes 7731 * @function 7732 * @private 7733 */ 7734 7735 7736 _createClass(Sticky, [{ 7737 key: "_init", 7738 value: function _init() { 7739 var $parent = this.$element.parent("[data-sticky-container]"), 7740 id = this.$element[0].id || Foundation.GetYoDigits(6, "sticky"), 7741 _this = this; 7742 7743 if (!$parent.length) { 7744 this.wasWrapped = true; 7745 } 7746 7747 this.$container = $parent.length ? $parent : $(this.options.container).wrapInner(this.$element); 7748 this.$container.addClass(this.options.containerClass); 7749 this.$element.addClass(this.options.stickyClass).attr({ 7750 "data-resize": id 7751 }); 7752 this.scrollCount = this.options.checkEvery; 7753 this.isStuck = false; 7754 7755 function loaded() { 7756 //We calculate the container height to have correct values for anchor points offset calculation. 7757 _this.containerHeight = _this.$element.css("display") == "none" ? 0 : _this.$element[0].getBoundingClientRect().height; 7758 7759 _this.$container.css("height", _this.containerHeight); 7760 7761 _this.elemHeight = _this.containerHeight; 7762 7763 if (_this.options.anchor !== "") { 7764 _this.$anchor = $("#" + _this.options.anchor); 7765 } else { 7766 _this._parsePoints(); 7767 } 7768 7769 _this._setSizes(function () { 7770 _this._calc(false); 7771 }); 7772 7773 _this._events(id.split("-").reverse().join("-")); 7774 } 7775 7776 if (document.readyState == "complete") { 7777 loaded(); 7778 } else { 7779 $(window).one("load.zf.sticky", loaded); 7780 } 7781 } 7782 /** 7783 * If using multiple elements as anchors, calculates the top and bottom pixel values the sticky thing should stick and unstick on. 7784 * @function 7785 * @private 7786 */ 7787 7788 }, { 7789 key: "_parsePoints", 7790 value: function _parsePoints() { 7791 var top = this.options.topAnchor == "" ? 1 : this.options.topAnchor, 7792 btm = this.options.btmAnchor == "" ? document.documentElement.scrollHeight : this.options.btmAnchor, 7793 pts = [top, btm], 7794 breaks = {}; 7795 7796 for (var i = 0, len = pts.length; i < len && pts[i]; i++) { 7797 var pt; 7798
7799 if (typeof pts[i] === "number") { 7800 pt = pts[i]; 7801 } else { 7802 var place = pts[i].split(":"), 7803 anchor = $("#" + place[0]); 7804 pt = anchor.offset().top; 7805 7806 if (place[1] && place[1].toLowerCase() === "bottom") { 7807 pt += anchor[0].getBoundingClientRect().height; 7808 } 7809 } 7810 7811 breaks[i] = pt; 7812 } 7813 7814 this.points = breaks; 7815 return; 7816 } 7817 /** 7818 * Adds event handlers for the scrolling element. 7819 * @private 7820 * @param {String} id - psuedo-random id for unique scroll event listener. 7821 */ 7822 7823 }, { 7824 key: "_events", 7825 value: function _events(id) { 7826 var _this = this, 7827 scrollListener = this.scrollListener = "scroll.zf." + id; 7828 7829 if (this.isOn) { 7830 return; 7831 } 7832 7833 if (this.canStick) { 7834 this.isOn = true; 7835 $(window).off(scrollListener).on(scrollListener, function (e) { 7836 if (_this.scrollCount === 0) { 7837 _this.scrollCount = _this.options.checkEvery; 7838 7839 _this._setSizes(function () { 7840 _this._calc(false, window.pageYOffset); 7841 }); 7842 } else { 7843 _this.scrollCount--; 7844 7845 _this._calc(false, window.pageYOffset); 7846 } 7847 }); 7848 } 7849 7850 this.$element.off("resizeme.zf.trigger").on("resizeme.zf.trigger", function (e, el) { 7851 _this._setSizes(function () { 7852 _this._calc(false); 7853 7854 if (_this.canStick) { 7855 if (!_this.isOn) { 7856 _this._events(id); 7857 } 7858 } else if (_this.isOn) { 7859 _this._pauseListeners(scrollListener); 7860 } 7861 }); 7862 }); 7863 } 7864 /** 7865 * Removes event handlers for scroll and change events on anchor. 7866 * @fires Sticky#pause 7867 * @param {String} scrollListener - unique, namespaced scroll listener attached to `window` 7868 */ 7869 7870 }, { 7871 key: "_pauseListeners", 7872 value: function _pauseListeners(scrollListener) { 7873 this.isOn = false; 7874 $(window).off(scrollListener); 7875 /** 7876 * Fires when the plugin is paused due to resize event shrinking the view. 7877 * @event Sticky#pause 7878 * @private 7879 */ 7880 7881 this.$element.trigger("pause.zf.sticky"); 7882 } 7883 /** 7884 * Called on every `scroll` event and on `_init` 7885 * fires functions based on booleans and cached values 7886 * @param {Boolean} checkSizes - true if plugin should recalculate sizes and breakpoints. 7887 * @param {Number} scroll - current scroll position passed from scroll event cb function. If not passed, defaults to `window.pageYOffset`. 7888 */ 7889 7890 }, { 7891 key: "_calc", 7892 value: function _calc(checkSizes, scroll) { 7893 if (checkSizes) { 7894 this._setSizes(); 7895 } 7896 7897 if (!this.canStick) { 7898 if (this.isStuck) { 7899 this._removeSticky(true); 7900 } 7901 7902 return false; 7903 } 7904 7905 if (!scroll) { 7906 scroll = window.pageYOffset; 7907 } 7908 7909 if (scroll >= this.topPoint) { 7910 if (scroll <= this.bottomPoint) { 7911 if (!this.isStuck) { 7912 this._setSticky(); 7913 } 7914 } else { 7915 if (this.isStuck) { 7916 this._removeSticky(false); 7917 } 7918 } 7919 } else { 7920 if (this.isStuck) { 7921 this._removeSticky(true); 7922 } 7923 } 7924 } 7925 /** 7926 * Causes the $element to become stuck. 7927 * Adds `position: fixed;`, and helper classes. 7928 * @fires Sticky#stuckto 7929 * @function 7930 * @private 7931 */ 7932 7933 }, { 7934 key: "_setSticky", 7935 value: function _setSticky() { 7936 var _this = this, 7937 stickTo = this.options.stickTo, 7938 mrgn = stickTo === "top" ? "marginTop" : "marginBottom", 7939 notStuckTo = stickTo === "top" ? "bottom" : "top", 7940 css = {}; 7941 7942 css[mrgn] = this.options[mrgn] + "em"; 7943 css[stickTo] = 0; 7944 css[notStuckTo] = "auto"; 7945 css["left"] = this.$container.offset().left + parseInt(window.getComputedStyle(this.$container[0])["padding-left"], 10); 7946 this.isStuck = true; 7947 this.$element.removeClass("is-anchored is-at-" + notStuckTo).addClass("is-stuck is-at-" + stickTo).css(css) 7948 /** 7949 * Fires when the $element has become `position: fixed;` 7950 * Namespaced to `top` or `bottom`, e.g. `sticky.zf.stuckto:top` 7951 * @event Sticky#stuckto 7952 */ 7953 .trigger("sticky.zf.stuckto:" + stickTo); 7954 this.$element.on("transitionend webkitTransitionEnd oTransitionEnd otransitionend MSTransitionEnd", function () { 7955 _this._setSizes(); 7956 }); 7957 } 7958 /** 7959 * Causes the $element to become unstuck. 7960 * Removes `position: fixed;`, and helper classes. 7961 * Adds other helper classes. 7962 * @param {Boolean} isTop - tells the function if the $element should anchor to the top or bottom of its $anchor element. 7963 * @fires Sticky#unstuckfrom 7964 * @private 7965 */ 7966 7967 }, {
7968 key: "_removeSticky", 7969 value: function _removeSticky(isTop) { 7970 var stickTo = this.options.stickTo, 7971 stickToTop = stickTo === "top", 7972 css = {}, 7973 anchorPt = (this.points ? this.points[1] - this.points[0] : this.anchorHeight) - this.elemHeight, 7974 mrgn = stickToTop ? "marginTop" : "marginBottom", 7975 notStuckTo = stickToTop ? "bottom" : "top", 7976 topOrBottom = isTop ? "top" : "bottom"; 7977 css[mrgn] = 0; 7978 css["bottom"] = "auto"; 7979 7980 if (isTop) { 7981 css["top"] = 0; 7982 } else { 7983 css["top"] = anchorPt; 7984 } 7985 7986 css["left"] = ""; 7987 this.isStuck = false; 7988 this.$element.removeClass("is-stuck is-at-" + stickTo).addClass("is-anchored is-at-" + topOrBottom).css(css) 7989 /** 7990 * Fires when the $element has become anchored. 7991 * Namespaced to `top` or `bottom`, e.g. `sticky.zf.unstuckfrom:bottom` 7992 * @event Sticky#unstuckfrom 7993 */ 7994 .trigger("sticky.zf.unstuckfrom:" + topOrBottom); 7995 } 7996 /** 7997 * Sets the $element and $container sizes for plugin. 7998 * Calls `_setBreakPoints`. 7999 * @param {Function} cb - optional callback function to fire on completion of `_setBreakPoints`. 8000 * @private 8001 */ 8002 8003 }, { 8004 key: "_setSizes", 8005 value: function _setSizes(cb) { 8006 this.canStick = Foundation.MediaQuery.atLeast(this.options.stickyOn); 8007 8008 if (!this.canStick) { 8009 if (cb && typeof cb === "function") { 8010 cb(); 8011 } 8012 } 8013 8014 var _this = this, 8015 newElemWidth = this.$container[0].getBoundingClientRect().width, 8016 comp = window.getComputedStyle(this.$container[0]), 8017 pdng = parseInt(comp["padding-right"], 10); 8018 8019 if (this.$anchor && this.$anchor.length) { 8020 this.anchorHeight = this.$anchor[0].getBoundingClientRect().height; 8021 } else { 8022 this._parsePoints(); 8023 } 8024 8025 this.$element.css({ 8026 "max-width": newElemWidth - pdng + "px" 8027 }); 8028 var newContainerHeight = this.$element[0].getBoundingClientRect().height || this.containerHeight; 8029 8030 if (this.$element.css("display") == "none") { 8031 newContainerHeight = 0; 8032 } 8033 8034 this.containerHeight = newContainerHeight; 8035 this.$container.css({ 8036 height: newContainerHeight 8037 }); 8038 this.elemHeight = newContainerHeight; 8039 8040 if (this.isStuck) { 8041 this.$element.css({ 8042 "left": this.$container.offset().left + parseInt(comp["padding-left"], 10) 8043 }); 8044 } else { 8045 if (this.$element.hasClass("is-at-bottom")) { 8046 var anchorPt = (this.points ? this.points[1] - this.$container.offset().top : this.anchorHeight) - this.elemHeight;
8047 this.$element.css("top", anchorPt); 8048 } 8049 } 8050 8051 this._setBreakPoints(newContainerHeight, function () { 8052 if (cb && typeof cb === "function") { 8053 cb(); 8054 } 8055 }); 8056 } 8057 /** 8058 * Sets the upper and lower breakpoints for the element to become sticky/unsticky. 8059 * @param {Number} elemHeight - px value for sticky.$element height, calculated by `_setSizes`. 8060 * @param {Function} cb - optional callback function to be called on completion. 8061 * @private 8062 */ 8063 8064 }, { 8065 key: "_setBreakPoints", 8066 value: function _setBreakPoints(elemHeight, cb) { 8067 if (!this.canStick) { 8068 if (cb && typeof cb === "function") { 8069 cb(); 8070 } else { 8071 return false; 8072 } 8073 } 8074 8075 var mTop = emCalc(this.options.marginTop), 8076 mBtm = emCalc(this.options.marginBottom), 8077 topPoint = this.points ? this.points[0] : this.$anchor.offset().top, 8078 bottomPoint = this.points ? this.points[1] : topPoint + this.anchorHeight, 8079 // topPoint = this.$anchor.offset().top || this.points[0], 8080 // bottomPoint = topPoint + this.anchorHeight || this.points[1], 8081 winHeight = window.innerHeight; 8082 8083 if (this.options.stickTo === "top") { 8084 topPoint -= mTop; 8085 bottomPoint -= elemHeight + mTop; 8086 } else if (this.options.stickTo === "bottom") { 8087 topPoint -= winHeight - (elemHeight + mBtm); 8088 bottomPoint -= winHeight - mBtm; 8089 } else {//this would be the stickTo: both option... tricky 8090 } 8091 8092 this.topPoint = topPoint; 8093 this.bottomPoint = bottomPoint; 8094 8095 if (cb && typeof cb === "function") { 8096 cb(); 8097 } 8098 } 8099 /** 8100 * Destroys the current sticky element. 8101 * Resets the element to the top position first. 8102 * Removes event listeners, JS-added css properties and classes, and unwraps the $element if the JS added the $container. 8103 * @function 8104 */ 8105 8106 }, { 8107 key: "destroy", 8108 value: function destroy() { 8109 this._removeSticky(true); 8110 8111 this.$element.removeClass(this.options.stickyClass + " is-anchored is-at-top").css({ 8112 height: "", 8113 top: "", 8114 bottom: "", 8115 "max-width": "" 8116 }).off("resizeme.zf.trigger"); 8117 8118 if (this.$anchor && this.$anchor.length) { 8119 this.$anchor.off("change.zf.sticky"); 8120 } 8121 8122 $(window).off(this.scrollListener); 8123 8124 if (this.wasWrapped) { 8125 this.$element.unwrap(); 8126 } else { 8127 this.$container.removeClass(this.options.containerClass).css({ 8128 height: "" 8129 }); 8130 } 8131 8132 Foundation.unregisterPlugin(this); 8133 } 8134 }]); 8135 8136 return Sticky; 8137 }(); 8138 8139 Sticky.defaults = { 8140 /** 8141 * Customizable container template. Add your own classes for styling and sizing. 8142 * @option 8143 * @example '<div data-sticky-container class="small-6 columns"></div>' 8144 */ 8145 container: "<div data-sticky-container></div>", 8146 8147 /** 8148 * Location in the view the element sticks to. 8149 * @option 8150 * @example 'top' 8151 */ 8152 stickTo: "top", 8153 8154 /** 8155 * If anchored to a single element, the id of that element. 8156 * @option 8157 * @example 'exampleId' 8158 */ 8159 anchor: "", 8160 8161 /** 8162 * If using more than one element as anchor points, the id of the top anchor. 8163 * @option 8164 * @example 'exampleId:top' 8165 */ 8166 topAnchor: "", 8167 8168 /** 8169 * If using more than one element as anchor points, the id of the bottom anchor. 8170 * @option 8171 * @example 'exampleId:bottom' 8172 */ 8173 btmAnchor: "", 8174 8175 /** 8176 * Margin, in `em`'s to apply to the top of the element when it becomes sticky. 8177 * @option 8178 * @example 1 8179 */ 8180 marginTop: 1, 8181 8182 /** 8183 * Margin, in `em`'s to apply to the bottom of the element when it becomes sticky. 8184 * @option 8185 * @example 1 8186 */ 8187 marginBottom: 1, 8188 8189 /** 8190 * Breakpoint string that is the minimum screen size an element should become sticky. 8191 * @option 8192 * @example 'medium' 8193 */ 8194 stickyOn: "medium", 8195 8196 /** 8197 * Class applied to sticky element, and removed on destruction. Foundation defaults to `sticky`. 8198 * @option 8199 * @example 'sticky' 8200 */ 8201 stickyClass: "sticky", 8202 8203 /** 8204 * Class applied to sticky container. Foundation defaults to `sticky-container`. 8205 * @option 8206 * @example 'sticky-container' 8207 */ 8208 containerClass: "sticky-container", 8209 8210 /** 8211 * Number of scroll events between the plugin's recalculating sticky points. Setting it to `0` will cause it to recalc every scroll event, setting it to `-1` will prevent recalc on scroll. 8212 * @option 8213 * @example 50 8214 */ 8215 checkEvery: -1 8216 }; 8217 /** 8218 * Helper function to calculate em values 8219 * @param Number {em} - number of em's to calculate into pixels 8220 */ 8221 8222 function emCalc(em) { 8223 return parseInt(window.getComputedStyle(document.body, null).fontSize, 10) * em; 8224 } // Window exports 8225 8226 8227 Foundation.plugin(Sticky, "Sticky"); 8228}(jQuery); 8229 8230/***/ }), 8231 8232/***/ 9906: 8233/***/ (() => { 8234 8235"use strict"; 8236 8237 8238function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 8239 8240!function ($) { 8241 // Default set of media queries 8242 var defaultQueries = { 8243 "default": "only screen", 8244 landscape: "only screen and (orientation: landscape)", 8245 portrait: "only screen and (orientation: portrait)", 8246 retina: "only screen and (-webkit-min-device-pixel-ratio: 2)," + "only screen and (min--moz-device-pixel-ratio: 2)," + "only screen and (-o-min-device-pixel-ratio: 2/1)," + "only screen and (min-device-pixel-ratio: 2)," + "only screen and (min-resolution: 192dpi)," + "only screen and (min-resolution: 2dppx)" 8247 }; 8248 var MediaQuery = { 8249 queries: [], 8250 current: "", 8251 8252 /** 8253 * Initializes the media query helper, by extracting the breakpoint list from the CSS and activating the breakpoint watcher. 8254 * @function 8255 * @private 8256 */ 8257 _init: function _init() { 8258 var self = this;
8259 var extractedStyles = $(".foundation-mq").css("font-family"); 8260 var namedQueries; 8261 namedQueries = parseStyleToObject(extractedStyles); 8262 8263 for (var key in namedQueries) { 8264 if (namedQueries.hasOwnProperty(key)) { 8265 self.queries.push({ 8266 name: key, 8267 value: "only screen and (min-width: " + namedQueries[key] + ")" 8268 }); 8269 } 8270 } 8271 8272 this.current = this._getCurrentSize(); 8273 8274 this._watcher(); 8275 }, 8276 8277 /** 8278 * Checks if the screen is at least as wide as a breakpoint. 8279 * @function 8280 * @param {String} size - Name of the breakpoint to check. 8281 * @returns {Boolean} `true` if the breakpoint matches, `false` if it's smaller. 8282 */ 8283 atLeast: function atLeast(size) { 8284 var query = this.get(size); 8285 8286 if (query) { 8287 return window.matchMedia(query).matches; 8288 } 8289 8290 return false; 8291 }, 8292 8293 /** 8294 * Gets the media query of a breakpoint. 8295 * @function 8296 * @param {String} size - Name of the breakpoint to get. 8297 * @returns {String|null} - The media query of the breakpoint, or `null` if the breakpoint doesn't exist. 8298 */ 8299 get: function get(size) { 8300 for (var i in this.queries) { 8301 if (this.queries.hasOwnProperty(i)) { 8302 var query = this.queries[i]; 8303 if (size === query.name) return query.value; 8304 } 8305 } 8306 8307 return null; 8308 }, 8309 8310 /** 8311 * Gets the current breakpoint name by testing every breakpoint and returning the last one to match (the biggest one). 8312 * @function 8313 * @private 8314 * @returns {String} Name of the current breakpoint. 8315 */ 8316 _getCurrentSize: function _getCurrentSize() { 8317 var matched; 8318 8319 for (var i = 0; i < this.queries.length; i++) { 8320 var query = this.queries[i]; 8321 8322 if (window.matchMedia(query.value).matches) { 8323 matched = query; 8324 } 8325 } 8326 8327 if (_typeof(matched) === "object") { 8328 return matched.name; 8329 } else { 8330 return matched; 8331 } 8332 }, 8333 8334 /** 8335 * Activates the breakpoint watcher, which fires an event on the window whenever the breakpoint changes. 8336 * @function 8337 * @private 8338 */ 8339 _watcher: function _watcher() { 8340 var _this = this; 8341 8342 $(window).on("resize.zf.mediaquery", function () { 8343 var newSize = _this._getCurrentSize(), 8344 currentSize = _this.current; 8345 8346 if (newSize !== currentSize) { 8347 // Change the current media query 8348 _this.current = newSize; // Broadcast the media query change on the window 8349 8350 $(window).trigger("changed.zf.mediaquery", [newSize, currentSize]); 8351 } 8352 }); 8353 } 8354 }; 8355 Foundation.MediaQuery = MediaQuery; // matchMedia() polyfill - Test a CSS media type/query in JS. 8356 // Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas, David Knight. Dual MIT/BSD license 8357 8358 window.matchMedia || (window.matchMedia = function () { 8359 "use strict"; // For browsers that support matchMedium api such as IE 9 and webkit 8360 8361 var styleMedia = window.styleMedia || window.media; // For those that don't support matchMedium 8362 8363 if (!styleMedia) { 8364 var style = document.createElement("style"), 8365 script = document.getElementsByTagName("script")[0], 8366 info = null; 8367 style.type = "text/css"; 8368 style.id = "matchmediajs-test"; 8369 script && script.parentNode && script.parentNode.insertBefore(style, script); // 'style.currentStyle' is used by IE <= 8 and 'window.getComputedStyle' for all other browsers 8370 8371 info = "getComputedStyle" in window && window.getComputedStyle(style, null) || style.currentStyle; 8372 styleMedia = { 8373 matchMedium: function matchMedium(media) { 8374 var text = "@media " + media + "{ #matchmediajs-test { width: 1px; } }"; // 'style.styleSheet' is used by IE <= 8 and 'style.textContent' for all other browsers 8375 8376 if (style.styleSheet) { 8377 style.styleSheet.cssText = text; 8378 } else { 8379 style.textContent = text; 8380 } // Test if media query is true or false 8381 8382 8383 return info.width === "1px"; 8384 } 8385 }; 8386 } 8387 8388 return function (media) { 8389 return { 8390 matches: styleMedia.matchMedium(media || "all"), 8391 media: media || "all" 8392 }; 8393 }; 8394 }()); // Thank you: https://github.com/sindresorhus/query-string 8395 8396 function parseStyleToObject(str) { 8397 var styleObject = {}; 8398 8399 if (typeof str !== "string") { 8400 return styleObject; 8401 } 8402 8403 str = str.trim().slice(1, -1);
8403 // browsers re-quote string style values 8404 8405 if (!str) { 8406 return styleObject; 8407 } 8408 8409 styleObject = str.split("&").reduce(function (ret, param) { 8410 var parts = param.replace(/\+/g, " ").split("="); 8411 var key = parts[0]; 8412 var val = parts[1]; 8413 key = decodeURIComponent(key); // missing `=` should be `null`: 8414 // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters 8415 8416 val = val === undefined ? null : decodeURIComponent(val); 8417 8418 if (!ret.hasOwnProperty(key)) { 8419 ret[key] = val; 8420 } else if (Array.isArray(ret[key])) { 8421 ret[key].push(val); 8422 } else { 8423 ret[key] = [ret[key], val]; 8424 } 8425 8426 return ret; 8427 }, {}); 8428 return styleObject; 8429 } 8430 8431 Foundation.MediaQuery = MediaQuery; 8432}(jQuery); 8433 8434/***/ }), 8435 8436/***/ 9642: 8437/***/ ((module, exports, __webpack_require__) => { 8438 8439var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 8440 8441/*! jQuery UI - v1.12.1 - 2019-09-18 8442* http://jqueryui.com 8443* Includes: widget.js, effect.js 8444* Copyright jQuery Foundation and other contributors; Licensed MIT */ 8445(function (t) { 8446 true ? !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(4540)], __WEBPACK_AMD_DEFINE_FACTORY__ = (t), 8447 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 8448 (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), 8449 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : 0; 8450})(function (t) { 8451 t.ui = t.ui || {}, t.ui.version = "1.12.1"; 8452 var e = 0, 8453 i = Array.prototype.slice; 8454 t.cleanData = function (e) { 8455 return function (i) { 8456 var s, n, o; 8457 8458 for (o = 0; null != (n = i[o]); o++) { 8459 try { 8460 s = t._data(n, "events"), s && s.remove && t(n).triggerHandler("remove"); 8461 } catch (a) {} 8462 } 8463 8464 e(i); 8465 }; 8466 }(t.cleanData), t.widget = function (e, i, s) { 8467 var n, 8468 o, 8469 a, 8470 r = {}, 8471 l = e.split(".")[0]; 8472 e = e.split(".")[1]; 8473 var h = l + "-" + e; 8474 return s || (s = i, i = t.Widget), t.isArray(s) && (s = t.extend.apply(null, [{}].concat(s))), t.expr[":"][h.toLowerCase()] = function (e) { 8475 return !!t.data(e, h); 8476 }, t[l] = t[l] || {}
8476, n = t[l][e], o = t[l][e] = function (t, e) { 8477 return this._createWidget ? (arguments.length && this._createWidget(t, e), void 0) : new o(t, e); 8478 }, t.extend(o, n, { 8479 version: s.version, 8480 _proto: t.extend({}, s), 8481 _childConstructors: [] 8482 }), a = new i(), a.options = t.widget.extend({}, a.options), t.each(s, function (e, s) { 8483 return t.isFunction(s) ? (r[e] = function () { 8484 function t() { 8485 return i.prototype[e].apply(this, arguments); 8486 } 8487 8488 function n(t) { 8489 return i.prototype[e].apply(this, t); 8490 } 8491 8492 return function () { 8493 var e, 8494 i = this._super, 8495 o = this._superApply; 8496 return this._super = t, this._superApply = n, e = s.apply(this, arguments), this._super = i, this._superApply = o, e; 8497 }; 8498 }(), void 0) : (r[e] = s, void 0); 8499 }), o.prototype = t.widget.extend(a, { 8500 widgetEventPrefix: n ? a.widgetEventPrefix || e : e 8501 }, r, { 8502 constructor: o, 8503 namespace: l, 8504 widgetName: e, 8505 widgetFullName: h 8506 }), n ? (t.each(n._childConstructors, function (e, i) { 8507 var s = i.prototype; 8508 t.widget(s.namespace + "." + s.widgetName, o, i._proto); 8509 }), delete n._childConstructors) : i._childConstructors.push(o), t.widget.bridge(e, o), o; 8510 }, t.widget.extend = function (e) { 8511 for (var s, n, o = i.call(arguments, 1), a = 0, r = o.length; r > a; a++) { 8512 for (s in o[a]) { 8513 n = o[a][s], o[a].hasOwnProperty(s) && void 0 !== n && (e[s] = t.isPlainObject(n) ? t.isPlainObject(e[s]) ? t.widget.extend({}, e[s], n) : t.widget.extend({}, n) : n); 8514 } 8515 } 8516 8517 return e; 8518 }, t.widget.bridge = function (e, s) { 8519 var n = s.prototype.widgetFullName || e; 8520 8521 t.fn[e] = function (o) { 8522 var a = "string" == typeof o, 8523 r = i.call(arguments, 1), 8524 l = this; 8525 return a ? this.length || "instance" !== o ? this.each(function () { 8526 var i, 8527 s = t.data(this, n); 8528 return "instance" === o ? (l = s, !1) : s ? t.isFunction(s[o]) && "_" !== o.charAt(0) ? (i = s[o].apply(s, r), i !== s && void 0 !== i ? (l = i && i.jquery ? l.pushStack(i.get()) : i, !1) : void 0) : t.error("no such method '" + o + "' for " + e + " widget instance") : t.error("cannot call methods on " + e + " prior to initialization; " + "attempted to call method '" + o + "'"); 8529 }) : l = void 0 : (r.length && (o = t.widget.extend.apply(null, [o].concat(r))), this.each(function () { 8530 var e = t.data(this, n); 8531 e ? (e.option(o || {}), e._init && e._init()) : t.data(this, n, new s(o, this)); 8532 })), l; 8533 }; 8534 }, t.Widget = function () {}, t.Widget._childConstructors = [], t.Widget.prototype = { 8535 widgetName: "widget", 8536 widgetEventPrefix: "", 8537 defaultElement: "<div>", 8538 options: { 8539 classes: {}, 8540 disabled: !1, 8541 create: null 8542 }, 8543 _createWidget: function _createWidget(i, s) { 8544 s = t(s || this.defaultElement || this)[0], this.element = t(s), this.uuid = e++, this.eventNamespace = "." + this.widgetName + this.uuid, this.bindings = t(), this.hoverable = t(), this.focusable = t(), this.classesElementLookup = {}, s !== this && (t.data(s, this.widgetFullName, this), this._on(!0, this.element, { 8545 remove: function remove(t) { 8546 t.target === s && this.destroy(); 8547 } 8548 }), this.document = t(s.style ? s.ownerDocument : s.document || s), this.window = t(this.document[0].defaultView || this.document[0].parentWindow)), this.options = t.widget.extend({}, this.options, this._getCreateOptions(), i), this._create(), this.options.disabled && this._setOptionDisabled(this.options.disabled), this._trigger("create", null, this._getCreateEventData()), this._init(); 8549 }, 8550 _getCreateOptions: function _getCreateOptions() { 8551 return {}; 8552 }, 8553 _getCreateEventData: t.noop, 8554 _create: t.noop, 8555 _init: t.noop, 8556 destroy: function destroy() { 8557 var e = this; 8558 this._destroy(), t.each(this.classesElementLookup, function (t, i) { 8559 e._removeClass(i, t); 8560 }), this.element.off(this.eventNamespace).removeData(this.widgetFullName), this.widget().off(this.eventNamespace).removeAttr("aria-disabled"), this.bindings.off(this.eventNamespace); 8561 }, 8562 _destroy: t.noop, 8563 widget: function widget() { 8564 return this.element; 8565 }, 8566 option: function option(e, i) { 8567 var s, 8568 n, 8569 o, 8570 a = e; 8571 if (0 === arguments.length) return t.widget.extend({}, this.options); 8572 if ("string" == typeof e) if (a = {}, s = e.split("."), e = s.shift(), s.length) {
8573 for (n = a[e] = t.widget.extend({}, this.options[e]), o = 0; s.length - 1 > o; o++) { 8574 n[s[o]] = n[s[o]] || {}, n = n[s[o]]; 8575 } 8576 8577 if (e = s.pop(), 1 === arguments.length) return void 0 === n[e] ? null : n[e]; 8578 n[e] = i; 8579 } else { 8580 if (1 === arguments.length) return void 0 === this.options[e] ? null : this.options[e]; 8581 a[e] = i; 8582 } 8583 return this._setOptions(a), this; 8584 }, 8585 _setOptions: function _setOptions(t) { 8586 var e; 8587 8588 for (e in t) { 8589 this._setOption(e, t[e]); 8590 } 8591 8592 return this; 8593 }, 8594 _setOption: function _setOption(t, e) { 8595 return "classes" === t && this._setOptionClasses(e), this.options[t] = e, "disabled" === t && this._setOptionDisabled(e), this; 8596 }, 8597 _setOptionClasses: function _setOptionClasses(e) { 8598 var i, s, n; 8599 8600 for (i in e) { 8601 n = this.classesElementLookup[i], e[i] !== this.options.classes[i] && n && n.length && (s = t(n.get()), this._removeClass(n, i), s.addClass(this._classes({ 8602 element: s, 8603 keys: i, 8604 classes: e, 8605 add: !0 8606 }))); 8607 } 8608 }, 8609 _setOptionDisabled: function _setOptionDisabled(t) { 8610 this._toggleClass(this.widget(), this.widgetFullName + "-disabled", null, !!t), t && (this._removeClass(this.hoverable, null, "ui-state-hover"), this._removeClass(this.focusable, null, "ui-state-focus")); 8611 }, 8612 enable: function enable() { 8613 return this._setOptions({ 8614 disabled: !1 8615 }); 8616 }, 8617 disable: function disable() { 8618 return this._setOptions({ 8619 disabled: !0 8620 }); 8621 }, 8622 _classes: function _classes(e) { 8623 function i(i, o) { 8624 var a, r; 8625 8626 for (r = 0; i.length > r; r++) { 8627 a = n.classesElementLookup[i[r]] || t(), a = e.add ? t(t.unique(a.get().concat(e.element.get()))) : t(a.not(e.element).get()), n.classesElementLookup[i[r]] = a, s.push(i[r]), o && e.classes[i[r]] && s.push(e.classes[i[r]]); 8628 } 8629 } 8630 8631 var s = [], 8632 n = this; 8633 return e = t.extend({ 8634 element: this.element, 8635 classes: this.options.classes || {} 8636 }, e), this._on(e.element, { 8637 remove: "_untrackClassesElement" 8638 }), e.keys && i(e.keys.match(/\S+/g) || [], !0), e.extra && i(e.extra.match(/\S+/g) || []), s.join(" "); 8639 }, 8640 _untrackClassesElement: function _untrackClassesElement(e) { 8641 var i = this; 8642 t.each(i.classesElementLookup, function (s, n) { 8643 -1 !== t.inArray(e.target, n) && (i.classesElementLookup[s] = t(n.not(e.target).get())); 8644 }); 8645 }, 8646 _removeClass: function _removeClass(t, e, i) { 8647 return this._toggleClass(t, e, i, !1); 8648 }, 8649 _addClass: function _addClass(t, e, i) { 8650 return this._toggleClass(t, e, i, !0); 8651 }, 8652 _toggleClass: function _toggleClass(t, e, i, s) { 8653 s = "boolean" == typeof s ? s : i; 8654 var n = "string" == typeof t || null === t, 8655 o = { 8656 extra: n ? e : i, 8657 keys: n ? t : e, 8658 element: n ? this.element : t, 8659 add: s 8660 }; 8661 return o.element.toggleClass(this._classes(o), s), this; 8662 }, 8663 _on: function _on(e, i, s) { 8664 var n, 8665 o = this; 8666 "boolean" != typeof e && (s = i, i = e, e = !1), s ? (i = n = t(i), this.bindings = this.bindings.add(i)) : (s = i, i = this.element, n = this.widget()), t.each(s, function (s, a) { 8667 function r() { 8668 return e || o.options.disabled !== !0 && !t(this).hasClass("ui-state-disabled") ? ("string" == typeof a ? o[a] : a).apply(o, arguments) : void 0; 8669 } 8670 8671 "string" != typeof a && (r.guid = a.guid = a.guid || r.guid || t.guid++); 8672 var l = s.match(/^([\w:-]*)\s*(.*)$/), 8673 h = l[1] + o.eventNamespace, 8674 u = l[2]; 8675 u ? n.on(h, u, r) : i.on(h, r); 8676 }); 8677 }, 8678 _off: function _off(e, i) { 8679 i = (i || "").split(" ").join(this.eventNamespace + " ") + this.eventNamespace, e.off(i).off(i), this.bindings = t(this.bindings.not(e).get()), this.focusable = t(this.focusable.not(e).get()), this.hoverable = t(this.hoverable.not(e).get()); 8680 }, 8681 _delay: function _delay(t, e) { 8682 function i() { 8683 return ("string" == typeof t ? s[t] : t).apply(s, arguments); 8684 } 8685 8686 var s = this; 8687 return setTimeout(i, e || 0); 8688 }, 8689 _hoverable: function _hoverable(e) { 8690 this.hoverable = this.hoverable.add(e), this._on(e, { 8691 mouseenter: function mouseenter(e) { 8692 this._addClass(t(e.currentTarget), null, "ui-state-hover"); 8693 }, 8694 mouseleave: function mouseleave(e) { 8695 this._removeClass(t(e.currentTarget), null, "ui-state-hover"); 8696 } 8697 }); 8698 }, 8699 _focusable: function _focusable(e) { 8700 this.focusable = this.focusable.add(e), this._on(e, { 8701 focusin: function focusin(e) { 8702 this._addClass(t(e.currentTarget), null, "ui-state-focus"); 8703 }, 8704 focusout: function focusout(e) { 8705 this._removeClass(t(e.currentTarget), null, "ui-state-focus"); 8706 } 8707 }); 8708 }, 8709 _trigger: function _trigger(e, i, s) { 8710 var n, 8711 o, 8712 a = this.options[e]; 8713 if (s = s || {}, i = t.Event(i), i.type = (e === this.widgetEventPrefix ? e : this.widgetEventPrefix + e).toLowerCase(), i.target = this.element[0], o = i.originalEvent) for (n in o) { 8714 n in i || (i[n] = o[n]); 8715 } 8716 return this.element.trigger(i, s), !(t.isFunction(a) && a.apply(this.element[0], [i].concat(s)) === !1 || i.isDefaultPrevented()); 8717 } 8718 }, t.each({ 8719 show: "fadeIn", 8720 hide: "fadeOut" 8721 }, function (e, i) { 8722 t.Widget.prototype["_" + e] = function (s, n, o) { 8723 "string" == typeof n && (n = { 8724 effect: n 8725 }); 8726 var a, 8727 r = n ? n === !0 || "number" == typeof n ? i : n.effect || i : e; 8728 n = n || {}, "number" == typeof n && (n = { 8729 duration: n 8730 }), a = !t.isEmptyObject(n), n.complete = o, n.delay && s.delay(n.delay), a && t.effects && t.effects.effect[r] ? s[e](n) : r !== e && s[r] ? s[r](n.duration, n.easing, o) : s.queue(function (i) { 8731 t(this)[e](), o && o.call(s[0]), i(); 8732 }); 8733 }; 8734 }), t.widget; 8735 var s = "ui-effects-", 8736 n = "ui-effects-style", 8737 o = "ui-effects-animated", 8738 a = t; 8739 t.effects = { 8740 effect: {} 8741 }, function (t, e) { 8742 function i(t, e, i) { 8743 var s = c[e.type] || {}; 8744 return null == t ? i || !e.def ? null : e.def : (t = s.floor ? ~~t : parseFloat(t), isNaN(t) ? e.def : s.mod ? (t + s.mod) % s.mod : 0 > t ? 0 : t > s.max ? s.max : t); 8745 } 8746 8747 function s(i) { 8748 var s = h(), 8749 n = s._rgba = []; 8750 return i = i.toLowerCase(), f(l, function (t, o) { 8751 var a, 8752 r = o.re.exec(i), 8753 l = r && o.parse(r), 8754 h = o.space || "rgba"; 8755 return l ? (a = s[h](l), s[u[h].cache] = a[u[h].cache], n = s._rgba = a._rgba, !1) : e; 8756 }), n.length ? ("0,0,0,0" === n.join() && t.extend(n, o.transparent), s) : o[i]; 8757 } 8758 8759 function n(t, e, i) { 8760 return i = (i + 1) % 1, 1 > 6 * i ? t + 6 * (e - t) * i : 1 > 2 * i ? e : 2 > 3 * i ? t + 6 * (e - t) * (2 / 3 - i) : t; 8761 } 8762 8763 var o, 8764 a = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor", 8765 r = /^([\-+])=\s*(\d+\.?\d*)/, 8766 l = [{ 8767 re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/, 8768 parse: function parse(t) { 8769 return [t[1], t[2], t[3], t[4]]; 8770 } 8771 }, {
8772 re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/, 8773 parse: function parse(t) { 8774 return [2.55 * t[1], 2.55 * t[2], 2.55 * t[3], t[4]]; 8775 } 8776 }, { 8777 re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/, 8778 parse: function parse(t) { 8779 return [parseInt(t[1], 16), parseInt(t[2], 16), parseInt(t[3], 16)]; 8780 } 8781 }, { 8782 re: /#([a-f0-9])([a-f0-9])([a-f0-9])/, 8783 parse: function parse(t) { 8784 return [parseInt(t[1] + t[1], 16), parseInt(t[2] + t[2], 16), parseInt(t[3] + t[3], 16)]; 8785 } 8786 }, { 8787 re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/, 8788 space: "hsla", 8789 parse: function parse(t) { 8790 return [t[1], t[2] / 100, t[3] / 100, t[4]]; 8791 } 8792 }], 8793 h = t.Color = function (e, i, s, n) { 8794 return new t.Color.fn.parse(e, i, s, n); 8795 }, 8796 u = { 8797 rgba: { 8798 props: { 8799 red: { 8800 idx: 0, 8801 type: "byte" 8802 }, 8803 green: { 8804 idx: 1, 8805 type: "byte" 8806 }, 8807 blue: { 8808 idx: 2, 8809 type: "byte" 8810 } 8811 } 8812 }, 8813 hsla: { 8814 props: { 8815 hue: { 8816 idx: 0, 8817 type: "degrees" 8818 }, 8819 saturation: { 8820 idx: 1, 8821 type: "percent" 8822 }, 8823 lightness: { 8824 idx: 2, 8825 type: "percent" 8826 } 8827 } 8828 } 8829 }, 8830 c = { 8831 "byte": { 8832 floor: !0, 8833 max: 255 8834 }, 8835 percent: { 8836 max: 1 8837 }, 8838 degrees: { 8839 mod: 360, 8840 floor: !0 8841 } 8842 }, 8843 d = h.support = {}, 8844 p = t("<p>")[0], 8845 f = t.each; 8846 8847 p.style.cssText = "background-color:rgba(1,1,1,.5)", d.rgba = p.style.backgroundColor.indexOf("rgba") > -1, f(u, function (t, e) { 8848 e.cache = "_" + t, e.props.alpha = { 8849 idx: 3, 8850 type: "percent", 8851 def: 1 8852 }; 8853 }), h.fn = t.extend(h.prototype, { 8854 parse: function parse(n, a, r, l) { 8855 if (n === e) return this._rgba = [null, null, null, null], this; 8856 (n.jquery || n.nodeType) && (n = t(n).css(a), a = e); 8857 var c = this, 8858 d = t.type(n), 8859 p = this._rgba = []; 8860 return a !== e && (n = [n, a, r, l], d = "array"), "string" === d ? this.parse(s(n) || o._default) : "array" === d ? (f(u.rgba.props, function (t, e) { 8861 p[e.idx] = i(n[e.idx], e); 8862 }), this) : "object" === d ? (n instanceof h ? f(u, function (t, e) { 8863 n[e.cache] && (c[e.cache] = n[e.cache].slice()); 8864 }) : f(u, function (e, s) { 8865 var o = s.cache; 8866 f(s.props, function (t, e) { 8867 if (!c[o] && s.to) { 8868 if ("alpha" === t || null == n[t]) return; 8869 c[o] = s.to(c._rgba); 8870 } 8871 8872 c[o][e.idx] = i(n[t], e, !0); 8873 }), c[o] && 0 > t.inArray(null, c[o].slice(0, 3)) && (c[o][3] = 1, s.from && (c._rgba = s.from(c[o]))); 8874 }), this) : e; 8875 }, 8876 is: function is(t) { 8877 var i = h(t), 8878 s = !0, 8879 n = this; 8880 return f(u, function (t, o) { 8881 var a, 8882 r = i[o.cache]; 8883 return r && (a = n[o.cache] || o.to && o.to(n._rgba) || [], f(o.props, function (t, i) { 8884 return null != r[i.idx] ? s = r[i.idx] === a[i.idx] : e; 8885 })), s; 8886 }), s; 8887 }, 8888 _space: function _space() { 8889 var t = [], 8890 e = this; 8891 return f(u, function (i, s) { 8892 e[s.cache] && t.push(i); 8893 }), t.pop(); 8894 }, 8895 transition: function transition(t, e) { 8896 var s = h(t), 8897 n = s._space(), 8898 o = u[n], 8899 a = 0 === this.alpha() ? h("transparent") : this, 8900 r = a[o.cache] || o.to(a._rgba), 8901 l = r.slice(); 8902 8903 return s = s[o.cache], f(o.props, function (t, n) { 8904 var o = n.idx, 8905 a = r[o], 8906 h = s[o], 8907 u = c[n.type] || {}; 8908 null !== h && (null === a ? l[o] = h : (u.mod && (h - a > u.mod / 2 ? a += u.mod : a - h > u.mod / 2 && (a -= u.mod)), l[o] = i((h - a) * e + a, n))); 8909 }), this[n](l); 8910 }, 8911 blend: function blend(e) { 8912 if (1 === this._rgba[3]) return this; 8913 8914 var i = this._rgba.slice(), 8915 s = i.pop(), 8916 n = h(e)._rgba; 8917 8918 return h(t.map(i, function (t, e) { 8919 return (1 - s) * n[e] + s * t; 8920 })); 8921 }, 8922 toRgbaString: function toRgbaString() { 8923 var e = "rgba(", 8924 i = t.map(this._rgba, function (t, e) { 8925 return null == t ? e > 2 ? 1 : 0 : t; 8926 }); 8927 return 1 === i[3] && (i.pop(), e = "rgb("), e + i.join() + ")"; 8928 }, 8929 toHslaString: function toHslaString() { 8930 var e = "hsla(", 8931 i = t.map(this.hsla(), function (t, e) { 8932 return null == t && (t = e > 2 ? 1 : 0), e && 3 > e && (t = Math.round(100 * t) + "%"), t; 8933 }); 8934 return 1 === i[3] && (i.pop(), e = "hsl("), e + i.join() + ")"; 8935 }, 8936 toHexString: function toHexString(e) { 8937 var i = this._rgba.slice(), 8938 s = i.pop(); 8939 8940 return e && i.push(~~(255 * s)), "#" + t.map(i, function (t) { 8941 return t = (t || 0).toString(16), 1 === t.length ? "0" + t : t; 8942 }).join(""); 8943 }, 8944 toString: function toString() { 8945 return 0 === this._rgba[3] ? "transparent" : this.toRgbaString(); 8946 } 8947 }), h.fn.parse.prototype = h.fn, u.hsla.to = function (t) { 8948 if (null == t[0] || null == t[1] || null == t[2]) return [null, null, null, t[3]]; 8949 var e, 8950 i,
8951 s = t[0] / 255, 8952 n = t[1] / 255, 8953 o = t[2] / 255, 8954 a = t[3], 8955 r = Math.max(s, n, o), 8956 l = Math.min(s, n, o), 8957 h = r - l, 8958 u = r + l, 8959 c = .5 * u; 8960 return e = l === r ? 0 : s === r ? 60 * (n - o) / h + 360 : n === r ? 60 * (o - s) / h + 120 : 60 * (s - n) / h + 240, i = 0 === h ? 0 : .5 >= c ? h / u : h / (2 - u), [Math.round(e) % 360, i, c, null == a ? 1 : a]; 8961 }, u.hsla.from = function (t) { 8962 if (null == t[0] || null == t[1] || null == t[2]) return [null, null, null, t[3]]; 8963 var e = t[0] / 360, 8964 i = t[1], 8965 s = t[2], 8966 o = t[3], 8967 a = .5 >= s ? s * (1 + i) : s + i - s * i, 8968 r = 2 * s - a; 8969 return [Math.round(255 * n(r, a, e + 1 / 3)), Math.round(255 * n(r, a, e)), Math.round(255 * n(r, a, e - 1 / 3)), o]; 8970 }, f(u, function (s, n) { 8971 var o = n.props, 8972 a = n.cache, 8973 l = n.to, 8974 u = n.from; 8975 h.fn[s] = function (s) { 8976 if (l && !this[a] && (this[a] = l(this._rgba)), s === e) return this[a].slice(); 8977 var n, 8978 r = t.type(s), 8979 c = "array" === r || "object" === r ? s : arguments, 8980 d = this[a].slice(); 8981 return f(o, function (t, e) { 8982 var s = c["object" === r ? t : e.idx]; 8983 null == s && (s = d[e.idx]), d[e.idx] = i(s, e); 8984 }), u ? (n = h(u(d)), n[a] = d, n) : h(d); 8985 }, f(o, function (e, i) { 8986 h.fn[e] || (h.fn[e] = function (n) { 8987 var o, 8988 a = t.type(n), 8989 l = "alpha" === e ? this._hsla ? "hsla" : "rgba" : s, 8990 h = this[l](), 8991 u = h[i.idx]; 8992 return "undefined" === a ? u : ("function" === a && (n = n.call(this, u), a = t.type(n)), null == n && i.empty ? this : ("string" === a && (o = r.exec(n), o && (n = u + parseFloat(o[2]) * ("+" === o[1] ? 1 : -1))), h[i.idx] = n, this[l](h))); 8993 }); 8994 }); 8995 }), h.hook = function (e) { 8996 var i = e.split(" "); 8997 f(i, function (e, i) { 8998 t.cssHooks[i] = { 8999 set: function set(e, n) { 9000 var o, 9001 a, 9002 r = ""; 9003 9004 if ("transparent" !== n && ("string" !== t.type(n) || (o = s(n)))) { 9005 if (n = h(o || n), !d.rgba && 1 !== n._rgba[3]) { 9006 for (a = "backgroundColor" === i ? e.parentNode : e; ("" === r || "transparent" === r) && a && a.style;) { 9007 try { 9008 r = t.css(a, "backgroundColor"), a = a.parentNode; 9009 } catch (l) {} 9010 } 9011 9012 n = n.blend(r && "transparent" !== r ? r : "_default"); 9013 } 9014 9015 n = n.toRgbaString(); 9016 } 9017 9018 try { 9019 e.style[i] = n; 9020 } catch (l) {} 9021 } 9022 }, t.fx.step[i] = function (e) { 9023 e.colorInit || (e.start = h(e.elem, i), e.end = h(e.end), e.colorInit = !0), t.cssHooks[i].set(e.elem, e.start.transition(e.end, e.pos)); 9024 }; 9025 }); 9026 }, h.hook(a), t.cssHooks.borderColor = { 9027 expand: function expand(t) { 9028 var e = {}; 9029 return f(["Top", "Right", "Bottom", "Left"], function (i, s) { 9030 e["border" + s + "Color"] = t; 9031 }), e; 9032 } 9033 }, o = t.Color.names = { 9034 aqua: "#00ffff", 9035 black: "#000000", 9036 blue: "#0000ff", 9037 fuchsia: "#ff00ff", 9038 gray: "#808080", 9039 green: "#008000", 9040 lime: "#00ff00", 9041 maroon: "#800000", 9042 navy: "#000080", 9043 olive: "#808000", 9044 purple: "#800080", 9045 red: "#ff0000", 9046 silver: "#c0c0c0", 9047 teal: "#008080", 9048 white: "#ffffff", 9049 yellow: "#ffff00", 9050 transparent: [null, null, null, 0], 9051 _default: "#ffffff" 9052 }; 9053 }(a), function () { 9054 function e(e) { 9055 var i, 9056 s, 9057 n = e.ownerDocument.defaultView ? e.ownerDocument.defaultView.getComputedStyle(e, null) : e.currentStyle, 9058 o = {}; 9059 if (n && n.length && n[0] && n[n[0]]) for (s = n.length; s--;) { 9060 i = n[s], "string" == typeof n[i] && (o[t.camelCase(i)] = n[i]); 9061 } else for (i in n) { 9062 "string" == typeof n[i] && (o[i] = n[i]); 9063 } 9064 return o; 9065 } 9066 9067 function i(e, i) { 9068 var s, 9069 o, 9070 a = {}; 9071 9072 for (s in i) { 9073 o = i[s], e[s] !== o && (n[s] || (t.fx.step[s] || !isNaN(parseFloat(o))) && (a[s] = o)); 9074 } 9075 9076 return a; 9077 } 9078 9079 var s = ["add", "remove", "toggle"], 9080 n = { 9081 border: 1, 9082 borderBottom: 1, 9083 borderColor: 1, 9084 borderLeft: 1, 9085 borderRight: 1, 9086 borderTop: 1, 9087 borderWidth: 1, 9088 margin: 1, 9089 padding: 1 9090 }; 9091 t.each(["borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle"], function (e, i) { 9092 t.fx.step[i] = function (t) { 9093 ("none" !== t.end && !t.setAttr || 1 === t.pos && !t.setAttr) && (a.style(t.elem, i, t.end), t.setAttr = !0); 9094 }; 9095 }), t.fn.addBack || (t.fn.addBack = function (t) { 9096 return this.add(null == t ? this.prevObject : this.prevObject.filter(t)); 9097 }), t.effects.animateClass = function (n, o, a, r) { 9098 var l = t.speed(o, a, r); 9099 return this.queue(function () { 9100 var o, 9101 a = t(this), 9102 r = a.attr("class") || "", 9103 h = l.children ? a.find("*").addBack() : a; 9104 h = h.map(function () { 9105 var i = t(this); 9106 return { 9107 el: i, 9108 start: e(this) 9109 }; 9110 }), o = function o() { 9111 t.each(s, function (t, e) { 9112 n[e] && a[e + "Class"](n[e]); 9113 }); 9114 }, o(), h = h.map(function () { 9115 return this.end = e(this.el[0]), this.diff = i(this.start, this.end), this; 9116 }), a.attr("class", r), h = h.map(function () { 9117 var e = this, 9118 i = t.Deferred(), 9119 s = t.extend({}, l, { 9120 queue: !1, 9121 complete: function complete() { 9122 i.resolve(e); 9123 } 9124 }); 9125 return this.el.animate(this.diff, s), i.promise(); 9126 }), t.when.apply(t, h.get()).done(function () { 9127 o(), t.each(arguments, function () { 9128 var e = this.el; 9129 t.each(this.diff, function (t) { 9130 e.css(t, ""); 9131 }); 9132 }), l.complete.call(a[0]); 9133 }); 9134 }); 9135 }, t.fn.extend({ 9136 addClass: function (e) { 9137 return function (i, s, n, o) { 9138 return s ? t.effects.animateClass.call(this, { 9139 add: i 9140 }, s, n, o) : e.apply(this, arguments); 9141 }; 9142 }(t.fn.addClass), 9143 removeClass: function (e) { 9144 return function (i, s, n, o) { 9145 return arguments.length > 1 ? t.effects.animateClass.call(this, { 9146 remove: i 9147 }, s, n, o) : e.apply(this, arguments); 9148 }; 9149 }(t.fn.removeClass), 9150 toggleClass: function (e) { 9151 return function (i, s, n, o, a) { 9152 return "boolean" == typeof s || void 0 === s ? n ? t.effects.animateClass.call(this, s ? { 9153 add: i 9154 } : { 9155 remove: i 9156 }, n, o, a) : e.apply(this, arguments) : t.effects.animateClass.call(this, { 9157 toggle: i 9158 }, s, n, o); 9159 }; 9160 }(t.fn.toggleClass), 9161 switchClass: function switchClass(e, i, s, n, o) { 9162 return t.effects.animateClass.call(this, { 9163 add: i, 9164 remove: e 9165 }, s, n, o); 9166 } 9167 }); 9168 }(), function () { 9169 function e(e, i, s, n) { 9170 return t.isPlainObject(e) && (i = e, e = e.effect), e = { 9171 effect: e 9172 }, null == i && (i = {}), t.isFunction(i) && (n = i, s = null, i = {}), ("number" == typeof i || t.fx.speeds[i]) && (n = s, s = i, i = {}), t.isFunction(s) && (n = s, s = null), i && t.extend(e, i), s = s || i.duration, e.duration = t.fx.off ? 0 : "number" == typeof s ? s : s in t.fx.speeds ? t.fx.speeds[s] : t.fx.speeds._default, e.complete = n || i.complete, e; 9173 } 9174 9175 function i(e) { 9176 return !e || "number" == typeof e || t.fx.speeds[e] ? !0 : "string" != typeof e || t.effects.effect[e] ? t.isFunction(e) ? !0 : "object" != _typeof(e) || e.effect ? !1 : !0 : !0; 9177 } 9178 9179 function a(t, e) { 9180 var i = e.outerWidth(), 9181 s = e.outerHeight(), 9182 n = /^rect\((-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto)\)$/, 9183 o = n.exec(t) || ["", 0, i, s, 0]; 9184 return { 9185 top: parseFloat(o[1]) || 0, 9186 right: "auto" === o[2] ? i : parseFloat(o[2]), 9187 bottom: "auto" === o[3] ? s : parseFloat(o[3]), 9188 left: parseFloat(o[4]) || 0 9189 }; 9190 } 9191 9192 t.expr && t.expr.filters && t.expr.filters.animated && (t.expr.filters.animated = function (e) { 9193 return function (i) { 9194 return !!t(i).data(o) || e(i); 9195 }; 9196 }(t.expr.filters.animated)), t.uiBackCompat !== !1 && t.extend(t.effects, { 9197 save: function save(t, e) { 9198 for (var i = 0, n = e.length; n > i; i++) { 9199 null !== e[i] && t.data(s + e[i], t[0].style[e[i]]); 9200 } 9201 }, 9202 restore: function restore(t, e) { 9203 for (var i, n = 0, o = e.length; o > n; n++) { 9204 null !== e[n] && (i = t.data(s + e[n]), t.css(e[n], i)); 9205 } 9206 }, 9207 setMode: function setMode(t, e) { 9208 return "toggle" === e && (e = t.is(":hidden") ? "show" : "hide"), e; 9209 }, 9210 createWrapper: function createWrapper(e) { 9211 if (e.parent().is(".ui-effects-wrapper")) return e.parent(); 9212 var i = { 9213 width: e.outerWidth(!0), 9214 height: e.outerHeight(!0), 9215 "float": e.css("float") 9216 }, 9217 s = t("<div></div>").addClass("ui-effects-wrapper").css({ 9218 fontSize: "100%", 9219 background: "transparent", 9220 border: "none", 9221 margin: 0, 9222 padding: 0 9223 }), 9224 n = { 9225 width: e.width(), 9226 height: e.height() 9227 }, 9228 o = document.activeElement; 9229 9230 try { 9231 o.id; 9232 } catch (a) { 9233 o = document.body; 9234 } 9235 9236 return e.wrap(s), (e[0] === o || t.contains(e[0], o)) && t(o).trigger("focus"), s = e.parent(), "static" === e.css("position") ? (s.css({ 9237 position: "relative" 9238 }), e.css({ 9239 position: "relative" 9240 })) : (t.extend(i, { 9241 position: e.css("position"), 9242 zIndex: e.css("z-index") 9243 }), t.each(["top", "left", "bottom", "right"], function (t, s) { 9244 i[s] = e.css(s), isNaN(parseInt(i[s], 10)) && (i[s] = "auto"); 9245 }), e.css({ 9246 position: "relative", 9247 top: 0, 9248 left: 0, 9249 right: "auto", 9250 bottom: "auto" 9251 })), e.css(n), s.css(i).show(); 9252 }, 9253 removeWrapper: function removeWrapper(e) { 9254 var i = document.activeElement; 9255 return e.parent().is(".ui-effects-wrapper") && (e.parent().replaceWith(e), (e[0] === i || t.contains(e[0], i)) && t(i).trigger("focus")), e; 9256 } 9257 }), t.extend(t.effects, { 9258 version: "1.12.1", 9259 define: function define(e, i, s) { 9260 return s || (s = i, i = "effect"), t.effects.effect[e] = s, t.effects.effect[e].mode = i, s; 9261 }, 9262 scaledDimensions: function scaledDimensions(t, e, i) { 9263 if (0 === e) return { 9264 height: 0, 9265 width: 0, 9266 outerHeight: 0, 9267 outerWidth: 0 9268 }; 9269 var s = "horizontal" !== i ? (e || 100) / 100 : 1, 9270 n = "vertical" !== i ? (e || 100) / 100 : 1; 9271 return { 9272 height: t.height() * n, 9273 width: t.width() * s, 9274 outerHeight: t.outerHeight() * n, 9275 outerWidth: t.outerWidth() * s 9276 }; 9277 }, 9278 clipToBox: function clipToBox(t) { 9279 return { 9280 width: t.clip.right - t.clip.left, 9281 height: t.clip.bottom - t.clip.top, 9282 left: t.clip.left, 9283 top: t.clip.top 9284 }; 9285 }, 9286 unshift: function unshift(t, e, i) { 9287 var s = t.queue(); 9288 e > 1 && s.splice.apply(s, [1, 0].concat(s.splice(e, i))), t.dequeue(); 9289 }, 9290 saveStyle: function saveStyle(t) { 9291 t.data(n, t[0].style.cssText); 9292 }, 9293 restoreStyle: function restoreStyle(t) { 9294 t[0].style.cssText = t.data(n) || "", t.removeData(n); 9295 }, 9296 mode: function mode(t, e) { 9297 var i = t.is(":hidden"); 9298 return "toggle" === e && (e = i ? "show" : "hide"), (i ? "hide" === e : "show" === e) && (e = "none"), e; 9299 }, 9300 getBaseline: function getBaseline(t, e) { 9301 var i, s; 9302 9303 switch (t[0]) { 9304 case "top": 9305 i = 0; 9306 break; 9307 9308 case "middle": 9309 i = .5; 9310 break; 9311 9312 case "bottom": 9313 i = 1; 9314 break; 9315 9316 default: 9317 i = t[0] / e.height; 9318 } 9319 9320 switch (t[1]) {
9321 case "left": 9322 s = 0; 9323 break; 9324 9325 case "center": 9326 s = .5; 9327 break; 9328 9329 case "right": 9330 s = 1; 9331 break; 9332 9333 default: 9334 s = t[1] / e.width; 9335 } 9336 9337 return { 9338 x: s, 9339 y: i 9340 }; 9341 }, 9342 createPlaceholder: function createPlaceholder(e) { 9343 var i, 9344 n = e.css("position"), 9345 o = e.position(); 9346 return e.css({ 9347 marginTop: e.css("marginTop"), 9348 marginBottom: e.css("marginBottom"), 9349 marginLeft: e.css("marginLeft"), 9350 marginRight: e.css("marginRight") 9351 }).outerWidth(e.outerWidth()).outerHeight(e.outerHeight()), /^(static|relative)/.test(n) && (n = "absolute", i = t("<" + e[0].nodeName + ">").insertAfter(e).css({ 9352 display: /^(inline|ruby)/.test(e.css("display")) ? "inline-block" : "block", 9353 visibility: "hidden", 9354 marginTop: e.css("marginTop"), 9355 marginBottom: e.css("marginBottom"), 9356 marginLeft: e.css("marginLeft"), 9357 marginRight: e.css("marginRight"), 9358 "float": e.css("float") 9359 }).outerWidth(e.outerWidth()).outerHeight(e.outerHeight()).addClass("ui-effects-placeholder"), e.data(s + "placeholder", i)), e.css({ 9360 position: n, 9361 left: o.left, 9362 top: o.top 9363 }), i; 9364 }, 9365 removePlaceholder: function removePlaceholder(t) { 9366 var e = s + "placeholder", 9367 i = t.data(e); 9368 i && (i.remove(), t.removeData(e)); 9369 }, 9370 cleanUp: function cleanUp(e) { 9371 t.effects.restoreStyle(e), t.effects.removePlaceholder(e); 9372 }, 9373 setTransition: function setTransition(e, i, s, n) { 9374 return n = n || {}, t.each(i, function (t, i) { 9375 var o = e.cssUnit(i); 9376 o[0] > 0 && (n[i] = o[0] * s + o[1]); 9377 }), n; 9378 } 9379 }), t.fn.extend({ 9380 effect: function effect() { 9381 function i(e) { 9382 function i() { 9383 l.removeData(o), t.effects.cleanUp(l), "hide" === s.mode && l.hide(), r(); 9384 } 9385 9386 function r() { 9387 t.isFunction(h) && h.call(l[0]), t.isFunction(e) && e(); 9388 } 9389 9390 var l = t(this); 9391 s.mode = c.shift(), t.uiBackCompat === !1 || a ? "none" === s.mode ? (l[u](), r()) : n.call(l[0], s, i) : (l.is(":hidden") ? "hide" === u : "show" === u) ? (l[u](), r()) : n.call(l[0], s, r); 9392 } 9393 9394 var s = e.apply(this, arguments), 9395 n = t.effects.effect[s.effect], 9396 a = n.mode, 9397 r = s.queue, 9398 l = r || "fx", 9399 h = s.complete, 9400 u = s.mode, 9401 c = [], 9402 d = function d(e) { 9403 var i = t(this), 9404 s = t.effects.mode(i, u) || a; 9405 i.data(o, !0), c.push(s), a && ("show" === s || s === a && "hide" === s) && i.show(), a && "none" === s || t.effects.saveStyle(i), t.isFunction(e) && e(); 9406 }; 9407 9408 return t.fx.off || !n ? u ? this[u](s.duration, h) : this.each(function () { 9409 h && h.call(this); 9410 }) : r === !1 ? this.each(d).each(i) : this.queue(l, d).queue(l, i); 9411 }, 9412 show: function (t) { 9413 return function (s) { 9414 if (i(s)) return t.apply(this, arguments); 9415 var n = e.apply(this, arguments); 9416 return n.mode = "show", this.effect.call(this, n); 9417 }; 9418 }(t.fn.show), 9419 hide: function (t) { 9420 return function (s) { 9421 if (i(s)) return t.apply(this, arguments); 9422 var n = e.apply(this, arguments); 9423 return n.mode = "hide", this.effect.call(this, n); 9424 }; 9425 }(t.fn.hide), 9426 toggle: function (t) { 9427 return function (s) { 9428 if (i(s) || "boolean" == typeof s) return t.apply(this, arguments); 9429 var n = e.apply(this, arguments); 9430 return n.mode = "toggle", this.effect.call(this, n); 9431 }; 9432 }(t.fn.toggle), 9433 cssUnit: function cssUnit(e) { 9434 var i = this.css(e), 9435 s = []; 9436 return t.each(["em", "px", "%", "pt"], function (t, e) { 9437 i.indexOf(e) > 0 && (s = [parseFloat(i), e]); 9438 }), s; 9439 }, 9440 cssClip: function cssClip(t) { 9441 return t ? this.css("clip", "rect(" + t.top + "px " + t.right + "px " + t.bottom + "px " + t.left + "px)") : a(this.css("clip"), this); 9442 }, 9443 transfer: function transfer(e, i) { 9444 var s = t(this), 9445 n = t(e.to), 9446 o = "fixed" === n.css("position"), 9447 a = t("body"), 9448 r = o ? a.scrollTop() : 0, 9449 l = o ? a.scrollLeft() : 0, 9450 h = n.offset(), 9451 u = { 9452 top: h.top - r, 9453 left: h.left - l, 9454 height: n.innerHeight(), 9455 width: n.innerWidth() 9456 }, 9457 c = s.offset(), 9458 d = t("<div class='ui-effects-transfer'></div>").appendTo("body").addClass(e.className).css({ 9459 top: c.top - r, 9460 left: c.left - l, 9461 height: s.innerHeight(), 9462 width: s.innerWidth(), 9463 position: o ? "fixed" : "absolute" 9464 }).animate(u, e.duration, e.easing, function () { 9465 d.remove(), t.isFunction(i) && i(); 9466 }); 9467 } 9468 }), t.fx.step.clip = function (e) { 9469 e.clipInit || (e.start = t(e.elem).cssClip(), "string" == typeof e.end && (e.end = a(e.end, e.elem)), e.clipInit = !0), t(e.elem).cssClip({ 9470 top: e.pos * (e.end.top - e.start.top) + e.start.top, 9471 right: e.pos * (e.end.right - e.start.right) + e.start.right, 9472 bottom: e.pos * (e.end.bottom - e.start.bottom) + e.start.bottom, 9473 left: e.pos * (e.end.left - e.start.left) + e.start.left 9474 }); 9475 }; 9476 }(), function () { 9477 var e = {}; 9478 t.each(["Quad", "Cubic", "Quart", "Quint", "Expo"], function (t, i) { 9479 e[i] = function (e) { 9480 return Math.pow(e, t + 2); 9481 }; 9482 }), t.extend(e, { 9483 Sine: function Sine(t) { 9484 return 1 - Math.cos(t * Math.PI / 2); 9485 }, 9486 Circ: function Circ(t) { 9487 return 1 - Math.sqrt(1 - t * t); 9488 }, 9489 Elastic: function Elastic(t) { 9490 return 0 === t || 1 === t ? t : -Math.pow(2, 8 * (t - 1)) * Math.sin((80 * (t - 1)
9490- 7.5) * Math.PI / 15); 9491 }, 9492 Back: function Back(t) { 9493 return t * t * (3 * t - 2); 9494 }, 9495 Bounce: function Bounce(t) { 9496 for (var e, i = 4; ((e = Math.pow(2, --i)) - 1) / 11 > t;) { 9497 ; 9498 } 9499 9500 return 1 / Math.pow(4, 3 - i) - 7.5625 * Math.pow((3 * e - 2) / 22 - t, 2); 9501 } 9502 }), t.each(e, function (e, i) { 9503 t.easing["easeIn" + e] = i, t.easing["easeOut" + e] = function (t) { 9504 return 1 - i(1 - t); 9505 }, t.easing["easeInOut" + e] = function (t) { 9506 return .5 > t ? i(2 * t) / 2 : 1 - i(-2 * t + 2) / 2; 9507 }; 9508 }); 9509 }(), t.effects; 9510}); 9511 9512/***/ }), 9513 9514/***/ 3523: 9515/***/ ((module, exports, __webpack_require__) => { 9516 9517var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 9518 9519/** 9520 * jquery.mask.js 9521 * @version: v1.14.16 9522 * @author: Igor Escobar 9523 * 9524 * Created by Igor Escobar on 2012-03-10. Please report any bug at github.com/igorescobar/jQuery-Mask-Plugin 9525 * 9526 * Copyright (c) 2012 Igor Escobar http://igorescobar.com 9527 * 9528 * The MIT License (http://www.opensource.org/licenses/mit-license.php) 9529 * 9530 * Permission is hereby granted, free of charge, to any person 9531 * obtaining a copy of this software and associated documentation 9532 * files (the "Software"), to deal in the Software without 9533 * restriction, including without limitation the rights to use, 9534 * copy, modify, merge, publish, distribute, sublicense, and/or sell 9535 * copies of the Software, and to permit persons to whom the 9536 * Software is furnished to do so, subject to the following 9537 * conditions: 9538 * 9539 * The above copyright notice and this permission notice shall be 9540 * included in all copies or substantial portions of the Software. 9541 * 9542 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 9543 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 9544 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 9545 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 9546 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 9547 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 9548 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 9549 * OTHER DEALINGS IN THE SOFTWARE. 9550 */ 9551 9552/* jshint laxbreak: true */ 9553 9554/* jshint maxcomplexity:17 */ 9555 9556/* global define */ 9557// UMD (Universal Module Definition) patterns for JavaScript modules that work everywhere. 9558// https://github.com/umdjs/umd/blob/master/templates/jqueryPlugin.js 9559(function (factory, jQuery, Zepto) { 9560 if (true) { 9561 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(4540)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 9562 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 9563 (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), 9564 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 9565 } else {} 9566})(function ($) { 9567 "use strict"; 9568 9569 var Mask = function Mask(el, mask, options) { 9570 var p = { 9571 invalid: [], 9572 getCaret: function getCaret() { 9573 try { 9574 var sel, 9575 pos = 0, 9576 ctrl = el.get(0), 9577 dSel = document.selection, 9578 cSelStart = ctrl.selectionStart; // IE Support 9579 9580 if (dSel && navigator.appVersion.indexOf("MSIE 10") === -1) { 9581 sel = dSel.createRange(); 9582 sel.moveStart("character", -p.val().length); 9583 pos = sel.text.length; 9584 } // Firefox support 9585 else if (cSelStart || cSelStart === "0") { 9586 pos = cSelStart; 9587 } 9588 9589 return pos; 9590 } catch (e) {} 9591 }, 9592 setCaret: function setCaret(pos) { 9593 try { 9594 if (el.is(":focus")) { 9595 var range, 9596 ctrl = el.get(0); // Firefox, WebKit, etc.. 9597 9598 if (ctrl.setSelectionRange) { 9599 ctrl.setSelectionRange(pos, pos); 9600 } else { 9601 // IE 9602 range = ctrl.createTextRange(); 9603 range.collapse(true); 9604 range.moveEnd("character", pos); 9605 range.moveStart("character", pos); 9606 range.select(); 9607 } 9608 } 9609 } catch (e) {} 9610 }, 9611 events: function events() {
vendor: 11,142 bytes, lines 9612-9959
9612 el.on("keydown.mask", function (e) { 9613 el.data("mask-keycode", e.keyCode || e.which); 9614 el.data("mask-previus-value", el.val()); 9615 el.data("mask-previus-caret-pos", p.getCaret()); 9616 p.maskDigitPosMapOld = p.maskDigitPosMap; 9617 }).on($.jMaskGlobals.useInput ? "input.mask" : "keyup.mask", p.behaviour).on("paste.mask drop.mask", function () { 9618 setTimeout(function () { 9619 el.keydown().keyup(); 9620 }, 100); 9621 }).on("change.mask", function () { 9622 el.data("changed", true); 9623 }).on("blur.mask", function () { 9624 if (oldValue !== p.val() && !el.data("changed")) { 9625 el.trigger("change"); 9626 } 9627 9628 el.data("changed", false); 9629 }) // it's very important that this callback remains in this position 9630 // otherwhise oldValue it's going to work buggy 9631 .on("blur.mask", function () { 9632 oldValue = p.val(); 9633 }) // select all text on focus 9634 .on("focus.mask", function (e) { 9635 if (options.selectOnFocus === true) { 9636 $(e.target).select(); 9637 } 9638 }) // clear the value if it not complete the mask 9639 .on("focusout.mask", function () { 9640 if (options.clearIfNotMatch && !regexMask.test(p.val())) { 9641 p.val(""); 9642 } 9643 }); 9644 }, 9645 getRegexMask: function getRegexMask() { 9646 var maskChunks = [], 9647 translation, 9648 pattern, 9649 optional, 9650 recursive, 9651 oRecursive, 9652 r; 9653 9654 for (var i = 0; i < mask.length; i++) { 9655 translation = jMask.translation[mask.charAt(i)]; 9656 9657 if (translation) { 9658 pattern = translation.pattern.toString().replace(/.{1}$|^.{1}/g, ""); 9659 optional = translation.optional; 9660 recursive = translation.recursive; 9661 9662 if (recursive) { 9663 maskChunks.push(mask.charAt(i)); 9664 oRecursive = { 9665 digit: mask.charAt(i), 9666 pattern: pattern 9667 }; 9668 } else { 9669 maskChunks.push(!optional && !recursive ? pattern : pattern + "?"); 9670 } 9671 } else { 9672 maskChunks.push(mask.charAt(i).replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")); 9673 } 9674 } 9675 9676 r = maskChunks.join(""); 9677 9678 if (oRecursive) { 9679 r = r.replace(new RegExp("(" + oRecursive.digit + "(.*" + oRecursive.digit + ")?)"), "($1)?").replace(new RegExp(oRecursive.digit, "g"), oRecursive.pattern); 9680 } 9681 9682 return new RegExp(r); 9683 }, 9684 destroyEvents: function destroyEvents() { 9685 el.off(["input", "keydown", "keyup", "paste", "drop", "blur", "focusout", ""].join(".mask ")); 9686 }, 9687 val: function val(v) { 9688 var isInput = el.is("input"), 9689 method = isInput ? "val" : "text", 9690 r; 9691 9692 if (arguments.length > 0) { 9693 if (el[method]() !== v) { 9694 el[method](v); 9695 } 9696 9697 r = el; 9698 } else { 9699 r = el[method](); 9700 } 9701 9702 return r; 9703 }, 9704 calculateCaretPosition: function calculateCaretPosition(oldVal) { 9705 var newVal = p.getMasked(), 9706 caretPosNew = p.getCaret(); 9707 9708 if (oldVal !== newVal) { 9709 var caretPosOld = el.data("mask-previus-caret-pos") || 0, 9710 newValL = newVal.length, 9711 oldValL = oldVal.length, 9712 maskDigitsBeforeCaret = 0, 9713 maskDigitsAfterCaret = 0, 9714 maskDigitsBeforeCaretAll = 0, 9715 maskDigitsBeforeCaretAllOld = 0, 9716 i = 0; 9717 9718 for (i = caretPosNew; i < newValL; i++) { 9719 if (!p.maskDigitPosMap[i]) { 9720 break; 9721 } 9722 9723 maskDigitsAfterCaret++; 9724 } 9725 9726 for (i = caretPosNew - 1; i >= 0; i--) { 9727 if (!p.maskDigitPosMap[i]) { 9728 break; 9729 } 9730 9731 maskDigitsBeforeCaret++; 9732 } 9733 9734 for (i = caretPosNew - 1; i >= 0; i--) { 9735 if (p.maskDigitPosMap[i]) { 9736 maskDigitsBeforeCaretAll++; 9737 } 9738 } 9739 9740 for (i = caretPosOld - 1; i >= 0; i--) { 9741 if (p.maskDigitPosMapOld[i]) { 9742 maskDigitsBeforeCaretAllOld++; 9743 } 9744 } // if the cursor is at the end keep it there 9745 9746 9747 if (caretPosNew > oldValL) { 9748 caretPosNew = newValL * 10; 9749 } else if (caretPosOld >= caretPosNew && caretPosOld !== oldValL) { 9750 if (!p.maskDigitPosMapOld[caretPosNew]) { 9751 var caretPos = caretPosNew; 9752 caretPosNew -= maskDigitsBeforeCaretAllOld - maskDigitsBeforeCaretAll; 9753 caretPosNew -= maskDigitsBeforeCaret; 9754 9755 if (p.maskDigitPosMap[caretPosNew]) { 9756 caretPosNew = caretPos; 9757 } 9758 } 9759 } else if (caretPosNew > caretPosOld) { 9760 caretPosNew += maskDigitsBeforeCaretAll - maskDigitsBeforeCaretAllOld; 9761 caretPosNew += maskDigitsAfterCaret; 9762 } 9763 } 9764 9765 return caretPosNew; 9766 }, 9767 behaviour: function behaviour(e) { 9768 e = e || window.event; 9769 p.invalid = []; 9770 var keyCode = el.data("mask-keycode"); 9771 9772 if ($.inArray(keyCode, jMask.byPassKeys) === -1) { 9773 var newVal = p.getMasked(), 9774 caretPos = p.getCaret(), 9775 oldVal = el.data("mask-previus-value") || ""; // this is a compensation to devices/browsers that don't compensate 9776 // caret positioning the right way 9777 9778 setTimeout(function () { 9779 p.setCaret(p.calculateCaretPosition(oldVal)); 9780 }, $.jMaskGlobals.keyStrokeCompensation); 9781 p.val(newVal); 9782 p.setCaret(caretPos); 9783 return p.callbacks(e); 9784 } 9785 }, 9786 getMasked: function getMasked(skipMaskChars, val) { 9787 var buf = [], 9788 value = val === undefined ? p.val() : val + "", 9789 m = 0, 9790 maskLen = mask.length, 9791 v = 0, 9792 valLen = value.length, 9793 offset = 1, 9794 addMethod = "push", 9795 resetPos = -1, 9796 maskDigitCount = 0, 9797 maskDigitPosArr = [], 9798 lastMaskChar, 9799 check; 9800 9801 if (options.reverse) { 9802 addMethod = "unshift"; 9803 offset = -1; 9804 lastMaskChar = 0; 9805 m = maskLen - 1; 9806 v = valLen - 1; 9807 9808 check = function check() { 9809 return m > -1 && v > -1; 9810 }; 9811 } else { 9812 lastMaskChar = maskLen - 1; 9813 9814 check = function check() { 9815 return m < maskLen && v < valLen; 9816 }; 9817 } 9818 9819 var lastUntranslatedMaskChar; 9820 9821 while (check()) { 9822 var maskDigit = mask.charAt(m), 9823 valDigit = value.charAt(v), 9824 translation = jMask.translation[maskDigit]; 9825 9826 if (translation) { 9827 if (valDigit.match(translation.pattern)) { 9828 buf[addMethod](valDigit); 9829 9830 if (translation.recursive) { 9831 if (resetPos === -1) { 9832 resetPos = m; 9833 } else if (m === lastMaskChar && m !== resetPos) { 9834 m = resetPos - offset; 9835 } 9836 9837 if (lastMaskChar === resetPos) { 9838 m -= offset; 9839 } 9840 } 9841 9842 m += offset; 9843 } else if (valDigit === lastUntranslatedMaskChar) { 9844 // matched the last untranslated (raw) mask character that we encountered 9845 // likely an insert offset the mask character from the last entry; fall 9846 // through and only increment v 9847 maskDigitCount--; 9848 lastUntranslatedMaskChar = undefined; 9849 } else if (translation.optional) { 9850 m += offset; 9851 v -= offset; 9852 } else if (translation.fallback) { 9853 buf[addMethod](translation.fallback); 9854 m += offset; 9855 v -= offset; 9856 } else { 9857 p.invalid.push({ 9858 p: v, 9859 v: valDigit, 9860 e: translation.pattern 9861 }); 9862 } 9863 9864 v += offset; 9865 } else { 9866 if (!skipMaskChars) { 9867 buf[addMethod](maskDigit); 9868 } 9869 9870 if (valDigit === maskDigit) { 9871 maskDigitPosArr.push(v); 9872 v += offset; 9873 } else { 9874 lastUntranslatedMaskChar = maskDigit; 9875 maskDigitPosArr.push(v + maskDigitCount); 9876 maskDigitCount++; 9877 } 9878 9879 m += offset; 9880 } 9881 } 9882 9883 var lastMaskCharDigit = mask.charAt(lastMaskChar); 9884 9885 if (maskLen === valLen + 1 && !jMask.translation[lastMaskCharDigit]) { 9886 buf.push(lastMaskCharDigit); 9887 } 9888 9889 var newVal = buf.join(""); 9890 p.mapMaskdigitPositions(newVal, maskDigitPosArr, valLen); 9891 return newVal; 9892 }, 9893 mapMaskdigitPositions: function mapMaskdigitPositions(newVal, maskDigitPosArr, valLen) { 9894 var maskDiff = options.reverse ? newVal.length - valLen : 0; 9895 p.maskDigitPosMap = {}; 9896 9897 for (var i = 0; i < maskDigitPosArr.length; i++) { 9898 p.maskDigitPosMap[maskDigitPosArr[i] + maskDiff] = 1; 9899 } 9900 }, 9901 callbacks: function callbacks(e) { 9902 var val = p.val(), 9903 changed = val !== oldValue, 9904 defaultArgs = [val, e, el, options], 9905 callback = function callback(name, criteria, args) { 9906 if (typeof options[name] === "function" && criteria) { 9907 options[name].apply(this, args); 9908 } 9909 }; 9910 9911 callback("onChange", changed === true, defaultArgs); 9912 callback("onKeyPress", changed === true, defaultArgs); 9913 callback("onComplete", val.length === mask.length, defaultArgs); 9914 callback("onInvalid", p.invalid.length > 0, [val, e, el, p.invalid, options]); 9915 } 9916 }; 9917 el = $(el); 9918 var jMask = this, 9919 oldValue = p.val(), 9920 regexMask; 9921 mask = typeof mask === "function" ? mask(p.val(), undefined, el, options) : mask; // public methods 9922 9923 jMask.mask = mask; 9924 jMask.options = options; 9925 9926 jMask.remove = function () { 9927 var caret = p.getCaret(); 9928 9929 if (jMask.options.placeholder) { 9930 el.removeAttr("placeholder"); 9931 } 9932 9933 if (el.data("mask-maxlength")) { 9934 el.removeAttr("maxlength"); 9935 } 9936 9937 p.destroyEvents(); 9938 p.val(jMask.getCleanVal()); 9939 p.setCaret(caret); 9940 return el; 9941 }; // get value without mask 9942 9943 9944 jMask.getCleanVal = function () { 9945 return p.getMasked(true); 9946 }; // get masked value without the value being in the input or element 9947 9948 9949 jMask.getMaskedVal = function (val) { 9950 return p.getMasked(false, val); 9951 }; 9952 9953 jMask.init = function (onlyMask) { 9954 onlyMask = onlyMask || false; 9955 options = options || {}; 9956 jMask.clearIfNotMatch = $.jMaskGlobals.clearIfNotMatch; 9957 jMask.byPassKeys = $.jMaskGlobals.byPassKeys; 9958 jMask.translation = $.extend({}, $.jMaskGlobals.translation, options.translation); 9959 jMask = $.extend(true, {}
9959, jMask, options); 9960 regexMask = p.getRegexMask(); 9961 9962 if (onlyMask) { 9963 p.events(); 9964 p.val(p.getMasked()); 9965 } else { 9966 if (options.placeholder) { 9967 el.attr("placeholder", options.placeholder); 9968 } // this is necessary, otherwise if the user submit the form 9969 // and then press the "back" button, the autocomplete will erase 9970 // the data. Works fine on IE9+, FF, Opera, Safari. 9971 9972 9973 if (el.data("mask")) { 9974 el.attr("autocomplete", "off"); 9975 } // detect if is necessary let the user type freely. 9976 // for is a lot faster than forEach. 9977 9978 9979 for (var i = 0, maxlength = true; i < mask.length; i++) { 9980 var translation = jMask.translation[mask.charAt(i)]; 9981 9982 if (translation && translation.recursive) { 9983 maxlength = false; 9984 break; 9985 } 9986 } 9987 9988 if (maxlength) { 9989 el.attr("maxlength", mask.length).data("mask-maxlength", true); 9990 } 9991 9992 p.destroyEvents(); 9993 p.events(); 9994 var caret = p.getCaret(); 9995 p.val(p.getMasked()); 9996 p.setCaret(caret); 9997 } 9998 }; 9999 10000 jMask.init(!el.is("input")); 10001 }; 10002 10003 $.maskWatchers = {}; 10004 10005 var HTMLAttributes = function HTMLAttributes() { 10006 var input = $(this), 10007 options = {}, 10008 prefix = "data-mask-", 10009 mask = input.attr("data-mask"); 10010 10011 if (input.attr(prefix + "reverse")) { 10012 options.reverse = true; 10013 } 10014 10015 if (input.attr(prefix + "clearifnotmatch")) { 10016 options.clearIfNotMatch = true; 10017 } 10018 10019 if (input.attr(prefix + "selectonfocus") === "true") { 10020 options.selectOnFocus = true; 10021 } 10022 10023 if (notSameMaskObject(input, mask, options)) { 10024 return input.data("mask", new Mask(this, mask, options)); 10025 } 10026 }, 10027 notSameMaskObject = function notSameMaskObject(field, mask, options) { 10028 options = options || {}; 10029 var maskObject = $(field).data("mask"), 10030 stringify = JSON.stringify, 10031 value = $(field).val() || $(field).text(); 10032 10033 try { 10034 if (typeof mask === "function") { 10035 mask = mask(value); 10036 } 10037 10038 return _typeof(maskObject) !== "object" || stringify(maskObject.options) !== stringify(options) || maskObject.mask !== mask; 10039 } catch (e) {} 10040 }, 10041 eventSupported = function eventSupported(eventName) { 10042 var el = document.createElement("div"), 10043 isSupported; 10044 eventName = "on" + eventName; 10045 isSupported = eventName in el; 10046 10047 if (!isSupported) { 10048 el.setAttribute(eventName, "return;"); 10049 isSupported = typeof el[eventName] === "function"; 10050 } 10051 10052 el = null; 10053 return isSupported; 10054 }; 10055 10056 $.fn.mask = function (mask, options) { 10057 options = options || {}; 10058 10059 var selector = this.selector, 10060 globals = $.jMaskGlobals, 10061 interval = globals.watchInterval, 10062 watchInputs = options.watchInputs || globals.watchInputs, 10063 maskFunction = function maskFunction() { 10064 if (notSameMaskObject(this, mask, options)) { 10065 return $(this).data("mask", new Mask(this, mask, options)); 10066 } 10067 }; 10068 10069 $(this).each(maskFunction); 10070 10071 if (selector && selector !== "" && watchInputs) { 10072 clearInterval($.maskWatchers[selector]); 10073 $.maskWatchers[selector] = setInterval(function () { 10074 $(document).find(selector).each(maskFunction); 10075 }, interval); 10076 } 10077 10078 return this; 10079 }; 10080 10081 $.fn.masked = function (val) { 10082 return this.data("mask").getMaskedVal(val); 10083 }; 10084 10085 $.fn.unmask = function () { 10086 clearInterval($.maskWatchers[this.selector]); 10087 delete $.maskWatchers[this.selector]; 10088 return this.each(function () { 10089 var dataMask = $(this).data("mask"); 10090 10091 if (dataMask) { 10092 dataMask.remove().removeData("mask"); 10093 } 10094 }); 10095 }; 10096 10097 $.fn.cleanVal = function () { 10098 return this.data("mask").getCleanVal(); 10099 }; 10100 10101 $.applyDataMask = function (selector) { 10102 selector = selector || $.jMaskGlobals.maskElements; 10103 var $selector = selector instanceof $ ? selector : $(selector); 10104 $selector.filter($.jMaskGlobals.dataMaskAttr).each(HTMLAttributes); 10105 }; 10106 10107 var globals = { 10108 maskElements: "input,td,span,div", 10109 dataMaskAttr: "[data-mask]", 10110 dataMask: true, 10111 watchInterval: 300, 10112 watchInputs: true, 10113 keyStrokeCompensation: 10, 10114 // old versions of chrome dont work great with input event 10115 useInput: !/Chrome\/[2-4][0-9]|SamsungBrowser/.test(window.navigator.userAgent) && eventSupported("input"), 10116 watchDataMask: false, 10117 byPassKeys: [9, 16, 17, 18, 36, 37, 38, 39, 40, 91], 10118 translation: { 10119 "0": { 10120 pattern: /\d/ 10121 }, 10122 "9": { 10123 pattern: /\d/, 10124 optional: true 10125 }, 10126 "#": { 10127 pattern: /\d/, 10128 recursive: true 10129 }, 10130 "A": { 10131 pattern: /[a-zA-Z0-9]/ 10132 }, 10133 "S": { 10134 pattern: /[a-zA-Z]/ 10135 } 10136 } 10137 }; 10138 $.jMaskGlobals = $.jMaskGlobals || {}; 10139 globals = $.jMaskGlobals = $.extend(true, {}, globals, $.jMaskGlobals); // looking for inputs with data-mask attribute 10140 10141 if (globals.dataMask) { 10142 $.applyDataMask(); 10143 } 10144 10145 setInterval(function () { 10146 if ($.jMaskGlobals.watchDataMask) { 10147 $.applyDataMask(); 10148 } 10149 }, globals.watchInterval); 10150}, window.jQuery, window.Zepto); 10151 10152/***/ }), 10153 10154/***/ 9073: 10155/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 10156 10157/* module decorator */ module = __webpack_require__.nmd(module); 10158function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 10159 10160/*! lazysizes - v4.1.4 */ 10161!function (a, b) { 10162 var c = b(a, a.document); 10163 a.lazySizes = c, "object" == ( false ? 0 : _typeof(module)) && module.exports && (module.exports = c); 10164}(window, function (a, b) { 10165 "use strict"; 10166 10167 if (b.getElementsByClassName) { 10168 var c, 10169 d, 10170 e = b.documentElement, 10171 f = a.Date, 10172 g = a.HTMLPictureElement, 10173 h = "addEventListener", 10174 i = "getAttribute", 10175 j = a[h], 10176 k = a.setTimeout, 10177 l = a.requestAnimationFrame || k, 10178 m = a.requestIdleCallback, 10179 n = /^picture$/i, 10180 o = ["load", "error", "lazyincluded", "_lazyloaded"], 10181 p = {}, 10182 q = Array.prototype.forEach, 10183 r = function r(a, b) { 10184 return p[b] || (p[b] = new RegExp("(\\s|^)" + b + "(\\s|$)")), p[b].test(a[i]("class") || "") && p[b]; 10185 }, 10186 s = function s(a, b) { 10187 r(a, b) || a.setAttribute("class", (a[i]("class") || "").trim() + " " + b); 10188 }, 10189 t = function t(a, b) { 10190 var c; 10191 (c = r(a, b)) && a.setAttribute("class", (a[i]("class") || "").replace(c, " ")); 10192 }, 10193 u = function u(a, b, c) { 10194 var d = c ? h : "removeEventListener"; 10195 c && u(a, b), o.forEach(function (c) { 10196 a[d](c, b); 10197 }); 10198 }, 10199 v = function v(a, d, e, f, g) { 10200 var h = b.createEvent("Event"); 10201 return e || (e = {}), e.instance = c, h.initEvent(d, !f, !g), h.detail = e, a.dispatchEvent(h), h; 10202 }, 10203 w = function w(b, c) { 10204 var e; 10205 !g && (e = a.picturefill || d.pf) ? (c && c.src && !b[i]("srcset") && b.setAttribute("srcset", c.src), e({ 10206 reevaluate: !0, 10207 elements: [b] 10208 })) : c && c.src && (b.src = c.src); 10209 }, 10210 x = function x(a, b) { 10211 return (getComputedStyle(a, null) || {})[b]; 10212 }, 10213 y = function y(a, b, c) { 10214 for (c = c || a.offsetWidth; c < d.minSize && b && !a._lazysizesWidth;) { 10215 c = b.offsetWidth, b = b.parentNode; 10216 } 10217 10218 return c; 10219 }, 10220 z = function () { 10221 var a, 10222 c, 10223 d = [], 10224 e = [], 10225 f = d, 10226 g = function g() { 10227 var b = f; 10228 10229 for (f = d.length ? e : d, a = !0, c = !1; b.length;) { 10230 b.shift()(); 10231 } 10232 10233 a = !1; 10234 }, 10235 h = function h(d, e) { 10236 a && !e ? d.apply(this, arguments) : (f.push(d), c || (c = !0, (b.hidden ? k : l)(g))); 10237 }; 10238 10239 return h._lsFlush = g, h; 10240 }(), 10241 A = function A(a, b) { 10242 return b ? function () { 10243 z(a); 10244 } : function () { 10245 var b = this, 10246 c = arguments; 10247 z(function () { 10248 a.apply(b, c); 10249 }); 10250 }; 10251 }, 10252 B = function B(a) { 10253 var b, 10254 c = 0, 10255 e = d.throttleDelay, 10256 g = d.ricTimeout, 10257 h = function h() { 10258 b = !1, c = f.now(), a(); 10259 }, 10260 i = m && g > 49 ? function () { 10261 m(h, { 10262 timeout: g 10263 }), g !== d.ricTimeout && (g = d.ricTimeout); 10264 } : A(function () { 10265 k(h); 10266 }, !0); 10267 10268 return function (a) { 10269 var d; 10270 (a = a === !0) && (g = 33), b || (b = !0, d = e - (f.now() - c), 0 > d && (d = 0), a || 9 > d ? i() : k(i, d)); 10271 }; 10272 }, 10273 C = function C(a) { 10274 var b, 10275 c, 10276 d = 99, 10277 e = function e() { 10278 b = null, a(); 10279 }, 10280 g = function g() { 10281 var a = f.now() - c; 10282 d > a ? k(g, d - a) : (m || e)(e); 10283 }; 10284 10285 return function () { 10286 c = f.now(), b || (b = k(g, d)); 10287 }; 10288 }; 10289 10290 !function () { 10291 var b, 10292 c = { 10293 lazyClass: "lazyload", 10294 loadedClass: "lazyloaded", 10295 loadingClass: "lazyloading", 10296 preloadClass: "lazypreload", 10297 errorClass: "lazyerror", 10298 autosizesClass: "lazyautosizes", 10299 srcAttr: "data-src", 10300 srcsetAttr: "data-srcset", 10301 sizesAttr: "data-sizes", 10302 minSize: 40, 10303 customMedia: {}, 10304 init: !0, 10305 expFactor: 1.5, 10306 hFac: .8,
10307 loadMode: 2, 10308 loadHidden: !0, 10309 ricTimeout: 0, 10310 throttleDelay: 125 10311 }; 10312 d = a.lazySizesConfig || a.lazysizesConfig || {}; 10313 10314 for (b in c) { 10315 b in d || (d[b] = c[b]); 10316 } 10317 10318 a.lazySizesConfig = d, k(function () { 10319 d.init && F(); 10320 }); 10321 }(); 10322 10323 var D = function () { 10324 var g, 10325 l, 10326 m, 10327 o, 10328 p, 10329 y, 10330 D, 10331 F, 10332 G, 10333 H, 10334 I, 10335 J, 10336 K, 10337 L, 10338 M = /^img$/i, 10339 N = /^iframe$/i, 10340 O = "onscroll" in a && !/(gle|ing)bot/.test(navigator.userAgent), 10341 P = 0, 10342 Q = 0, 10343 R = 0, 10344 S = -1, 10345 T = function T(a) { 10346 R--, a && a.target && u(a.target, T), (!a || 0 > R || !a.target) && (R = 0); 10347 }, 10348 U = function U(a, c) { 10349 var d, 10350 f = a, 10351 g = "hidden" == x(b.body, "visibility") || "hidden" != x(a.parentNode, "visibility") && "hidden" != x(a, "visibility"); 10352 10353 for (F -= c, I += c, G -= c, H += c; g && (f = f.offsetParent) && f != b.body && f != e;) { 10354 g = (x(f, "opacity") || 1) > 0, g && "visible" != x(f, "overflow") && (d = f.getBoundingClientRect(), g = H > d.left && G < d.right && I > d.top - 1 && F < d.bottom + 1); 10355 } 10356 10357 return g; 10358 }, 10359 V = function V() { 10360 var a, 10361 f, 10362 h, 10363 j, 10364 k, 10365 m, 10366 n, 10367 p, 10368 q, 10369 r = c.elements; 10370 10371 if ((o = d.loadMode) && 8 > R && (a = r.length)) {
10372 f = 0, S++, null == K && ("expand" in d || (d.expand = e.clientHeight > 500 && e.clientWidth > 500 ? 500 : 370), J = d.expand, K = J * d.expFactor), K > Q && 1 > R && S > 2 && o > 2 && !b.hidden ? (Q = K, S = 0) : Q = o > 1 && S > 1 && 6 > R ? J : P; 10373 10374 for (; a > f; f++) { 10375 if (r[f] && !r[f]._lazyRace) if (O) { 10376 if ((p = r[f][i]("data-expand")) && (m = 1 * p) || (m = Q), q !== m && (y = innerWidth + m * L, D = innerHeight + m, n = -1 * m, q = m), h = r[f].getBoundingClientRect(), (I = h.bottom) >= n && (F = h.top) <= D && (H = h.right) >= n * L && (G = h.left) <= y && (I || H || G || F) && (d.loadHidden || "hidden" != x(r[f], "visibility")) && (l && 3 > R && !p && (3 > o || 4 > S) || U(r[f], m))) { 10377 if (ba(r[f]), k = !0, R > 9) break; 10378 } else !k && l && !j && 4 > R && 4 > S && o > 2 && (g[0] || d.preloadAfterLoad) && (g[0] || !p && (I || H || G || F || "auto" != r[f][i](d.sizesAttr))) && (j = g[0] || r[f]); 10379 } else ba(r[f]); 10380 } 10381 10382 j && !k && ba(j); 10383 } 10384 }, 10385 W = B(V), 10386 X = function X(a) { 10387 s(a.target, d.loadedClass), t(a.target, d.loadingClass), u(a.target, Z), v(a.target, "lazyloaded"); 10388 }, 10389 Y = A(X), 10390 Z = function Z(a) { 10391 Y({ 10392 target: a.target 10393 }); 10394 }, 10395 $ = function $(a, b) { 10396 try { 10397 a.contentWindow.location.replace(b); 10398 } catch (c) { 10399 a.src = b; 10400 } 10401 }, 10402 _ = function _(a) { 10403 var b, 10404 c = a[i](d.srcsetAttr); 10405 (b = d.customMedia[a[i]("data-media") || a[i]("media")]) && a.setAttribute("media", b), c && a.setAttribute("srcset", c); 10406 }, 10407 aa = A(function (a, b, c, e, f) { 10408 var g, h, j, l, o, p; 10409 (o = v(a, "lazybeforeunveil", b)).defaultPrevented || (e && (c ? s(a, d.autosizesClass) : a.setAttribute("sizes", e)), h = a[i](d.srcsetAttr), g = a[i](d.srcAttr), f && (j = a.parentNode, l = j && n.test(j.nodeName || "")), p = b.firesLoad || "src" in a && (h || g || l), o = { 10410 target: a 10411 }, p && (u(a, T, !0), clearTimeout(m), m = k(T, 2500), s(a, d.loadingClass), u(a, Z, !0)), l && q.call(j.getElementsByTagName("source"), _), h ? a.setAttribute("srcset", h) : g && !l && (N.test(a.nodeName) ? $(a, g) : a.src = g), f && (h || l) && w(a, { 10412 src: g 10413 })), a._lazyRace && delete a._lazyRace, t(a, d.lazyClass), z(function () { 10414 (!p || a.complete && a.naturalWidth > 1) && (p ? T(o) : R--, X(o)); 10415 }, !0); 10416 }), 10417 ba = function ba(a) { 10418 var b, 10419 c = M.test(a.nodeName), 10420 e = c && (a[i](d.sizesAttr) || a[i]("sizes")), 10421 f = "auto" == e; 10422 (!f && l || !c || !a[i]("src") && !a.srcset || a.complete || r(a, d.errorClass) || !r(a, d.lazyClass)) && (b = v(a, "lazyunveilread").detail, f && E.updateElem(a, !0, a.offsetWidth), a._lazyRace = !0, R++, aa(a, b, f, e, c)); 10423 }, 10424 ca = function ca() { 10425 if (!l) { 10426 if (f.now() - p < 999) return void k(ca, 999); 10427 var a = C(function () { 10428 d.loadMode = 3, W(); 10429 }); 10430 l = !0, d.loadMode = 3, W(), j("scroll", function () { 10431 3 == d.loadMode && (d.loadMode = 2), a(); 10432 }, !0); 10433 } 10434 }; 10435 10436 return { 10437 _: function _() { 10438 p = f.now(), c.elements = b.getElementsByClassName(d.lazyClass), g = b.getElementsByClassName(d.lazyClass + " " + d.preloadClass), L = d.hFac, j("scroll", W, !0), j("resize", W, !0), a.MutationObserver ? new MutationObserver(W).observe(e, { 10439 childList: !0, 10440 subtree: !0, 10441 attributes: !0 10442 }) : (e[h]("DOMNodeInserted", W, !0), e[h]("DOMAttrModified", W, !0), setInterval(W, 999)), j("hashchange", W, !0), ["focus", "mouseover", "click", "load", "transitionend", "animationend", "webkitAnimationEnd"].forEach(function (a) { 10443 b[h](a, W, !0); 10444 }), /d$|^c/.test(b.readyState) ? ca() : (j("load", ca), b[h]("DOMContentLoaded", W), k(ca, 2e4)), c.elements.length ? (V(), z._lsFlush()) : W(); 10445 }, 10446 checkElems: W, 10447 unveil: ba 10448 }; 10449 }(), 10450 E = function () { 10451 var a, 10452 c = A(function (a, b, c, d) { 10453 var e, f, g; 10454 if (a._lazysizesWidth = d, d += "px", a.setAttribute("sizes", d), n.test(b.nodeName || "")) for (e = b.getElementsByTagName("source"), f = 0, g = e.length; g > f; f++) { 10455 e[f].setAttribute("sizes", d); 10456 } 10457 c.detail.dataAttr || w(a, c.detail); 10458 }), 10459 e = function e(a, b, d) { 10460 var e, 10461 f = a.parentNode; 10462 f && (d = y(a, f, d), e = v(a, "lazybeforesizes", { 10463 width: d, 10464 dataAttr: !!b 10465 }), e.defaultPrevented || (d = e.detail.width, d && d !== a._lazysizesWidth && c(a, f, e, d))); 10466 }, 10467 f = function f() { 10468 var b, 10469 c = a.length; 10470 if (c) for (b = 0; c > b; b++) { 10471 e(a[b]); 10472 } 10473 }, 10474 g = C(f); 10475 10476 return { 10477 _: function _() {
10478 a = b.getElementsByClassName(d.autosizesClass), j("resize", g); 10479 }, 10480 checkElems: g, 10481 updateElem: e 10482 }; 10483 }(), 10484 F = function F() { 10485 F.i || (F.i = !0, E._(), D._()); 10486 }; 10487 10488 return c = { 10489 cfg: d, 10490 autoSizer: E, 10491 loader: D, 10492 init: F, 10493 uP: w, 10494 aC: s, 10495 rC: t, 10496 hC: r, 10497 fire: v, 10498 gW: y, 10499 rAF: z 10500 }; 10501 } 10502}); 10503 10504/***/ }), 10505 10506/***/ 3105: 10507/***/ (() => { 10508 10509function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 10510 10511/*! modernizr 3.6.0 (Custom Build) | MIT * 10512 * https://modernizr.com/download/?-touchevents-setclasses !*/ 10513!function (e, n, t) { 10514 function o(e) { 10515 var n = u.className, 10516 t = Modernizr._config.classPrefix || ""; 10517 10518 if (p && (n = n.baseVal), Modernizr._config.enableJSClass) { 10519 var o = new RegExp("(^|\\s)" + t + "no-js(\\s|$)"); 10520 n = n.replace(o, "$1" + t + "js$2"); 10521 } 10522 10523 Modernizr._config.enableClasses && (n += " " + t + e.join(" " + t), p ? u.className.baseVal = n : u.className = n); 10524 } 10525 10526 function s(e, n) { 10527 return _typeof(e) === n; 10528 } 10529 10530 function a() { 10531 var e, n, t, o, a, i, r; 10532 10533 for (var l in c) { 10534 if (c.hasOwnProperty(l)) { 10535 if (e = [], n = c[l], n.name && (e.push(n.name.toLowerCase()), n.options && n.options.aliases && n.options.aliases.length)) for (t = 0; t < n.options.aliases.length; t++) { 10536 e.push(n.options.aliases[t].toLowerCase()); 10537 } 10538 10539 for (o = s(n.fn, "function") ? n.fn() : n.fn, a = 0; a < e.length; a++) { 10540 i = e[a], r = i.split("."), 1 === r.length ? Modernizr[r[0]] = o : (!Modernizr[r[0]] || Modernizr[r[0]] instanceof Boolean || (Modernizr[r[0]] = new Boolean(Modernizr[r[0]])), Modernizr[r[0]][r[1]] = o), f.push((o ? "" : "no-") + r.join("-")); 10541 } 10542 } 10543 } 10544 } 10545 10546 function i() { 10547 return "function" != typeof n.createElement ? n.createElement(arguments[0]) : p ? n.createElementNS.call(n, "http://www.w3.org/2000/svg", arguments[0]) : n.createElement.apply(n, arguments); 10548 } 10549 10550 function r() { 10551 var e = n.body; 10552 return e || (e = i(p ? "svg" : "body"), e.fake = !0), e; 10553 } 10554 10555 function l(e, t, o, s) { 10556 var a, 10557 l, 10558 f, 10559 c, 10560 d = "modernizr", 10561 p = i("div"), 10562 h = r(); 10563 if (parseInt(o, 10)) for (; o--;) { 10564 f = i("div"), f.id = s ? s[o] : d + (o + 1), p.appendChild(f); 10565 } 10566 return a = i("style"), a.type = "text/css", a.id = "s" + d, (h.fake ? h : p).appendChild(a), h.appendChild(p), a.styleSheet ? a.styleSheet.cssText = e : a.appendChild(n.createTextNode(e)), p.id = d, h.fake && (h.style.background = "", h.style.overflow = "hidden", c = u.style.overflow, u.style.overflow = "hidden", u.appendChild(h)), l = t(p, e), h.fake ? (h.parentNode.removeChild(h), u.style.overflow = c, u.offsetHeight) : p.parentNode.removeChild(p), !!l; 10567 } 10568 10569 var f = [], 10570 c = [], 10571 d = { 10572 _version: "3.6.0", 10573 _config: { 10574 classPrefix: "", 10575 enableClasses: !0, 10576 enableJSClass: !0, 10577 usePrefixes: !0 10578 }, 10579 _q: [], 10580 on: function on(e, n) { 10581 var t = this; 10582 setTimeout(function () { 10583 n(t[e]); 10584 }, 0); 10585 }, 10586 addTest: function addTest(e, n, t) { 10587 c.push({ 10588 name: e, 10589 fn: n, 10590 options: t 10591 }); 10592 }, 10593 addAsyncTest: function addAsyncTest(e) { 10594 c.push({ 10595 name: null, 10596 fn: e 10597 }); 10598 } 10599 }, 10600 Modernizr = function Modernizr() {}; 10601 10602 Modernizr.prototype = d, Modernizr = new Modernizr(); 10603 var u = n.documentElement, 10604 p = "svg" === u.nodeName.toLowerCase(), 10605 h = d._config.usePrefixes ? " -webkit- -moz- -o- -ms- ".split(" ") : ["", ""]; 10606 d._prefixes = h; 10607 var m = d.testStyles = l; 10608 Modernizr.addTest("touchevents", function () { 10609 var t; 10610 if ("ontouchstart" in e || e.DocumentTouch && n instanceof DocumentTouch) t = !0;else { 10611 var o = ["@media (", h.join("touch-enabled),("), "heartz", ")", "{#modernizr{top:9px;position:absolute}}"].join(""); 10612 m(o, function (e) { 10613 t = 9 === e.offsetTop; 10614 }); 10615 } 10616 return t; 10617 }), a(), o(f), delete d.addTest, delete d.addAsyncTest; 10618 10619 for (var v = 0; v < Modernizr._q.length; v++) { 10620 Modernizr._q[v](); 10621 } 10622 10623 e.Modernizr = Modernizr; 10624}(window, document); 10625 10626/***/ }), 10627 10628/***/ 8150: 10629/***/ ((module, exports, __webpack_require__) => { 10630 10631/* module decorator */ module = __webpack_require__.nmd(module); 10632var __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 10633 10634/*! picturefill - v3.0.2 - 2016-02-12 10635 * https://scottjehl.github.io/picturefill/ 10636 * Copyright (c) 2016 https://github.com/scottjehl/picturefill/blob/master/Authors.txt; Licensed MIT 10637 */ 10638!function (a) { 10639 var b = navigator.userAgent; 10640 a.HTMLPictureElement && /ecko/.test(b) && b.match(/rv\:(\d+)/) && RegExp.$1 < 45 && addEventListener("resize", function () { 10641 var b, 10642 c = document.createElement("source"), 10643 d = function d(a) { 10644 var b, 10645 d, 10646 e = a.parentNode;
10647 "PICTURE" === e.nodeName.toUpperCase() ? (b = c.cloneNode(), e.insertBefore(b, e.firstElementChild), setTimeout(function () { 10648 e.removeChild(b); 10649 })) : (!a._pfLastSize || a.offsetWidth > a._pfLastSize) && (a._pfLastSize = a.offsetWidth, d = a.sizes, a.sizes += ",100vw", setTimeout(function () { 10650 a.sizes = d; 10651 })); 10652 }, 10653 e = function e() { 10654 var a, 10655 b = document.querySelectorAll("picture > img, img[srcset][sizes]"); 10656 10657 for (a = 0; a < b.length; a++) { 10658 d(b[a]); 10659 } 10660 }, 10661 f = function f() { 10662 clearTimeout(b), b = setTimeout(e, 99); 10663 }, 10664 g = a.matchMedia && matchMedia("(orientation: landscape)"), 10665 h = function h() { 10666 f(), g && g.addListener && g.addListener(f); 10667 }; 10668 10669 return c.srcset = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==", /^[c|i]|d$/.test(document.readyState || "") ? h() : document.addEventListener("DOMContentLoaded", h), f; 10670 }()); 10671}(window), function (a, b, c) { 10672 "use strict"; 10673 10674 function d(a) { 10675 return " " === a || " " === a || "\n" === a || "\f" === a || "\r" === a; 10676 } 10677 10678 function e(b, c) { 10679 var d = new a.Image(); 10680 return d.onerror = function () { 10681 A[b] = !1, ba(); 10682 }, d.onload = function () { 10683 A[b] = 1 === d.width, ba(); 10684 }, d.src = c, "pending"; 10685 } 10686 10687 function f() { 10688 M = !1, P = a.devicePixelRatio, N = {}, O = {}, s.DPR = P || 1, Q.width = Math.max(a.innerWidth || 0, z.clientWidth), Q.height = Math.max(a.innerHeight || 0, z.clientHeight), Q.vw = Q.width / 100, Q.vh = Q.height / 100, r = [Q.height, Q.width, P].join("-"), Q.em = s.getEmValue(), Q.rem = Q.em; 10689 } 10690 10691 function g(a, b, c, d) { 10692 var e, f, g, h; 10693 return "saveData" === B.algorithm ? a > 2.7 ? h = c + 1 : (f = b - c, e = Math.pow(a - .6, 1.5), g = f * e, d && (g += .1 * e), h = a + g) : h = c > 1 ? Math.sqrt(a * b) : a, h > c; 10694 } 10695 10696 function h(a) { 10697 var b, 10698 c = s.getSet(a), 10699 d = !1; 10700 "pending" !== c && (d = r, c && (b = s.setRes(c), s.applySetCandidate(b, a))), a[s.ns].evaled = d; 10701 } 10702 10703 function i(a, b) { 10704 return a.res - b.res; 10705 } 10706 10707 function j(a, b, c) { 10708 var d; 10709 return !c && b && (c = a[s.ns].sets, c = c && c[c.length - 1]), d = k(b, c), d && (b = s.makeUrl(b), a[s.ns].curSrc = b, a[s.ns].curCan = d, d.res || aa(d, d.set.sizes)), d; 10710 } 10711 10712 function k(a, b) { 10713 var c, d, e; 10714 if (a && b) for (e = s.parseSet(b), a = s.makeUrl(a), c = 0; c < e.length; c++) { 10715 if (a === s.makeUrl(e[c].url)) { 10716 d = e[c]; 10717 break; 10718 } 10719 } 10720 return d; 10721 } 10722 10723 function l(a, b) { 10724 var c, 10725 d, 10726 e, 10727 f, 10728 g = a.getElementsByTagName("source"); 10729 10730 for (c = 0, d = g.length; d > c; c++) { 10731 e = g[c], e[s.ns] = !0, f = e.getAttribute("srcset"), f && b.push({ 10732 srcset: f, 10733 media: e.getAttribute("media"), 10734 type: e.getAttribute("type"), 10735 sizes: e.getAttribute("sizes") 10736 }); 10737 } 10738 } 10739 10740 function m(a, b) { 10741 function c(b) { 10742 var c, 10743 d = b.exec(a.substring(m)); 10744 return d ? (c = d[0], m += c.length, c) : void 0; 10745 } 10746 10747 function e() { 10748 var a, 10749 c, 10750 d, 10751 e, 10752 f, 10753 i, 10754 j, 10755 k, 10756 l, 10757 m = !1, 10758 o = {}; 10759 10760 for (e = 0; e < h.length; e++) { 10761 f = h[e], i = f[f.length - 1], j = f.substring(0, f.length - 1), k = parseInt(j, 10), l = parseFloat(j), X.test(j) && "w" === i ? ((a || c) && (m = !0), 0 === k ? m = !0 : a = k) : Y.test(j) && "x" === i ? ((a || c || d) && (m = !0), 0 > l ? m = !0 : c = l) : X.test(j) && "h" === i ? ((d || c) && (m = !0), 0 === k ? m = !0 : d = k) : m = !0; 10762 } 10763 10764 m || (o.url = g, a && (o.w = a), c && (o.d = c), d && (o.h = d), d || c || a || (o.d = 1), 1 === o.d && (b.has1x = !0), o.set = b, n.push(o)); 10765 } 10766 10767 function f() { 10768 for (c(T), i = "", j = "in descriptor";;) { 10769 if (k = a.charAt(m), "in descriptor" === j) { 10770 if (d(k)) i && (h.push(i), i = "", j = "after descriptor");else { 10771 if ("," === k) return m += 1, i && h.push(i), void e(); 10772 if ("(" === k) i += k, j = "in parens";else { 10773 if ("" === k) return i && h.push(i), void e(); 10774 i += k; 10775 } 10776 } 10777 } else if ("in parens" === j) { 10778 if (")" === k) i += k, j = "in descriptor";else { 10779 if ("" === k) return h.push(i), void e(); 10780 i += k; 10781 } 10782 } else if ("after descriptor" === j) if (d(k)) ;else { 10783 if ("" === k) return void e(); 10784 j = "in descriptor", m -= 1; 10785 } 10786 m += 1; 10787 } 10788 } 10789 10790 for (var g, h, i, j, k, l = a.length, m = 0, n = [];;) { 10791 if (c(U), m >= l) return n; 10792 g = c(V), h = [], "," === g.slice(-1) ? (g = g.replace(W, ""), e()) : f(); 10793 } 10794 } 10795 10796 function n(a) { 10797 function b(a) { 10798 function b() { 10799 f && (g.push(f), f = ""); 10800 } 10801 10802 function c() { 10803 g[0] && (h.push(g), g = []); 10804 } 10805 10806 for (var e, f = "", g = [], h = [], i = 0, j = 0, k = !1;;) { 10807 if (e = a.charAt(j), "" === e) return b(), c(), h; 10808 10809 if (k) { 10810 if ("*" === e && "/" === a[j + 1]) { 10811 k = !1, j += 2, b(); 10812 continue; 10813 } 10814 10815 j += 1; 10816 } else { 10817 if (d(e)) { 10818 if (a.charAt(j - 1) && d(a.charAt(j - 1)) || !f) { 10819 j += 1; 10820 continue; 10821 } 10822 10823 if (0 === i) { 10824 b(), j += 1; 10825 continue; 10826 } 10827 10828 e = " "; 10829 } else if ("(" === e) i += 1;else if (")" === e) i -= 1;else { 10830 if ("," === e) { 10831 b(), c(), j += 1; 10832 continue; 10833 } 10834 10835 if ("/" === e && "*" === a.charAt(j + 1)) { 10836 k = !0, j += 2; 10837 continue; 10838 } 10839 } 10840 10841 f += e, j += 1; 10842 } 10843 } 10844 } 10845 10846 function c(a) { 10847 return k.test(a) && parseFloat(a) >= 0 ? !0 : l.test(a) ? !0 : "0" === a || "-0" === a || "+0" === a ? !0 : !1; 10848 } 10849 10850 var e, 10851 f, 10852 g, 10853 h, 10854 i, 10855 j, 10856 k = /^(?:[+-]?[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?[0-9]+)?(?:ch|cm|em|ex|in|mm|pc|pt|px|rem|vh|vmin|vmax|vw)$/i, 10857 l = /^calc\((?:[0-9a-z \.\+\-\*\/\(\)]+)\)$/i; 10858 10859 for (f = b(a), g = f.length, e = 0; g > e; e++) { 10860 if (h = f[e], i = h[h.length - 1], c(i)) { 10861 if (j = i, h.pop(), 0 === h.length) return j; 10862 if (h = h.join(" "), s.matchesMedia(h)) return j; 10863 } 10864 } 10865 10866 return "100vw"; 10867 } 10868 10869 b.createElement("picture"); 10870 10871 var o, 10872 p, 10873 q, 10874 r, 10875 s = {}, 10876 t = !1, 10877 u = function u() {}, 10878 v = b.createElement("img"), 10879 w = v.getAttribute, 10880 x = v.setAttribute, 10881 y = v.removeAttribute, 10882 z = b.documentElement, 10883 A = {}, 10884 B = { 10885 algorithm: "" 10886 }, 10887 C = "data-pfsrc", 10888 D = C + "set", 10889 E = navigator.userAgent, 10890 F = /rident/.test(E) || /ecko/.test(E) && E.match(/rv\:(\d+)/) && RegExp.$1 > 35, 10891 G = "currentSrc", 10892 H = /\s+\+?\d+(e\d+)?w/, 10893 I = /(\([^)]+\))?\s*(.+)/, 10894 J = a.picturefillCFG, 10895 K = "position:absolute;
10895left:0;visibility:hidden;display:block;padding:0;border:none;font-size:1em;width:1em;overflow:hidden;clip:rect(0px, 0px, 0px, 0px)", 10896 L = "font-size:100%!important;", 10897 M = !0, 10898 N = {}, 10899 O = {}, 10900 P = a.devicePixelRatio, 10901 Q = { 10902 px: 1, 10903 "in": 96 10904 }, 10905 R = b.createElement("a"), 10906 S = !1, 10907 T = /^[ \t\n\r\u000c]+/, 10908 U = /^[, \t\n\r\u000c]+/, 10909 V = /^[^ \t\n\r\u000c]+/, 10910 W = /[,]+$/, 10911 X = /^\d+$/, 10912 Y = /^-?(?:[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/, 10913 Z = function Z(a, b, c, d) { 10914 a.addEventListener ? a.addEventListener(b, c, d || !1) : a.attachEvent && a.attachEvent("on" + b, c); 10915 }, 10916 $ = function $(a) { 10917 var b = {}; 10918 return function (c) { 10919 return c in b || (b[c] = a(c)), b[c]; 10920 }; 10921 }, 10922 _ = function () { 10923 var a = /^([\d\.]+)(em|vw|px)$/, 10924 b = function b() { 10925 for (var a = arguments, b = 0, c = a[0]; (++b in a);) { 10926 c = c.replace(a[b], a[++b]); 10927 } 10928 10929 return c; 10930 }, 10931 c = $(function (a) { 10932 return "return " + b((a || "").toLowerCase(), /\band\b/g, "&&", /,/g, "||", /min-([a-z-\s]+):/g, "e.$1>=", /max-([a-z-\s]+):/g, "e.$1<=", /calc([^)]+)/g, "($1)", /(\d+[\.]*[\d]*)([a-z]+)/g, "($1 * e.$2)", /^(?!(e.[a-z]|[0-9\.&=|><\+\-\*\(\)\/])).*/gi, "") + ";"; 10933 }); 10934 10935 return function (b, d) { 10936 var e; 10937 if (!(b in N)) if (N[b] = !1, d && (e = b.match(a))) N[b] = e[1] * Q[e[2]];else try { 10938 N[b] = new Function("e", c(b))(Q); 10939 } catch (f) {} 10940 return N[b]; 10941 }; 10942 }(), 10943 aa = function aa(a, b) { 10944 return a.w ? (a.cWidth = s.calcListLength(b || "100vw"), a.res = a.w / a.cWidth) : a.res = a.d, a; 10945 }, 10946 ba = function ba(a) { 10947 if (t) { 10948 var c, 10949 d, 10950 e, 10951 f = a || {}; 10952 10953 if (f.elements && 1 === f.elements.nodeType && ("IMG" === f.elements.nodeName.toUpperCase() ? f.elements = [f.elements] : (f.context = f.elements, f.elements = null)), c = f.elements || s.qsa(f.context || b, f.reevaluate || f.reselect ? s.sel : s.selShort), e = c.length) { 10954 for (s.setupRun(f), S = !0, d = 0; e > d; d++) { 10955 s.fillImg(c[d], f); 10956 } 10957 10958 s.teardownRun(f); 10959 } 10960 } 10961 }; 10962 10963 o = a.console && console.warn ? function (a) { 10964 console.warn(a); 10965 } : u, G in v || (G = "src"), A["image/jpeg"] = !0, A["image/gif"] = !0, A["image/png"] = !0, A["image/svg+xml"] = b.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#Image", "1.1"), s.ns = ("pf" + new Date().getTime()).substr(0, 9), s.supSrcset = "srcset" in v, s.supSizes = "sizes" in v, s.supPicture = !!a.HTMLPictureElement, s.supSrcset && s.supPicture && !s.supSizes && !function (a) { 10966 v.srcset = "data:,a", a.src = "data:,a", s.supSrcset = v.complete === a.complete, s.supPicture = s.supSrcset && s.supPicture; 10967 }(b.createElement("img")), s.supSrcset && !s.supSizes ? !function () { 10968 var a = "data:image/gif;base64,R0lGODlhAgABAPAAAP///wAAACH5BAAAAAAALAAAAAACAAEAAAICBAoAOw==", 10969 c = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==", 10970 d = b.createElement("img"), 10971 e = function e() { 10972 var a = d.width; 10973 2 === a && (s.supSizes = !0), q = s.supSrcset && !s.supSizes, t = !0, setTimeout(ba); 10974 }; 10975 10976 d.onload = e, d.onerror = e, d.setAttribute("sizes", "9px"), d.srcset = c + " 1w," + a + " 9w", d.src = c; 10977 }() : t = !0, s.selShort = "picture>img,img[srcset]", s.sel = s.selShort, s.cfg = B, s.DPR = P || 1, s.u = Q, s.types = A, s.setSize = u, s.makeUrl = $(function (a) { 10978 return R.href = a, R.href; 10979 }), s.qsa = function (a, b) { 10980 return "querySelector" in a ? a.querySelectorAll(b) : []; 10981 }, s.matchesMedia = function () { 10982 return a.matchMedia && (matchMedia("(min-width: 0.1em)") || {}).matches ? s.matchesMedia = function (a) { 10983 return !a || matchMedia(a).matches; 10984 } : s.matchesMedia = s.mMQ, s.matchesMedia.apply(this, arguments); 10985 }, s.mMQ = function (a) { 10986 return a ? _(a) : !0; 10987 }, s.calcLength = function (a) { 10988 var b = _(a, !0) || !1; 10989 return 0 > b && (b = !1), b; 10990 }, s.supportsType = function (a) { 10991 return a ? A[a] : !0; 10992 }, s.parseSize = $(function (a) { 10993 var b = (a || "").match(I); 10994 return { 10995 media: b && b[1], 10996 length: b && b[2] 10997 }; 10998 }), s.parseSet = function (a) { 10999 return a.cands || (a.cands = m(a.srcset, a)), a.cands; 11000 }, s.getEmValue = function () { 11001 var a; 11002 11003 if (!p && (a = b.body)) { 11004 var c = b.createElement("div"), 11005 d = z.style.cssText, 11006 e = a.style.cssText; 11007 c.style.cssText = K, z.style.cssText = L, a.style.cssText = L, a.appendChild(c), p = c.offsetWidth, a.removeChild(c), p = parseFloat(p, 10), z.style.cssText = d, a.style.cssText = e; 11008 } 11009 11010 return p || 16; 11011 }, s.calcListLength = function (a) { 11012 if (!(a in O) || B.uT) { 11013 var b = s.calcLength(n(a)); 11014 O[a] = b ? b : Q.width; 11015 } 11016 11017 return O[a]; 11018 }, s.setRes = function (a) { 11019 var b; 11020 11021 if (a) { 11022 b = s.parseSet(a); 11023 11024 for (var c = 0, d = b.length; d > c; c++) { 11025 aa(b[c], a.sizes); 11026 } 11027 } 11028 11029 return b; 11030 }, s.setRes.res = aa, s.applySetCandidate = function (a, b) { 11031 if (a.length) { 11032 var c, 11033 d, 11034 e, 11035 f, 11036 h, 11037 k, 11038 l, 11039 m, 11040 n, 11041 o = b[s.ns], 11042 p = s.DPR; 11043 if (k = o.curSrc || b[G], l = o.curCan || j(b, k, a[0].set), l && l.set === a[0].set && (n = F && !b.complete && l.res - .1 > p, n || (l.cached = !0, l.res >
11043= p && (h = l))), !h) for (a.sort(i), f = a.length, h = a[f - 1], d = 0; f > d; d++) { 11044 if (c = a[d], c.res >= p) { 11045 e = d - 1, h = a[e] && (n || k !== s.makeUrl(c.url)) && g(a[e].res, c.res, p, a[e].cached) ? a[e] : c; 11046 break; 11047 } 11048 } 11049 h && (m = s.makeUrl(h.url), o.curSrc = m, o.curCan = h, m !== k && s.setSrc(b, h), s.setSize(b)); 11050 } 11051 }, s.setSrc = function (a, b) { 11052 var c; 11053 a.src = b.url, "image/svg+xml" === b.set.type && (c = a.style.width, a.style.width = a.offsetWidth + 1 + "px", a.offsetWidth + 1 && (a.style.width = c)); 11054 }, s.getSet = function (a) { 11055 var b, 11056 c, 11057 d, 11058 e = !1, 11059 f = a[s.ns].sets; 11060 11061 for (b = 0; b < f.length && !e; b++) { 11062 if (c = f[b], c.srcset && s.matchesMedia(c.media) && (d = s.supportsType(c.type))) { 11063 "pending" === d && (c = d), e = c; 11064 break; 11065 } 11066 } 11067 11068 return e; 11069 }, s.parseSets = function (a, b, d) { 11070 var e, 11071 f, 11072 g, 11073 h, 11074 i = b && "PICTURE" === b.nodeName.toUpperCase(), 11075 j = a[s.ns]; 11076 (j.src === c || d.src) && (j.src = w.call(a, "src"), j.src ? x.call(a, C, j.src) : y.call(a, C)), (j.srcset === c || d.srcset || !s.supSrcset || a.srcset) && (e = w.call(a, "srcset"), j.srcset = e, h = !0), j.sets = [], i && (j.pic = !0, l(b, j.sets)), j.srcset ? (f = { 11077 srcset: j.srcset, 11078 sizes: w.call(a, "sizes") 11079 }, j.sets.push(f), g = (q || j.src) && H.test(j.srcset || ""), g || !j.src || k(j.src, f) || f.has1x || (f.srcset += ", " + j.src, f.cands.push({ 11080 url: j.src, 11081 d: 1, 11082 set: f 11083 }))) : j.src && j.sets.push({ 11084 srcset: j.src, 11085 sizes: null 11086 }), j.curCan = null, j.curSrc = c, j.supported = !(i || f && !s.supSrcset || g && !s.supSizes), h && s.supSrcset && !j.supported && (e ? (x.call(a, D, e), a.srcset = "") : y.call(a, D)), j.supported && !j.srcset && (!j.src && a.src || a.src !== s.makeUrl(j.src)) && (null === j.src ? a.removeAttribute("src") : a.src = j.src), j.parsed = !0; 11087 }, s.fillImg = function (a, b) { 11088 var c, 11089 d = b.reselect || b.reevaluate; 11090 a[s.ns] || (a[s.ns] = {}), c = a[s.ns], (d || c.evaled !== r) && ((!c.parsed || b.reevaluate) && s.parseSets(a, a.parentNode, b), c.supported ? c.evaled = r : h(a)); 11091 }, s.setupRun = function () { 11092 (!S || M || P !== a.devicePixelRatio) && f(); 11093 }, s.supPicture ? (ba = u, s.fillImg = u) : !function () { 11094 var c, 11095 d = a.attachEvent ? /d$|^c/ : /d$|^c|^i/, 11096 e = function e() { 11097 var a = b.readyState || ""; 11098 f = setTimeout(e, "loading" === a ? 200 : 999), b.body && (s.fillImgs(), c = c || d.test(a), c && clearTimeout(f)); 11099 }, 11100 f = setTimeout(e, b.body ? 9 : 99), 11101 g = function g(a, b) { 11102 var c, 11103 d, 11104 e = function e() { 11105 var f = new Date() - d; 11106 b > f ? c = setTimeout(e, b - f) : (c = null, a()); 11107 }; 11108 11109 return function () { 11110 d = new Date(), c || (c = setTimeout(e, b)); 11111 }; 11112 }, 11113 h = z.clientHeight, 11114 i = function i() { 11115 M = Math.max(a.innerWidth || 0, z.clientWidth) !== Q.width || z.clientHeight !== h, h = z.clientHeight, M && s.fillImgs(); 11116 }; 11117 11118 Z(a, "resize", g(i, 99)), Z(b, "readystatechange", e); 11119 }(), s.picturefill = ba, s.fillImgs = ba, s.teardownRun = u, ba._ = s, a.picturefillCFG = { 11120 pf: s, 11121 push: function push(a) { 11122 var b = a.shift(); 11123 "function" == typeof s[b] ? s[b].apply(s, a) : (B[b] = a[0], S && s.fillImgs({ 11124 reselect: !0 11125 })); 11126 } 11127 }; 11128 11129 for (; J && J.length;) { 11130 a.picturefillCFG.push(J.shift()); 11131 } 11132 11133 a.picturefill = ba, "object" == ( false ? 0 : _typeof(module)) && "object" == _typeof(module.exports) ? module.exports = ba : true && !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () { 11134 return ba; 11135 }).call(exports, __webpack_require__, exports, module), 11136 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)), s.supPicture || (A["image/webp"] = e("image/webp", "data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA==")); 11137}(window, document); 11138 11139/***/ }), 11140 11141/***/ 8777: 11142/***/ ((module, exports, __webpack_require__) => { 11143 11144var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 11145 11146/* 11147 _ _ _ _ 11148 ___| (_) ___| | __ (_)___ 11149/ __| | |/ __| |/ / | / __| 11150\__ \ | | (__| < _ | \__ \ 11151|___/_|_|\___|_|\_(_)/ |___/ 11152 |__/ 11153 11154 Version: 1.9.0 11155 Author: Ken Wheeler 11156 Website: http://kenwheeler.github.io 11157 Docs: http://kenwheeler.github.io/slick 11158 Repo: http://github.com/kenwheeler/slick 11159 Issues: http://github.com/kenwheeler/slick/issues 11160 11161 */ 11162(function (i) { 11163 "use strict"; 11164 11165 true ? !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(4540)], __WEBPACK_AMD_DEFINE_FACTORY__ = (i), 11166 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 11167 (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
vendor: 5,636 bytes, lines 11168-11293
11168 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : 0; 11169})(function (i) { 11170 "use strict"; 11171 11172 var e = window.Slick || {}; 11173 e = function () { 11174 function e(e, o) { 11175 var s, 11176 n = this; 11177 n.defaults = { 11178 accessibility: !0, 11179 adaptiveHeight: !1, 11180 appendArrows: i(e), 11181 appendDots: i(e), 11182 arrows: !0, 11183 asNavFor: null, 11184 prevArrow: "<button class=\"slick-prev\" aria-label=\"Previous\" type=\"button\">Previous</button>", 11185 nextArrow: "<button class=\"slick-next\" aria-label=\"Next\" type=\"button\">Next</button>", 11186 autoplay: !1, 11187 autoplaySpeed: 3e3, 11188 centerMode: !1, 11189 centerPadding: "50px", 11190 cssEase: "ease", 11191 customPaging: function customPaging(e, t) { 11192 return i("<button type=\"button\" />").text(t + 1); 11193 }, 11194 dots: !1, 11195 dotsClass: "slick-dots", 11196 draggable: !0, 11197 easing: "linear", 11198 edgeFriction: .35, 11199 fade: !1, 11200 focusOnSelect: !1, 11201 focusOnChange: !1, 11202 infinite: !0, 11203 initialSlide: 0, 11204 lazyLoad: "ondemand", 11205 mobileFirst: !1, 11206 pauseOnHover: !0, 11207 pauseOnFocus: !0, 11208 pauseOnDotsHover: !1, 11209 respondTo: "window", 11210 responsive: null, 11211 rows: 1, 11212 rtl: !1, 11213 slide: "", 11214 slidesPerRow: 1, 11215 slidesToShow: 1, 11216 slidesToScroll: 1, 11217 speed: 1000, 11218 swipe: !0, 11219 swipeToSlide: !1, 11220 touchMove: !0, 11221 touchThreshold: 5, 11222 useCSS: !0, 11223 useTransform: !0, 11224 variableWidth: !1, 11225 vertical: !1, 11226 verticalSwiping: !1, 11227 waitForAnimate: !0, 11228 zIndex: 1e3 11229 }, n.initials = { 11230 animating: !1, 11231 dragging: !1, 11232 autoPlayTimer: null, 11233 currentDirection: 0, 11234 currentLeft: null, 11235 currentSlide: 0, 11236 direction: 1, 11237 $dots: null, 11238 listWidth: null, 11239 listHeight: null, 11240 loadIndex: 0, 11241 $nextArrow: null, 11242 $prevArrow: null, 11243 scrolling: !1, 11244 slideCount: null, 11245 slideWidth: null, 11246 $slideTrack: null, 11247 $slides: null, 11248 sliding: !1, 11249 slideOffset: 0, 11250 swipeLeft: null, 11251 swiping: !1, 11252 $list: null, 11253 touchObject: {}, 11254 transformsEnabled: !1, 11255 unslicked: !1 11256 }, i.extend(n, n.initials), n.activeBreakpoint = null, n.animType = null, n.animProp = null, n.breakpoints = [], n.breakpointSettings = [], n.cssTransitions = !1, n.focussed = !1, n.interrupted = !1, n.hidden = "hidden", n.paused = !0, n.positionProp = null, n.respondTo = null, n.rowCount = 1, n.shouldClick = !0, n.$slider = i(e), n.$slidesCache = null, n.transformType = null, n.transitionType = null, n.visibilityChange = "visibilitychange", n.windowWidth = 0, n.windowTimer = null, s = i(e).data("slick") || {}, n.options = i.extend({}, n.defaults, o, s), n.currentSlide = n.options.initialSlide, n.originalSettings = n.options, "undefined" != typeof document.mozHidden ? (n.hidden = "mozHidden", n.visibilityChange = "mozvisibilitychange") : "undefined" != typeof document.webkitHidden && (n.hidden = "webkitHidden", n.visibilityChange = "webkitvisibilitychange"), n.autoPlay = i.proxy(n.autoPlay, n), n.autoPlayClear = i.proxy(n.autoPlayClear, n), n.autoPlayIterator = i.proxy(n.autoPlayIterator, n), n.changeSlide = i.proxy(n.changeSlide, n), n.clickHandler = i.proxy(n.clickHandler, n), n.selectHandler = i.proxy(n.selectHandler, n), n.setPosition = i.proxy(n.setPosition, n), n.swipeHandler = i.proxy(n.swipeHandler, n), n.dragHandler = i.proxy(n.dragHandler, n), n.keyHandler = i.proxy(n.keyHandler, n), n.instanceUid = t++, n.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/, n.registerBreakpoints(), n.init(!0); 11257 } 11258 11259 var t = 0; 11260 return e; 11261 }(), e.prototype.activateADA = function () { 11262 var i = this; 11263 i.$slideTrack.find(".slick-active").attr({ 11264 "aria-hidden": "false" 11265 }).find("a, input, button, select").attr({ 11266 tabindex: "0" 11267 }); 11268 }, e.prototype.addSlide = e.prototype.slickAdd = function (e, t, o) { 11269 var s = this; 11270 if ("boolean" == typeof t) o = t, t = null;else if (t < 0 || t >= s.slideCount) return !1; 11271 s.unload(), "number" == typeof t ? 0 === t && 0 === s.$slides.length ? i(e).appendTo(s.$slideTrack) : o ? i(e).insertBefore(s.$slides.eq(t)) : i(e).insertAfter(s.$slides.eq(t)) : o === !0 ? i(e).prependTo(s.$slideTrack) : i(e).appendTo(s.$slideTrack), s.$slides = s.$slideTrack.children(this.options.slide), s.$slideTrack.children(this.options.slide).detach(), s.$slideTrack.append(s.$slides), s.$slides.each(function (e, t) { 11272 i(t).attr("data-slick-index", e); 11273 }), s.$slidesCache = s.$slides, s.reinit(); 11274 }, e.prototype.animateHeight = function () { 11275 var i = this; 11276 11277 if (1 === i.options.slidesToShow && i.options.adaptiveHeight === !0 && i.options.vertical === !1) { 11278 var e = i.$slides.eq(i.currentSlide).outerHeight(!0); 11279 i.$list.animate({ 11280 height: e 11281 }, i.options.speed); 11282 } 11283 }, e.prototype.animateSlide = function (e, t) { 11284 var o = {}, 11285 s = this; 11286 s.animateHeight(), s.options.rtl === !0 && s.options.vertical === !1 && (e = -e), s.transformsEnabled === !1 ? s.options.vertical === !1 ? s.$slideTrack.animate({ 11287 left: e 11288 }, s.options.speed, s.options.easing, t) : s.$slideTrack.animate({ 11289 top: e 11290 }, s.options.speed, s.options.easing, t) : s.cssTransitions === !1 ? (s.options.rtl === !0 && (s.currentLeft = -s.currentLeft), i({ 11291 animStart: s.currentLeft 11292 }).animate({ 11293 animStart: e
11294 }, { 11295 duration: s.options.speed, 11296 easing: s.options.easing, 11297 step: function step(i) { 11298 i = Math.ceil(i), s.options.vertical === !1 ? (o[s.animType] = "translate(" + i + "px, 0px)", s.$slideTrack.css(o)) : (o[s.animType] = "translate(0px," + i + "px)", s.$slideTrack.css(o)); 11299 }, 11300 complete: function complete() { 11301 t && t.call(); 11302 } 11303 })) : (s.applyTransition(), e = Math.ceil(e), s.options.vertical === !1 ? o[s.animType] = "translate3d(" + e + "px, 0px, 0px)" : o[s.animType] = "translate3d(0px," + e + "px, 0px)", s.$slideTrack.css(o), t && setTimeout(function () { 11304 s.disableTransition(), t.call(); 11305 }, s.options.speed)); 11306 }, e.prototype.getNavTarget = function () { 11307 var e = this, 11308 t = e.options.asNavFor; 11309 return t && null !== t && (t = i(t).not(e.$slider)), t; 11310 }, e.prototype.asNavFor = function (e) { 11311 var t = this, 11312 o = t.getNavTarget(); 11313 null !== o && "object" == _typeof(o) && o.each(function () { 11314 var t = i(this).slick("getSlick"); 11315 t.unslicked || t.slideHandler(e, !0); 11316 }); 11317 }, e.prototype.applyTransition = function (i) { 11318 var e = this, 11319 t = {}; 11320 e.options.fade === !1 ? t[e.transitionType] = e.transformType + " " + e.options.speed + "ms " + e.options.cssEase : t[e.transitionType] = "opacity " + e.options.speed + "ms " + e.options.cssEase, e.options.fade === !1 ? e.$slideTrack.css(t) : e.$slides.eq(i).css(t); 11321 }, e.prototype.autoPlay = function () { 11322 var i = this; 11323 i.autoPlayClear(), i.slideCount > i.options.slidesToShow && (i.autoPlayTimer = setInterval(i.autoPlayIterator, i.options.autoplaySpeed)); 11324 }, e.prototype.autoPlayClear = function () { 11325 var i = this; 11326 i.autoPlayTimer && clearInterval(i.autoPlayTimer); 11327 }, e.prototype.autoPlayIterator = function () { 11328 var i = this, 11329 e = i.currentSlide + i.options.slidesToScroll; 11330 i.paused || i.interrupted || i.focussed || (i.options.infinite === !1 && (1 === i.direction && i.currentSlide + 1 === i.slideCount - 1 ? i.direction = 0 : 0 === i.direction && (e = i.currentSlide - i.options.slidesToScroll, i.currentSlide - 1 === 0 && (i.direction = 1))), i.slideHandler(e)); 11331 }, e.prototype.buildArrows = function () { 11332 var e = this; 11333 e.options.arrows === !0 && (e.$prevArrow = i(e.options.prevArrow).addClass("slick-arrow"), e.$nextArrow = i(e.options.nextArrow).addClass("slick-arrow"), e.slideCount > e.options.slidesToShow ? (e.$prevArrow.removeClass("slick-hidden").removeAttr("aria-hidden tabindex"), e.$nextArrow.removeClass("slick-hidden").removeAttr("aria-hidden tabindex"), e.htmlExpr.test(e.options.prevArrow) && e.$prevArrow.prependTo(e.options.appendArrows), e.htmlExpr.test(e.options.nextArrow) && e.$nextArrow.appendTo(e.options.appendArrows), e.options.infinite !== !0 && e.$prevArrow.addClass("slick-disabled").attr("aria-disabled", "true")) : e.$prevArrow.add(e.$nextArrow).addClass("slick-hidden").attr({ 11334 "aria-disabled": "true", 11335 tabindex: "-1" 11336 })); 11337 }, e.prototype.buildDots = function () { 11338 var e, 11339 t, 11340 o = this; 11341 11342 if (o.options.dots === !0 && o.slideCount > o.options.slidesToShow) { 11343 for (o.$slider.addClass("slick-dotted"), t = i("<ul />").addClass(o.options.dotsClass), e = 0; e <= o.getDotCount(); e += 1) { 11344 t.append(i("<li />").append(o.options.customPaging.call(this, o, e))); 11345 } 11346 11347 o.$dots = t.appendTo(o.options.appendDots), o.$dots.find("li").first().addClass("slick-active"); 11348 } 11349 }, e.prototype.buildOut = function () { 11350 var e = this; 11351 e.$slides = e.$slider.children(e.options.slide + ":not(.slick-cloned)").addClass("slick-slide"), e.slideCount = e.$slides.length, e.$slides.each(function (e, t) { 11352 i(t).attr("data-slick-index", e).data("originalStyling", i(t).attr("style") || ""); 11353 }), e.$slider.addClass("slick-slider"), e.$slideTrack = 0 === e.slideCount ? i("<div class=\"slick-track\"/>").appendTo(e.$slider) : e.$slides.wrapAll("<div class=\"slick-track\"/>").parent(), e.$list = e.$slideTrack.wrap("<div class=\"slick-list\"/>").parent(), e.$slideTrack.css("opacity", 0), e.options.centerMode !== !0 && e.options.swipeToSlide !== !0 || (e.options.slidesToScroll = 1), i("img[data-lazy]", e.$slider).not("[src]").addClass("slick-loading"), e.setupInfinite(), e.buildArrows(), e.buildDots(), e.updateDots(), e.setSlideClasses("number" == typeof e.currentSlide ? e.currentSlide : 0), e.options.draggable === !0 && e.$list.addClass("draggable"); 11354 }, e.prototype.buildRows = function () { 11355 var i, 11356 e, 11357 t, 11358 o, 11359 s, 11360 n, 11361 r, 11362 l = this; 11363 11364 if (o = document.createDocumentFragment(), n = l.$slider.children(), l.options.rows > 0) { 11365 for (r = l.options.slidesPerRow * l.options.rows, s = Math.ceil(n.length / r), i = 0; i < s; i++) { 11366 var d = document.createElement("div"); 11367 11368 for (e = 0; e < l.options.rows; e++) { 11369 var a = document.createElement("div"); 11370 11371 for (t = 0; t < l.options.slidesPerRow; t++) { 11372 var c = i * r + (e * l.options.slidesPerRow + t); 11373 n.get(c) && a.appendChild(n.get(c)); 11374 } 11375 11376 d.appendChild(a); 11377 } 11378 11379 o.appendChild(d); 11380 } 11381 11382 l.$slider.empty().append(o), l.$slider.children().children().children().css({ 11383 width: 100 / l.options.slidesPerRow + "%", 11384 display: "inline-block" 11385 }); 11386 } 11387 }, e.prototype.checkResponsive = function (e, t) { 11388 var o, 11389 s, 11390 n, 11391 r = this, 11392 l = !1, 11393 d = r.$slider.width(), 11394 a = window.innerWidth || i(window).width(); 11395 11396 if ("window" === r.respondTo ? n = a : "slider" === r.respondTo ? n = d : "min" === r.respondTo && (n = Math.min(a, d)), r.options.responsive && r.options.responsive.length && null !== r.options.responsive) { 11397 s = null; 11398 11399 for (o in r.breakpoints) { 11400 r.breakpoints.hasOwnProperty(o) && (r.originalSettings.mobileFirst === !1 ? n < r.breakpoints[o] && (s = r.breakpoints[o]) : n > r.breakpoints[o] && (s = r.breakpoints[o])); 11401 } 11402 11403 null !== s ? null !== r.activeBreakpoint ? (s !== r.activeBreakpoint || t) && (r.activeBreakpoint = s, "unslick" === r.breakpointSettings[s] ? r.unslick(s) : (r.o
vendor: 2,865 bytes, lines 11403-11444
11403ptions = i.extend({}, r.originalSettings, r.breakpointSettings[s]), e === !0 && (r.currentSlide = r.options.initialSlide), r.refresh(e)), l = s) : (r.activeBreakpoint = s, "unslick" === r.breakpointSettings[s] ? r.unslick(s) : (r.options = i.extend({}, r.originalSettings, r.breakpointSettings[s]), e === !0 && (r.currentSlide = r.options.initialSlide), r.refresh(e)), l = s) : null !== r.activeBreakpoint && (r.activeBreakpoint = null, r.options = r.originalSettings, e === !0 && (r.currentSlide = r.options.initialSlide), r.refresh(e), l = s), e || l === !1 || r.$slider.trigger("breakpoint", [r, l]); 11404 } 11405 }, e.prototype.changeSlide = function (e, t) { 11406 var o, 11407 s, 11408 n, 11409 r = this, 11410 l = i(e.currentTarget); 11411 11412 switch (l.is("a") && e.preventDefault(), l.is("li") || (l = l.closest("li")), n = r.slideCount % r.options.slidesToScroll !== 0, o = n ? 0 : (r.slideCount - r.currentSlide) % r.options.slidesToScroll, e.data.message) { 11413 case "previous": 11414 s = 0 === o ? r.options.slidesToScroll : r.options.slidesToShow - o, r.slideCount > r.options.slidesToShow && r.slideHandler(r.currentSlide - s, !1, t); 11415 break; 11416 11417 case "next": 11418 s = 0 === o ? r.options.slidesToScroll : o, r.slideCount > r.options.slidesToShow && r.slideHandler(r.currentSlide + s, !1, t); 11419 break; 11420 11421 case "index": 11422 var d = 0 === e.data.index ? 0 : e.data.index || l.index() * r.options.slidesToScroll; 11423 r.slideHandler(r.checkNavigable(d), !1, t), l.children().trigger("focus"); 11424 break; 11425 11426 default: 11427 return; 11428 } 11429 }, e.prototype.checkNavigable = function (i) { 11430 var e, 11431 t, 11432 o = this; 11433 if (e = o.getNavigableIndexes(), t = 0, i > e[e.length - 1]) i = e[e.length - 1];else for (var s in e) { 11434 if (i < e[s]) { 11435 i = t; 11436 break; 11437 } 11438 11439 t = e[s]; 11440 } 11441 return i; 11442 }, e.prototype.cleanUpEvents = function () { 11443 var e = this; 11444 e.options.dots && null !== e.$dots && (i("li", e.$dots).off("click.slick", e.changeSlide).off("mouseenter.slick", i.proxy(e.interrupt, e, !0)).off("mouseleave.slick", i.proxy(e.interrupt, e, !1)), e.options.accessibility === !0 && e.$dots.off("keydown.slick", e.keyHandler)), e.$slider.off("focus.slick blur.slick"), e.options.arrows === !0 && e.slideCount > e.options.slidesToShow && (e.$prevArrow && e.$prevArrow.off("click.slick", e.changeSlide), e.$nextArrow && e.$nextArrow.off("click.slick", e.changeSlide), e.options.accessibility === !0 && (e.$prevArrow && e.$prevArrow.off("keydown.slick", e.keyHandler), e.$nextArrow && e.$nextArrow.off("keydown.slick", e.keyHandler))), e.$list.off("touchstart.slick mousedown.slick", e.swipeHandler), e.$list.off("touchmove.slick mousemove.slick", e.swipeHandler), e.$list.off("touchend.slick mouseup.slick", e.swipeHandler), e.$list.off("touchcancel.slick mouseleave.
11444slick", e.swipeHandler), e.$list.off("click.slick", e.clickHandler), i(document).off(e.visibilityChange, e.visibility), e.cleanUpSlideEvents(), e.options.accessibility === !0 && e.$list.off("keydown.slick", e.keyHandler), e.options.focusOnSelect === !0 && i(e.$slideTrack).children().off("click.slick", e.selectHandler), i(window).off("orientationchange.slick.slick-" + e.instanceUid, e.orientationChange), i(window).off("resize.slick.slick-" + e.instanceUid, e.resize), i("[draggable!=true]", e.$slideTrack).off("dragstart", e.preventDefault), i(window).off("load.slick.slick-" + e.instanceUid, e.setPosition); 11445 }, e.prototype.cleanUpSlideEvents = function () { 11446 var e = this; 11447 e.$list.off("mouseenter.slick", i.proxy(e.interrupt, e, !0)), e.$list.off("mouseleave.slick", i.proxy(e.interrupt, e, !1)); 11448 }, e.prototype.cleanUpRows = function () { 11449 var i, 11450 e = this; 11451 e.options.rows > 0 && (i = e.$slides.children().children(), i.removeAttr("style"), e.$slider.empty().append(i)); 11452 }, e.prototype.clickHandler = function (i) { 11453 var e = this; 11454 e.shouldClick === !1 && (i.stopImmediatePropagation(), i.stopPropagation(), i.preventDefault()); 11455 }, e.prototype.destroy = function (e) { 11456 var t = this; 11457 t.autoPlayClear(), t.touchObject = {}, t.cleanUpEvents(), i(".slick-cloned", t.$slider).detach(), t.$dots && t.$dots.remove(), t.$prevArrow && t.$prevArrow.length && (t.$prevArrow.removeClass("slick-disabled slick-arrow slick-hidden").removeAttr("aria-hidden aria-disabled tabindex").css("display", ""), t.htmlExpr.test(t.options.prevArrow) && t.$prevArrow.remove()), t.$nextArrow && t.$nextArrow.length && (t.$nextArrow.removeClass("slick-disabled slick-arrow slick-hidden").removeAttr("aria-hidden aria-disabled tabindex").css("display", ""), t.htmlExpr.test(t.options.nextArrow) && t.$nextArrow.remove()), t.$slides && (t.$slides.removeClass("slick-slide slick-active slick-center slick-visible slick-current").removeAttr("aria-hidden").removeAttr("data-slick-index").each(function () { 11458 i(this).attr("style", i(this).data("originalStyling")); 11459 }), t.$slideTrack.children(this.options.slide).detach(), t.$slideTrack.detach(), t.$list.detach(), t.$slider.append(t.$slides)), t.cleanUpRows(), t.$slider.removeClass("slick-slider"), t.$slider.removeClass("slick-initialized"), t.$slider.removeClass("slick-dotted"), t.unslicked = !0, e || t.$slider.trigger("destroy", [t]); 11460 }, e.prototype.disableTransition = function (i) { 11461 var e = this, 11462 t = {}; 11463 t[e.transitionType] = "", e.options.fade === !1 ? e.$slideTrack.css(t) : e.$slides.eq(i).css(t); 11464 }, e.prototype.fadeSlide = function (i, e) { 11465 var t = this; 11466 t.cssTransitions === !1 ? (t.$slides.eq(i).css({ 11467 zIndex: t.options.zIndex 11468 }), t.$slides.eq(i).animate({ 11469 opacity: 1 11470 }, t.options.speed, t.options.easing, e)) : (t.applyTransition(i), t.$slides.eq(i).css({ 11471 opacity: 1, 11472 zIndex: t.options.zIndex 11473 }), e && setTimeout(function () { 11474 t.disableTransition(i), e.call(); 11475 }, t.options.speed)); 11476 }, e.prototype.fadeSlideOut = function (i) { 11477 var e = this; 11478 e.cssTransitions === !1 ? e.$slides.eq(i).animate({ 11479 opacity: 0, 11480 zIndex: e.options.zIndex - 2 11481 }, e.options.speed, e.options.easing) : (e.applyTransition(i), e.$slides.eq(i).css({ 11482 opacity: 0, 11483 zIndex: e.options.zIndex - 2 11484 })); 11485 }, e.prototype.filterSlides = e.prototype.slickFilter = function (i) { 11486 var e = this; 11487 null !== i && (e.$slidesCache = e.$slides, e.unload(), e.$slideTrack.children(this.options.slide).detach(), e.$slidesCache.filter(i).appendTo(e.$slideTrack), e.reinit()); 11488 }, e.prototype.focusHandler = function () { 11489 var e = this; 11490 e.$slider.off("focus.slick blur.slick").on("focus.slick", "*", function (t) { 11491 var o = i(this); 11492 setTimeout(function () { 11493 e.options.pauseOnFocus && o.is(":focus") && (e.focussed = !0, e.autoPlay()); 11494 }, 0); 11495 }).on("blur.slick", "*", function (t) { 11496 i(this); 11497 e.options.pauseOnFocus && (e.focussed = !1, e.autoPlay()); 11498 }); 11499 }, e.prototype.getCurrent = e.prototype.slickCurrentSlide = function () { 11500 var i = this; 11501 return i.currentSlide; 11502 }, e.prototype.getDotCount = function () { 11503 var i = this, 11504 e = 0, 11505 t = 0, 11506 o = 0; 11507 if (i.options.infinite === !0) { 11508 if (i.slideCount <= i.options.slidesToShow) ++o;else for (; e < i.slideCount;) { 11509 ++o, e = t + i.options.slidesToScroll, t += i.options.slidesToScroll <= i.options.slidesToShow ? i.options.slidesToScroll : i.options.slidesToShow; 11510 } 11511 } else if (i.options.centerMode === !0) o = i.slideCount;else if (i.options.asNavFor) for (; e < i.slideCount;) { 11512 ++o, e = t + i.options.slidesToScroll, t += i.options.slidesToScroll <= i.options.slidesToShow ? i.options.slidesToScroll : i.options.slidesToShow; 11513 }
vendor: 2,994 bytes, lines 11513-11533
11513 else o = 1 + Math.ceil((i.slideCount - i.options.slidesToShow) / i.options.slidesToScroll); 11514 return o - 1; 11515 }, e.prototype.getLeft = function (i) { 11516 var e, 11517 t, 11518 o, 11519 s, 11520 n = this, 11521 r = 0; 11522 return n.slideOffset = 0, t = n.$slides.first().outerHeight(!0), n.options.infinite === !0 ? (n.slideCount > n.options.slidesToShow && (n.slideOffset = n.slideWidth * n.options.slidesToShow * -1, s = -1, n.options.vertical === !0 && n.options.centerMode === !0 && (2 === n.options.slidesToShow ? s = -1.5 : 1 === n.options.slidesToShow && (s = -2)), r = t * n.options.slidesToShow * s), n.slideCount % n.options.slidesToScroll !== 0 && i + n.options.slidesToScroll > n.slideCount && n.slideCount > n.options.slidesToShow && (i > n.slideCount ? (n.slideOffset = (n.options.slidesToShow - (i - n.slideCount)) * n.slideWidth * -1, r = (n.options.slidesToShow - (i - n.slideCount)) * t * -1) : (n.slideOffset = n.slideCount % n.options.slidesToScroll * n.slideWidth * -1, r = n.slideCount % n.options.slidesToScroll * t * -1))) : i + n.options.slidesToShow > n.slideCount && (n.slideOffset = (i + n.options.slidesToShow - n.slideCount) * n.slideWidth, r = (i + n.options.slidesToShow - n.slideCount) * t), n.slideCount <= n.options.slidesToShow && (n.slideOffset = 0, r = 0), n.options.centerMode === !0 && n.slideCount <= n.options.slidesToShow ? n.slideOffset = n.slideWidth * Math.floor(n.options.slidesToShow) / 2 - n.slideWidth * n.slideCount / 2 : n.options.centerMode === !0 && n.options.infinite === !0 ? n.slideOffset += n.slideWidth * Math.floor(n.options.slidesToShow / 2) - n.slideWidth : n.options.centerMode === !0 && (n.slideOffset = 0, n.slideOffset += n.slideWidth * Math.floor(n.options.slidesToShow / 2)), e = n.options.vertical === !1 ? i * n.slideWidth * -1 + n.slideOffset : i * t * -1 + r, n.options.variableWidth === !0 && (o = n.slideCount <= n.options.slidesToShow || n.options.infinite === !1 ? n.$slideTrack.children(".slick-slide").eq(i) : n.$slideTrack.children(".slick-slide").eq(i + n.options.slidesToShow), e = n.options.rtl === !0 ? o[0] ? (n.$slideTrack.width() - o[0].offsetLeft - o.width()) * -1 : 0 : o[0] ? o[0].offsetLeft * -1 : 0, n.options.centerMode === !0 && (o = n.slideCount <= n.options.slidesToShow || n.options.infinite === !1 ? n.$slideTrack.children(".slick-slide").eq(i) : n.$slideTrack.children(".slick-slide").eq(i + n.options.slidesToShow + 1), e = n.options.rtl === !0 ? o[0] ? (n.$slideTrack.width() - o[0].offsetLeft - o.width()) * -1 : 0 : o[0] ? o[0].offsetLeft * -1 : 0, e += (n.$list.width() - o.outerWidth()) / 2)), e; 11523 }, e.prototype.getOption = e.prototype.slickGetOption = function (i) { 11524 var e = this; 11525 return e.options[i]; 11526 }, e.prototype.getNavigableIndexes = function () { 11527 var i, 11528 e = this, 11529 t = 0, 11530 o = 0, 11531 s = []; 11532 11533 for (e.options.infinite === !1 ? i = e.slideCount : (t = e.options.slidesToScroll * -1, o = e.options.slidesToScroll * -1, i = 2 * e.
11533slideCount); t < i;) { 11534 s.push(t), t = o + e.options.slidesToScroll, o += e.options.slidesToScroll <= e.options.slidesToShow ? e.options.slidesToScroll : e.options.slidesToShow; 11535 } 11536 11537 return s; 11538 }, e.prototype.getSlick = function () { 11539 return this; 11540 }, e.prototype.getSlideCount = function () { 11541 var e, 11542 t, 11543 o, 11544 s, 11545 n = this; 11546 return s = n.options.centerMode === !0 ? Math.floor(n.$list.width() / 2) : 0, o = n.swipeLeft * -1 + s, n.options.swipeToSlide === !0 ? (n.$slideTrack.find(".slick-slide").each(function (e, s) { 11547 var r, l, d; 11548 if (r = i(s).outerWidth(), l = s.offsetLeft, n.options.centerMode !== !0 && (l += r / 2), d = l + r, o < d) return t = s, !1; 11549 }), e = Math.abs(i(t).attr("data-slick-index") - n.currentSlide) || 1) : n.options.slidesToScroll; 11550 }, e.prototype.goTo = e.prototype.slickGoTo = function (i, e) { 11551 var t = this; 11552 t.changeSlide({ 11553 data: { 11554 message: "index", 11555 index: parseInt(i) 11556 } 11557 }, e); 11558 }, e.prototype.init = function (e) { 11559 var t = this; 11560 i(t.$slider).hasClass("slick-initialized") || (i(t.$slider).addClass("slick-initialized"), t.buildRows(), t.buildOut(), t.setProps(), t.startLoad(), t.loadSlider(), t.initializeEvents(), t.updateArrows(), t.updateDots(), t.checkResponsive(!0), t.focusHandler()), e && t.$slider.trigger("init", [t]), t.options.accessibility === !0 && t.initADA(), t.options.autoplay && (t.paused = !1, t.autoPlay()); 11561 }, e.prototype.initADA = function () { 11562 var e = this, 11563 t = Math.ceil(e.slideCount / e.options.slidesToShow), 11564 o = e.getNavigableIndexes().filter(function (i) { 11565 return i >= 0 && i < e.slideCount; 11566 }); 11567 e.$slides.add(e.$slideTrack.find(".slick-cloned")).attr({ 11568 "aria-hidden": "true", 11569 tabindex: "-1" 11570 }).find("a, input, button, select").attr({ 11571 tabindex: "-1" 11572 }), null !== e.$dots && (e.$slides.not(e.$slideTrack.find(".slick-cloned")).each(function (t) { 11573 var s = o.indexOf(t); 11574 11575 if (i(this).attr({ 11576 role: "tabpanel", 11577 id: "slick-slide" + e.instanceUid + t, 11578 tabindex: -1 11579 }), s !== -1) { 11580 var n = "slick-slide-control" + e.instanceUid + s; 11581 i("#" + n).length && i(this).attr({ 11582 "aria-describedby": n 11583 }); 11584 } 11585 }), e.$dots.attr("role", "tablist").find("li").each(function (s) { 11586 var n = o[s]; 11587 i(this).attr({ 11588 role: "presentation" 11589 }), i(this).find("button").first().attr({ 11590 role: "tab", 11591 id: "slick-slide-control" + e.instanceUid + s, 11592 "aria-controls": "slick-slide" + e.instanceUid + n, 11593 "aria-label": s + 1 + " of " + t, 11594 "aria-selected": null, 11595 tabindex: "-1" 11596 }); 11597 }).eq(e.currentSlide).find("button").attr({ 11598 "aria-selected": "true", 11599 tabindex: "0" 11600 }).end()); 11601 11602 for (var s = e.currentSlide, n = s + e.options.slidesToShow; s < n; s++) { 11603 e.options.focusOnChange ? e.$slides.eq(s).attr({ 11604 tabindex: "0" 11605 }) : e.$slides.eq(s).removeAttr("tabindex"); 11606 } 11607 11608 e.activateADA(); 11609 }, e.prototype.initArrowEvents = function () { 11610 var i = this; 11611 i.options.arrows === !0 && i.slideCount > i.options.slidesToShow && (i.$prevArrow.off("click.slick").on("click.slick", { 11612 message: "previous" 11613 }, i.changeSlide), i.$nextArrow.off("click.slick").on("click.slick", { 11614 message: "next" 11615 }, i.changeSlide), i.options.accessibility === !0 && (i.$prevArrow.on("keydown.slick", i.keyHandler), i.$nextArrow.on("keydown.slick", i.keyHandler))); 11616 }, e.prototype.initDotEvents = function () { 11617 var e = this; 11618 e.options.dots === !0 && e.slideCount > e.options.slidesToShow && (i("li", e.$dots).on("click.slick", { 11619 message: "index" 11620 }, e.changeSlide), e.options.accessibility === !0 && e.$dots.on("keydown.slick", e.keyHandler)), e.options.dots === !0 && e.options.pauseOnDotsHover === !0 && e.slideCount > e.options.slidesToShow && i("li", e.$dots).on("mouseenter.slick", i.proxy(e.interrupt, e, !0)).on("mouseleave.slick", i.proxy(e.interrupt, e, !1)); 11621 }, e.prototype.initSlideEvents = function () { 11622 var e = this; 11623 e.options.pauseOnHover && (e.$list.on("mouseenter.slick", i.proxy(e.interrupt, e, !0)), e.$list.on("mouseleave.
11623slick", i.proxy(e.interrupt, e, !1))); 11624 }, e.prototype.initializeEvents = function () { 11625 var e = this; 11626 e.initArrowEvents(), e.initDotEvents(), e.initSlideEvents(), e.$list.on("touchstart.slick mousedown.slick", { 11627 action: "start" 11628 }, e.swipeHandler), e.$list.on("touchmove.slick mousemove.slick", { 11629 action: "move" 11630 }, e.swipeHandler), e.$list.on("touchend.slick mouseup.slick", { 11631 action: "end" 11632 }, e.swipeHandler), e.$list.on("touchcancel.slick mouseleave.slick", { 11633 action: "end" 11634 }, e.swipeHandler), e.$list.on("click.slick", e.clickHandler), i(document).on(e.visibilityChange, i.proxy(e.visibility, e)), e.options.accessibility === !0 && e.$list.on("keydown.slick", e.keyHandler), e.options.focusOnSelect === !0 && i(e.$slideTrack).children().on("click.slick", e.selectHandler), i(window).on("orientationchange.slick.slick-" + e.instanceUid, i.proxy(e.orientationChange, e)), i(window).on("resize.slick.slick-" + e.instanceUid, i.proxy(e.resize, e)), i("[draggable!=true]", e.$slideTrack).on("dragstart", e.preventDefault), i(window).on("load.slick.slick-" + e.instanceUid, e.setPosition), i(e.setPosition); 11635 }, e.prototype.initUI = function () { 11636 var i = this; 11637 i.options.arrows === !0 && i.slideCount > i.options.slidesToShow && (i.$prevArrow.show(), i.$nextArrow.show()), i.options.dots === !0 && i.slideCount > i.options.slidesToShow && i.$dots.show(); 11638 }, e.prototype.keyHandler = function (i) { 11639 var e = this; 11640 i.target.tagName.match("TEXTAREA|INPUT|SELECT") || (37 === i.keyCode && e.options.accessibility === !0 ? e.changeSlide({ 11641 data: { 11642 message: e.options.rtl === !0 ? "next" : "previous" 11643 } 11644 }) : 39 === i.keyCode && e.options.accessibility === !0 && e.changeSlide({ 11645 data: { 11646 message: e.options.rtl === !0 ? "previous" : "next" 11647 } 11648 })); 11649 }, e.prototype.lazyLoad = function () { 11650 function e(e) { 11651 i("img[data-lazy]", e).each(function () { 11652 var e = i(this), 11653 t = i(this).attr("data-lazy"), 11654 o = i(this).attr("data-srcset"), 11655 s = i(this).attr("data-sizes") || r.$slider.attr("data-sizes"), 11656 n = document.createElement("img"); 11657 n.onload = function () { 11658 e.animate({ 11659 opacity: 0 11660 }, 100, function () { 11661 o && (e.attr("srcset", o), s && e.attr("sizes", s)), e.attr("src", t).animate({ 11662 opacity: 1 11663 }, 200, function () { 11664 e.removeAttr("data-lazy data-srcset data-sizes").removeClass("slick-loading"); 11665 }), r.$slider.trigger("lazyLoaded", [r, e, t]); 11666 }); 11667 }, n.onerror = function () { 11668 e.removeAttr("data-lazy").removeClass("slick-loading").addClass("slick-lazyload-error"), r.$slider.trigger("lazyLoadError", [r, e, t]); 11669 }, n.src = t; 11670 }); 11671 } 11672 11673 var t, 11674 o, 11675 s, 11676 n, 11677 r = this; 11678 if (r.options.centerMode === !0 ? r.options.infinite === !0 ? (s = r.currentSlide + (r.options.slidesToShow / 2 + 1), n = s + r.options.slidesToShow + 2) : (s = Math.max(0, r.currentSlide - (r.options.slidesToShow / 2 + 1)), n = 2 + (r.options.slidesToShow / 2 + 1) + r.currentSlide) : (s = r.options.infinite ? r.options.slidesToShow + r.currentSlide : r.currentSlide, n = Math.ceil(s + r.options.slidesToShow), r.options.fade === !0 && (s > 0 && s--, n <= r.slideCount && n++)), t = r.$slider.find(".slick-slide").slice(s, n), "anticipated" === r.options.lazyLoad) for (var l = s - 1, d = n, a = r.$slider.find(".slick-slide"), c = 0; c < r.options.slidesToScroll; c++) { 11679 l < 0 && (l = r.slideCount - 1), t = t.add(a.eq(l)), t = t.add(a.eq(d)), l--, d++; 11680 } 11681 e(t), r.slideCount <= r.options.slidesToShow ? (o = r.$slider.find(".slick-slide"), e(o)) : r.currentSlide >= r.slideCount - r.options.slidesToShow ? (o = r.$slider.find(".slick-cloned").slice(0, r.options.slidesToShow), e(o)) : 0 === r.currentSlide && (o = r.$slider.find(".slick-cloned").slice(r.options.slidesToShow * -1), e(o)); 11682 }, e.prototype.loadSlider = function () { 11683 var i = this; 11684 i.setPosition(), i.$slideTrack.css({ 11685 opacity: 1 11686 }), i.$slider.removeClass("slick-loading"), i.initUI(), "progressive" === i.options.lazyLoad && i.progressiveLazyLoad(); 11687 }, e.prototype.next = e.prototype.slickNext = function () { 11688 var i = this; 11689 i.changeSlide({ 11690 data: { 11691 message: "next" 11692 } 11693 }); 11694 }, e.prototype.orientationChange = function () { 11695 var i = this; 11696 i.checkResponsive(), i.setPosition(); 11697 }, e.prototype.pause = e.prototype.slickPause = function () { 11698 var i = this; 11699 i.autoPlayClear(), i.paused = !0; 11700 }, e.prototype.play = e.prototype.slickPlay = function () { 11701 var i = this; 11702 i.autoPlay(), i.options.autoplay = !0, i.paused = !1, i.focussed = !1, i.interrupted = !1; 11703 }, e.prototype.postSlide = function (e) { 11704 var t = this; 11705 11706 if (!t.unslicked && (t.$slider.trigger("afterChange", [t, e]), t.animating = !1, t.slideCount > t.options.slidesToShow && t.setPosition(), t.swipeLeft = null, t.options.autoplay && t.autoPlay(), t.options.accessibility === !0 && (t.initADA(), t.options.focusOnChange))) { 11707 var o = i(t.$slides.get(t.currentSlide)); 11708 o.attr("tabindex", 0).focus(); 11709 } 11710 }, e.prototype.prev = e.prototype.slickPrev = function () { 11711 var i = this; 11712 i.changeSlide({ 11713 data: { 11714 message: "previous" 11715 } 11716 }); 11717 }, e.prototype.preventDefault = function (i) { 11718 i.preventDefault(); 11719 }, e.prototype.progressiveLazyLoad = function (e) { 11720 e = e || 1; 11721 var t, 11722 o, 11723 s, 11724 n, 11725 r, 11726 l = this, 11727 d = i("img[data-lazy]", l.$slider); 11728 d.length ? (t = d.first(), o = t.attr("data-lazy"), s = t.attr("data-srcset"), n = t.attr("data-sizes") || l.$slider.attr("data-sizes"), r = document.createElement("img"), r.onload = function () { 11729 s && (t.attr("srcset", s), n && t.attr("sizes", n)), t.attr("src", o).removeAttr("data-lazy data-srcset data-sizes").removeClass("slick-loading"), l.options.adaptiveHeight === !0 && l.setPosition(), l.$slider.trigger("lazyLoaded", [l, t, o]), l.progressiveLazyLoad(); 11730 }, r.onerror = function () { 11731 e < 3 ? setTimeout(function () { 11732 l.progressiveLazyLoad(e + 1); 11733 }, 500) : (t.removeAttr("data-lazy").removeClass("slick-loading").addClass("slick-lazyload-error"), l.$slider.trigger("lazyLoadError", [l, t, o]), l.progressiveLazyLoad()); 11734 }, r.src = o) : l.$slider.trigger("allImagesLoaded", [l]); 11735 }, e.prototype.refresh = function (e) { 11736 var t, 11737 o, 11738 s = this; 11739 o = s.slideCount - s.options.slidesToShow, !s.options.infinite && s.currentSlide > o && (s.currentSlide = o), s.slideCount <= s.options.slidesToShow && (s.currentSlide = 0), t = s.currentSlide, s.destroy(!0), i.extend(s, s.initials, { 11740 currentSlide: t 11741 }), s.init(), e || s.changeSlide({ 11742 data: { 11743 message: "index", 11744 index: t 11745 } 11746 }, !1); 11747 }, e.prototype.registerBreakpoints = function () { 11748 var e, 11749 t, 11750 o, 11751 s = this, 11752 n = s.options.responsive || null; 11753 11754 if ("array" === i.type(n) && n.length) { 11755 s.respondTo = s.options.respondTo || "window"; 11756 11757 for (e in n) { 11758 if (o = s.breakpoints.length - 1, n.hasOwnProperty(e)) { 11759 for (t = n[e].breakpoint; o >= 0;) { 11760 s.breakpoints[o] && s.breakpoints[o] === t && s.breakpoints.splice(o, 1), o--; 11761 } 11762 11763 s.breakpoints.push(t), s.breakpointSettings[t] = n[e].settings; 11764 } 11765 } 11766 11767 s.breakpoints.sort(function (i, e) { 11768 return s.options.mobileFirst ? i - e : e - i; 11769 }); 11770 } 11771 }, e.prototype.reinit = function () { 11772 var e = this; 11773 e.$slides = e.$slideTrack.children(e.options.slide).addClass("slick-slide"), e.slideCount = e.$slides.length, e.currentSlide >= e.slideCount && 0 !== e.currentSlide && (e.currentSlide = e.currentSlide - e.options.slidesToScroll), e.slideCount <= e.options.slidesToShow && (e.currentSlide = 0), e.registerBreakpoints(), e.setProps(), e.setupInfinite(), e.buildArrows(), e.updateArrows(), e.initArrowEvents(), e.buildDots(), e.updateDots(), e.initDotEvents(), e.cleanUpSlideEvents(), e.initSlideEvents(), e.checkResponsive(!1, !0), e.o
vendor: 16,851 bytes, lines 11773-11973
11773ptions.focusOnSelect === !0 && i(e.$slideTrack).children().on("click.slick", e.selectHandler), e.setSlideClasses("number" == typeof e.currentSlide ? e.currentSlide : 0), e.setPosition(), e.focusHandler(), e.paused = !e.options.autoplay, e.autoPlay(), e.$slider.trigger("reInit", [e]); 11774 }, e.prototype.resize = function () { 11775 var e = this; 11776 i(window).width() !== e.windowWidth && (clearTimeout(e.windowDelay), e.windowDelay = window.setTimeout(function () { 11777 e.windowWidth = i(window).width(), e.checkResponsive(), e.unslicked || e.setPosition(); 11778 }, 50)); 11779 }, e.prototype.removeSlide = e.prototype.slickRemove = function (i, e, t) { 11780 var o = this; 11781 return "boolean" == typeof i ? (e = i, i = e === !0 ? 0 : o.slideCount - 1) : i = e === !0 ? --i : i, !(o.slideCount < 1 || i < 0 || i > o.slideCount - 1) && (o.unload(), t === !0 ? o.$slideTrack.children().remove() : o.$slideTrack.children(this.options.slide).eq(i).remove(), o.$slides = o.$slideTrack.children(this.options.slide), o.$slideTrack.children(this.options.slide).detach(), o.$slideTrack.append(o.$slides), o.$slidesCache = o.$slides, void o.reinit()); 11782 }, e.prototype.setCSS = function (i) { 11783 var e, 11784 t, 11785 o = this, 11786 s = {}; 11787 o.options.rtl === !0 && (i = -i), e = "left" == o.positionProp ? Math.ceil(i) + "px" : "0px", t = "top" == o.positionProp ? Math.ceil(i) + "px" : "0px", s[o.positionProp] = i, o.transformsEnabled === !1 ? o.$slideTrack.css(s) : (s = {}, o.cssTransitions === !1 ? (s[o.animType] = "translate(" + e + ", " + t + ")", o.$slideTrack.css(s)) : (s[o.animType] = "translate3d(" + e + ", " + t + ", 0px)", o.$slideTrack.css(s))); 11788 }, e.prototype.setDimensions = function () { 11789 var i = this; 11790 i.options.vertical === !1 ? i.options.centerMode === !0 && i.$list.css({ 11791 padding: "0px " + i.options.centerPadding 11792 }) : (i.$list.height(i.$slides.first().outerHeight(!0) * i.options.slidesToShow), i.options.centerMode === !0 && i.$list.css({ 11793 padding: i.options.centerPadding + " 0px" 11794 })), i.listWidth = i.$list.width(), i.listHeight = i.$list.height(), i.options.vertical === !1 && i.options.variableWidth === !1 ? (i.slideWidth = Math.ceil(i.listWidth / i.options.slidesToShow), i.$slideTrack.width(Math.ceil(i.slideWidth * i.$slideTrack.children(".slick-slide").length))) : i.options.variableWidth === !0 ? i.$slideTrack.width(5e3 * i.slideCount) : (i.slideWidth = Math.ceil(i.listWidth), i.$slideTrack.height(Math.ceil(i.$slides.first().outerHeight(!0) * i.$slideTrack.children(".slick-slide").length))); 11795 var e = i.$slides.first().outerWidth(!0) - i.$slides.first().width(); 11796 i.options.variableWidth === !1 && i.$slideTrack.children(".slick-slide").width(i.slideWidth - e); 11797 }, e.prototype.setFade = function () { 11798 var e, 11799 t = this; 11800 t.$slides.each(function (o, s) { 11801 e = t.slideWidth * o * -1, t.options.rtl === !0 ? i(s).css({ 11802 position: "relative", 11803 right: e, 11804 top: 0, 11805 zIndex: t.options.zIndex - 2, 11806 opacity: 0 11807 }) : i(s).css({ 11808 position: "relative", 11809 left: e, 11810 top: 0, 11811 zIndex: t.options.zIndex - 2, 11812 opacity: 0 11813 }); 11814 }), t.$slides.eq(t.currentSlide).css({ 11815 zIndex: t.options.zIndex - 1, 11816 opacity: 1 11817 }); 11818 }, e.prototype.setHeight = function () { 11819 var i = this; 11820 11821 if (1 === i.options.slidesToShow && i.options.adaptiveHeight === !0 && i.options.vertical === !1) { 11822 var e = i.$slides.eq(i.currentSlide).outerHeight(!0); 11823 i.$list.css("height", e); 11824 } 11825 }, e.prototype.setOption = e.prototype.slickSetOption = function () { 11826 var e, 11827 t, 11828 o, 11829 s, 11830 n, 11831 r = this, 11832 l = !1; 11833 if ("object" === i.type(arguments[0]) ? (o = arguments[0], l = arguments[1], n = "multiple") : "string" === i.type(arguments[0]) && (o = arguments[0], s = arguments[1], l = arguments[2], "responsive" === arguments[0] && "array" === i.type(arguments[1]) ? n = "responsive" : "undefined" != typeof arguments[1] && (n = "single")), "single" === n) r.options[o] = s;else if ("multiple" === n) i.each(o, function (i, e) { 11834 r.options[i] = e; 11835 });else if ("responsive" === n) for (t in s) { 11836 if ("array" !== i.type(r.options.responsive)) r.options.responsive = [s[t]];else { 11837 for (e = r.options.responsive.length - 1; e >= 0;) { 11838 r.options.responsive[e].breakpoint === s[t].breakpoint && r.options.responsive.splice(e, 1), e--; 11839 } 11840 11841 r.options.responsive.push(s[t]); 11842 } 11843 } 11844 l && (r.unload(), r.reinit()); 11845 }, e.prototype.setPosition = function () { 11846 var i = this; 11847 i.setDimensions(), i.setHeight(), i.options.fade === !1 ? i.setCSS(i.getLeft(i.currentSlide)) : i.setFade(), i.$slider.trigger("setPosition", [i]); 11848 }, e.prototype.setProps = function () { 11849 var i = this, 11850 e = document.body.style; 11851 i.positionProp = i.options.vertical === !0 ? "top" : "left", "top" === i.positionProp ? i.$slider.addClass("slick-vertical") : i.$slider.removeClass("slick-vertical"), void 0 === e.WebkitTransition && void 0 === e.MozTransition && void 0 === e.msTransition || i.options.useCSS === !0 && (i.cssTransitions = !0), i.options.fade && ("number" == typeof i.options.zIndex ? i.options.zIndex < 3 && (i.options.zIndex = 3) : i.options.zIndex = i.defaults.zIndex), void 0 !== e.OTransform && (i.animType = "OTransform", i.transformType = "-o-transform", i.transitionType = "OTransition", void 0 === e.perspectiveProperty && void 0 === e.webkitPerspective && (i.animType = !1)), void 0 !== e.MozTransform && (i.animType = "MozTransform", i.transformType = "-moz-transform", i.transitionType = "MozTransition", void 0 === e.perspectiveProperty && void 0 === e.MozPerspective && (i.animType = !1)), void 0 !== e.webkitTransform && (i.animType = "webkitTransform", i.transformType = "-webkit-transform", i.transitionType = "webkitTransition", void 0 === e.perspectiveProperty && void 0 === e.webkitPerspective && (i.animType = !1)), void 0 !== e.msTransform && (i.animType = "msTransform", i.transformType = "-ms-transform", i.transitionType = "msTransition", void 0 === e.msTransform && (i.animType = !1)), void 0 !== e.transform && i.animType !== !1 && (i.animType = "transform", i.transformType = "transform", i.transitionType = "transition"), i.transformsEnabled = i.options.useTransform && null !== i.animType && i.animType !== !1; 11852 }, e.prototype.setSlideClasses = function (i) { 11853 var e, 11854 t, 11855 o, 11856 s, 11857 n = this; 11858 11859 if (t = n.$slider.find(".slick-slide").removeClass("slick-active slick-center slick-current").attr("aria-hidden", "true"), n.$slides.eq(i).addClass("slick-current"), n.options.centerMode === !0) { 11860 var r = n.options.slidesToShow % 2 === 0 ? 1 : 0; 11861 e = Math.floor(n.options.slidesToShow / 2), n.options.infinite === !0 && (i >= e && i <= n.slideCount - 1 - e ? n.$slides.slice(i - e + r, i + e + 1).addClass("slick-active").attr("aria-hidden", "false") : (o = n.options.slidesToShow + i, t.slice(o - e + 1 + r, o + e + 2).addClass("slick-active").attr("aria-hidden", "false")), 0 === i ? t.eq(t.length - 1 - n.options.slidesToShow).addClass("slick-center") : i === n.slideCount - 1 && t.eq(n.options.slidesToShow).addClass("slick-center")), n.$slides.eq(i).addClass("slick-center"); 11862 } else i >= 0 && i <= n.slideCount - n.options.slidesToShow ? n.$slides.slice(i, i + n.options.slidesToShow).addClass("slick-active").attr("aria-hidden", "false") : t.length <= n.options.slidesToShow ? t.addClass("slick-active").attr("aria-hidden", "false") : (s = n.slideCount % n.options.slidesToShow, o = n.options.infinite === !0 ? n.options.slidesToShow + i : i, n.options.slidesToShow == n.options.slidesToScroll && n.slideCount - i < n.options.slidesToShow ? t.slice(o - (n.options.slidesToShow - s), o + s).addClass("slick-active").attr("aria-hidden", "false") : t.slice(o, o + n.options.slidesToShow).addClass("slick-active").attr("aria-hidden", "false")); 11863 11864 "ondemand" !== n.options.lazyLoad && "anticipated" !== n.options.lazyLoad || n.lazyLoad(); 11865 }, e.prototype.setupInfinite = function () { 11866 var e, 11867 t, 11868 o, 11869 s = this; 11870 11871 if (s.options.fade === !0 && (s.options.centerMode = !1), s.options.infinite === !0 && s.options.fade === !1 && (t = null, s.slideCount > s.options.slidesToShow)) { 11872 for (o = s.options.centerMode === !0 ? s.options.slidesToShow + 1 : s.options.slidesToShow, e = s.slideCount; e > s.slideCount - o; e -= 1) { 11873 t = e - 1, i(s.$slides[t]).clone(!0).attr("id", "").attr("data-slick-index", t - s.slideCount).prependTo(s.$slideTrack).addClass("slick-cloned"); 11874 } 11875 11876 for (e = 0; e < o + s.slideCount; e += 1) { 11877 t = e, i(s.$slides[t]).clone(!0).attr("id", "").attr("data-slick-index", t + s.slideCount).appendTo(s.$slideTrack).addClass("slick-cloned"); 11878 } 11879 11880 s.$slideTrack.find(".slick-cloned").find("[id]").each(function () { 11881 i(this).attr("id", ""); 11882 }); 11883 } 11884 }, e.prototype.interrupt = function (i) { 11885 var e = this; 11886 i || e.autoPlay(), e.interrupted = i; 11887 }, e.prototype.selectHandler = function (e) { 11888 var t = this, 11889 o = i(e.target).is(".slick-slide") ? i(e.target) : i(e.target).parents(".slick-slide"), 11890 s = parseInt(o.attr("data-slick-index")); 11891 return s || (s = 0), t.slideCount <= t.options.slidesToShow ? void t.slideHandler(s, !1, !0) : void t.slideHandler(s); 11892 }, e.prototype.slideHandler = function (i, e, t) { 11893 var o, 11894 s, 11895 n, 11896 r, 11897 l, 11898 d = null, 11899 a = this; 11900 if (e = e || !1, !(a.animating === !0 && a.options.waitForAnimate === !0 || a.options.fade === !0 && a.currentSlide === i)) return e === !1 && a.asNavFor(i), o = i, d = a.getLeft(o), r = a.getLeft(a.currentSlide), a.currentLeft = null === a.swipeLeft ? r : a.swipeLeft, a.options.infinite === !1 && a.options.centerMode === !1 && (i < 0 || i > a.getDotCount() * a.options.slidesToScroll) ? void (a.options.fade === !1 && (o = a.currentSlide, t !== !0 && a.slideCount > a.options.slidesToShow ? a.animateSlide(r, function () { 11901 a.postSlide(o); 11902 }) : a.postSlide(o))) : a.options.infinite === !1 && a.options.centerMode === !0 && (i < 0 || i > a.slideCount - a.options.slidesToScroll) ? void (a.options.fade === !1 && (o = a.currentSlide, t !== !0 && a.slideCount > a.options.slidesToShow ? a.animateSlide(r, function () { 11903 a.postSlide(o); 11904 }) : a.postSlide(o))) : (a.options.autoplay && clearInterval(a.autoPlayTimer), s = o < 0 ? a.slideCount % a.options.slidesToScroll !== 0 ? a.slideCount - a.slideCount % a.options.slidesToScroll : a.slideCount + o : o >= a.slideCount ? a.slideCount % a.options.slidesToScroll !== 0 ? 0 : o - a.slideCount : o, a.animating = !0, a.$slider.trigger("beforeChange", [a, a.currentSlide, s]), n = a.currentSlide, a.currentSlide = s, a.setSlideClasses(a.currentSlide), a.options.asNavFor && (l = a.getNavTarget(), l = l.slick("getSlick"), l.slideCount <= l.options.slidesToShow && l.setSlideClasses(a.currentSlide)), a.updateDots(), a.updateArrows(), a.options.fade === !0 ? (t !== !0 ? (a.fadeSlideOut(n), a.fadeSlide(s, function () { 11905 a.postSlide(s); 11906 })) : a.postSlide(s), void a.animateHeight()) : void (t !== !0 && a.slideCount > a.options.slidesToShow ? a.animateSlide(d, function () { 11907 a.postSlide(s); 11908 }) : a.postSlide(s))); 11909 }, e.prototype.startLoad = function () { 11910 var i = this; 11911 i.options.arrows === !0 && i.slideCount > i.options.slidesToShow && (i.$prevArrow.hide(), i.$nextArrow.hide()), i.options.dots === !0 && i.slideCount > i.options.slidesToShow && i.$dots.hide(), i.$slider.addClass("slick-loading"); 11912 }, e.prototype.swipeDirection = function () { 11913 var i, 11914 e, 11915 t, 11916 o, 11917 s = this; 11918 return i = s.touchObject.startX - s.touchObject.curX, e = s.touchObject.startY - s.touchObject.curY, t = Math.atan2(e, i), o = Math.round(180 * t / Math.PI), o < 0 && (o = 360 - Math.abs(o)), o <= 45 && o >= 0 ? s.options.rtl === !1 ? "left" : "right" : o <= 360 && o >= 315 ? s.options.rtl === !1 ? "left" : "right" : o >= 135 && o <= 225 ? s.options.rtl === !1 ? "right" : "left" : s.options.verticalSwiping === !0 ? o >= 35 && o <= 135 ? "down" : "up" : "vertical"; 11919 }, e.prototype.swipeEnd = function (i) { 11920 var e, 11921 t, 11922 o = this; 11923 if (o.dragging = !1, o.swiping = !1, o.scrolling) return o.scrolling = !1, !1; 11924 if (o.interrupted = !1, o.shouldClick = !(o.touchObject.swipeLength > 10), void 0 === o.touchObject.curX) return !1; 11925 11926 if (o.touchObject.edgeHit === !0 && o.$slider.trigger("edge", [o, o.swipeDirection()]), o.touchObject.swipeLength >= o.touchObject.minSwipe) { 11927 switch (t = o.swipeDirection()) { 11928 case "left": 11929 case "down": 11930 e = o.options.swipeToSlide ? o.checkNavigable(o.currentSlide + o.getSlideCount()) : o.currentSlide + o.getSlideCount(), o.currentDirection = 0; 11931 break; 11932 11933 case "right": 11934 case "up": 11935 e = o.options.swipeToSlide ? o.checkNavigable(o.currentSlide - o.getSlideCount()) : o.currentSlide - o.getSlideCount(), o.currentDirection = 1; 11936 } 11937 11938 "vertical" != t && (o.slideHandler(e), o.touchObject = {}, o.$slider.trigger("swipe", [o, t])); 11939 } else o.touchObject.startX !== o.touchObject.curX && (o.slideHandler(o.currentSlide), o.touchObject = {}); 11940 }, e.prototype.swipeHandler = function (i) { 11941 var e = this; 11942 if (!(e.options.swipe === !1 || "ontouchend" in document && e.options.swipe === !1 || e.options.draggable === !1 && i.type.indexOf("mouse") !== -1)) switch (e.touchObject.fingerCount = i.originalEvent && void 0 !== i.originalEvent.touches ? i.originalEvent.touches.length : 1, e.touchObject.minSwipe = e.listWidth / e.options.touchThreshold, e.options.verticalSwiping === !0 && (e.touchObject.minSwipe = e.listHeight / e.options.touchThreshold), i.data.action) { 11943 case "start": 11944 e.swipeStart(i); 11945 break; 11946 11947 case "move": 11948 e.swipeMove(i); 11949 break; 11950 11951 case "end": 11952 e.swipeEnd(i); 11953 } 11954 }, e.prototype.swipeMove = function (i) { 11955 var e, 11956 t, 11957 o, 11958 s, 11959 n, 11960 r, 11961 l = this; 11962 return n = void 0 !== i.originalEvent ? i.originalEvent.touches : null, !(!l.dragging || l.scrolling || n && 1 !== n.length) && (e = l.getLeft(l.currentSlide), l.touchObject.curX = void 0 !== n ? n[0].pageX : i.clientX, l.touchObject.curY = void 0 !== n ? n[0].pageY : i.clientY, l.touchObject.swipeLength = Math.round(Math.sqrt(Math.pow(l.touchObject.curX - l.touchObject.startX, 2))), r = Math.round(Math.sqrt(Math.pow(l.touchObject.curY - l.touchObject.startY, 2))), !l.options.verticalSwiping && !l.swiping && r > 4 ? (l.scrolling = !0, !1) : (l.options.verticalSwiping === !0 && (l.touchObject.swipeLength = r), t = l.swipeDirection(), void 0 !== i.originalEvent && l.touchObject.swipeLength > 4 && (l.swiping = !0, i.preventDefault()), s = (l.options.rtl === !1 ? 1 : -1) * (l.touchObject.curX > l.touchObject.startX ? 1 : -1), l.options.verticalSwiping === !0 && (s = l.touchObject.curY > l.touchObject.startY ? 1 : -1), o = l.touchObject.swipeLength, l.touchObject.edgeHit = !1, l.options.infinite === !1 && (0 === l.currentSlide && "right" === t || l.currentSlide >= l.getDotCount() && "left" === t) && (o = l.touchObject.swipeLength * l.options.edgeFriction, l.touchObject.edgeHit = !0), l.options.vertical === !1 ? l.swipeLeft = e + o * s : l.swipeLeft = e + o * (l.$list.height() / l.listWidth) * s, l.options.verticalSwiping === !0 && (l.swipeLeft = e + o * s), l.options.fade !== !0 && l.options.touchMove !== !1 && (l.animating === !0 ? (l.swipeLeft = null, !1) : void l.setCSS(l.swipeLeft)))); 11963 }, e.prototype.swipeStart = function (i) { 11964 var e, 11965 t = this; 11966 return t.interrupted = !0, 1 !== t.touchObject.fingerCount || t.slideCount <= t.options.slidesToShow ? (t.touchObject = {}, !1) : (void 0 !== i.originalEvent && void 0 !== i.originalEvent.touches && (e = i.originalEvent.touches[0]), t.touchObject.startX = t.touchObject.curX = void 0 !== e ? e.pageX : i.clientX, t.touchObject.startY = t.touchObject.curY = void 0 !== e ? e.pageY : i.clientY, void (t.dragging = !0)); 11967 }, e.prototype.unfilterSlides = e.prototype.slickUnfilter = function () { 11968 var i = this; 11969 null !== i.$slidesCache && (i.unload(), i.$slideTrack.children(this.options.slide).detach(), i.$slidesCache.appendTo(i.$slideTrack), i.reinit()); 11970 }, e.prototype.unload = function () { 11971 var e = this; 11972 i(".slick-cloned", e.$slider).remove(), e.$dots && e.$dots.remove(), e.$prevArrow && e.htmlExpr.test(e.options.prevArrow) && e.$prevArrow.remove(), e.$nextArrow && e.htmlExpr.test(e.options.nextArrow) && e.$nextArrow.remove(), e.$slides.removeClass("slick-slide slick-active slick-visible slick-current").attr("aria-hidden", "true").css("width", ""); 11973 }
11973, e.prototype.unslick = function (i) { 11974 var e = this; 11975 e.$slider.trigger("unslick", [e, i]), e.destroy(); 11976 }, e.prototype.updateArrows = function () { 11977 var i, 11978 e = this; 11979 i = Math.floor(e.options.slidesToShow / 2), e.options.arrows === !0 && e.slideCount > e.options.slidesToShow && !e.options.infinite && (e.$prevArrow.removeClass("slick-disabled").attr("aria-disabled", "false"), e.$nextArrow.removeClass("slick-disabled").attr("aria-disabled", "false"), 0 === e.currentSlide ? (e.$prevArrow.addClass("slick-disabled").attr("aria-disabled", "true"), e.$nextArrow.removeClass("slick-disabled").attr("aria-disabled", "false")) : e.currentSlide >= e.slideCount - e.options.slidesToShow && e.options.centerMode === !1 ? (e.$nextArrow.addClass("slick-disabled").attr("aria-disabled", "true"), e.$prevArrow.removeClass("slick-disabled").attr("aria-disabled", "false")) : e.currentSlide >= e.slideCount - 1 && e.options.centerMode === !0 && (e.$nextArrow.addClass("slick-disabled").attr("aria-disabled", "true"), e.$prevArrow.removeClass("slick-disabled").attr("aria-disabled", "false"))); 11980 }, e.prototype.updateDots = function () { 11981 var i = this; 11982 null !== i.$dots && (i.$dots.find("li").removeClass("slick-active").end(), i.$dots.find("li").eq(Math.floor(i.currentSlide / i.options.slidesToScroll)).addClass("slick-active")); 11983 }, e.prototype.visibility = function () { 11984 var i = this; 11985 i.options.autoplay && (document[i.hidden] ? i.interrupted = !0 : i.interrupted = !1); 11986 }, i.fn.slick = function () { 11987 var i, 11988 t, 11989 o = this, 11990 s = arguments[0], 11991 n = Array.prototype.slice.call(arguments, 1), 11992 r = o.length; 11993 11994 for (i = 0; i < r; i++) { 11995 if ("object" == _typeof(s) || "undefined" == typeof s ? o[i].slick = new e(o[i], s) : t = o[i].slick[s].apply(o[i].slick, n), "undefined" != typeof t) return t; 11996 } 11997 11998 return o; 11999 }; 12000}); 12001 12002/***/ }), 12003 12004/***/ 4664: 12005/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 12006 12007"use strict"; 12008 12009 12010__webpack_require__(2979); 12011 12012__webpack_require__(3105); 12013 12014__webpack_require__(4986); 12015 12016__webpack_require__(8791); 12017/** 12018 * This function globally inits select2 plugin 12019 */ 12020 12021 12022var selectSelector = "select:not(.selectToBox, .selectToQty)"; 12023 12024function initSelect() { 12025 if (Modernizr && !Modernizr.touchevents && window.Foundation.MediaQuery.atLeast('lg')) { 12026 $(selectSelector).select2({ 12027 minimumResultsForSearch: -1 12028 }); 12029 } 12030} 12031 12032function reinitSelect($el) { 12033 var $select; 12034 12035 if ($el.length && $el.is('select')) { 12036 $select = $el; 12037 } else if ($(selectSelector).length > 0) { 12038 $select = $(selectSelector, $el); 12039 } 12040 12041 if ($select && $select.length && Modernizr && !Modernizr.touchevents && window.Foundation.MediaQuery.atLeast('lg')) { 12042 $select.select2({ 12043 minimumResultsForSearch: -1 12044 }); 12045 } 12046} 12047 12048var miniCartReinintSelect = function miniCartReinintSelect($el) { 12049 var $select; 12050 12051 if ($el.length && $el.is('select')) { 12052 $select = $el; 12053 } else if ($(selectSelector).length > 0) { 12054 $select = $(selectSelector, $el); 12055 } 12056 12057 if ($select && $select.length && Modernizr && !Modernizr.touchevents && window.Foundation.MediaQuery.atLeast('lg')) { 12058 $select.select2({ 12059 minimumResultsForSearch: -1, 12060 dropdownParent: $('.minicart-content') 12061 }); 12062 } 12063}; 12064/** 12065* Reinitializes the select element for quick view 12066* @param {jQuery} $el - select drop-down to reinitialize 12067* @returns {void} 12068*/ 12069 12070 12071var quickViewReinitSelect = function quickViewReinitSelect($el) { 12072 var $select; 12073 12074 if ($el.length && $el.is(selectSelector)) { 12075 $select = $el; 12076 } else if ($(selectSelector).length > 0) { 12077 $select = $(selectSelector, $el); 12078 } 12079 12080 if ($select && $select.length && Modernizr && !Modernizr.touchevents && window.Foundation.MediaQuery.atLeast("lg")) { 12081 $select.select2({ 12082 minimumResultsForSearch: -1, 12083 dropdownParent: $(".quick-view-select") 12084 }); 12085 } 12086}; 12087 12088function initDateMask() { 12089 $(".date-mask input").mask("00/00/0000"); 12090} 12091 12092function initFoundation() { 12093 $(document).foundation(); 12094 window.Foundation.MediaQuery.queriesRaw = { 12095 xs: 0, 12096 sm: 543, 12097 md: 991, 12098 lg: 1200 12099 }; 12100} 12101 12102function initModalSelect() { 12103 $(document).on("open.zf.reveal", function () { 12104 reinitSelect(); 12105 miniCartReinintSelect(); 12106 quickViewReinitSelect(); 12107 }); 12108 $(document).on("reinitSelect", function (e, el) { 12109 reinitSelect($(el)); 12110 }); 12111 $(document).on("miniCartReinintSelect", function (e, el) { 12112 miniCartReinintSelect($(el)); 12113 }); 12114 $(document).on("quickViewReinitSelect", function (e, el) { 12115 quickViewReinitSelect(el); 12116 }); 12117 $(selectSelector).on("open", function () { 12118 $(document).off("open.zf.reveal"); 12119 }); 12120} 12121/** 12122* @description Initializes the slick slider carousels 12123*/ 12124 12125 12126var slickCarousel = { 12127 /** 12128 * @function 12129 * @description - caches dom elements used as vars and returns an object 12130 */ 12131 initCache: function initCache() { 12132 var $cache = { 12133 slickElement: $(".slick-slider:not(.no-global-init)") 12134 }; 12135 return $cache;
12136 }, 12137 12138 /** 12139 * @function 12140 * @description - initializes each instance of the carousel found, based on the param passed 12141 */ 12142 initSlickSlider: function initSlickSlider(element) { 12143 var $element = $(element); 12144 $element.each(function () { 12145 var $this = $(this); 12146 12147 if ($this.hasClass("slick-initialized")) { 12148 return false; 12149 } 12150 12151 if (window.Foundation.MediaQuery.atLeast('sm')) { 12152 $this.slick({ 12153 arrows: true, 12154 slidesToShow: 4, 12155 slidesToScroll: 1, 12156 infinite: true, 12157 responsive: [{ 12158 breakpoint: window.Foundation.MediaQuery.queriesRaw.md, 12159 settings: { 12160 slidesToShow: 3 12161 } 12162 }] 12163 }); 12164 $this.find(".slick-slide").attr("aria-roledescription", "slide"); 12165 $this.find(".slick-slide").attr("role", "group"); 12166 } 12167 12168 $(window).on('changed.zf.mediaquery', function (event, newSize) { 12169 if (newSize === 'xs' && $this.hasClass('slick-initialized')) { 12170 $this.slick('unslick'); 12171 } else if (newSize !== 'xs' && !$this.hasClass('slick-initialized')) { 12172 slickCarousel.initSlickSlider($this); 12173 } 12174 }); 12175 }); 12176 }, 12177 init: function init() { 12178 var $cache = slickCarousel.initCache(); 12179 12180 if (!$cache.slickElement) { 12181 $cache.slickElement = $(".slick-slider"); 12182 } 12183 12184 slickCarousel.initSlickSlider($cache.slickElement); 12185 $(document).on('slick:reload', function (e, el) { 12186 slickCarousel.initSlickSlider(el); 12187 }); 12188 } 12189}; 12190module.exports = { 12191 initModalSelect: initModalSelect, 12192 initFoundation: initFoundation, 12193 initSelect: initSelect, 12194 slickCarousel: slickCarousel.init, 12195 initDateMask: initDateMask 12196}; 12197 12198/***/ }), 12199 12200/***/ 2739: 12201/***/ ((module) => { 12202 12203"use strict"; 12204 12205 12206module.exports = function () { 12207 var sizes = ['xs', 'sm', 'md', 'lg', 'xl'];
12208 sizes.forEach(function (size) { 12209 var selector = '.collapsible-' + size + ' .title'; 12210 $('body').on('click', selector, function (e) { 12211 e.preventDefault(); 12212 $(this).parents('.collapsible-' + size).toggleClass('active'); 12213 12214 if ($(this).parents('.collapsible-' + size).hasClass('active')) { 12215 $(this).attr('aria-expanded', true); 12216 } else { 12217 $(this).attr('aria-expanded', false); 12218 } 12219 }); 12220 }); 12221}; 12222 12223/***/ }), 12224 12225/***/ 5284: 12226/***/ ((module) => { 12227 12228"use strict"; 12229 12230/** 12231 * Get cookie value by cookie name from browser 12232 * @param {string} cookieName - name of the cookie 12233 * @returns {string} cookie value of the found cookie name 12234 */ 12235 12236function getCookie(cookieName) { 12237 var name = cookieName + '='; 12238 var decodedCookie = decodeURIComponent(document.cookie); 12239 var cookieArray = decodedCookie.split(';'); 12240 12241 for (var i = 0; i < cookieArray.length; i++) { 12242 var cookieItem = cookieArray[i]; 12243 12244 while (cookieItem.charAt(0) === ' ') { 12245 cookieItem = cookieItem.substring(1); 12246 } 12247 12248 if (cookieItem.indexOf(name) === 0) { 12249 return cookieItem.substring(name.length, cookieItem.length); 12250 } 12251 } 12252 12253 return ''; 12254} 12255 12256module.exports = function () { 12257 if ($('.valid-cookie-warning').length > 0) { 12258 var previousSessionID = window.localStorage.getItem('previousSid'); 12259 var currentSessionID = getCookie('sid'); 12260 12261 if (!previousSessionID && currentSessionID) { 12262 // When a user first time visit the home page, 12263 // set the previousSessionID to currentSessionID 12264 // and Show the cookie alert 12265 previousSessionID = currentSessionID; 12266 window.localStorage.setItem('previousSid', previousSessionID); 12267 $('.cookie-warning-messaging').show(); 12268 } else if (previousSessionID && previousSessionID === currentSessionID) { 12269 // Hide the cookie alert if user is in the same session 12270 $('.cookie-warning-messaging').hide(); 12271 } else { 12272 // Clear the previousSessionID from localStorage 12273 // when user session is changed or expired 12274 previousSessionID = ''; 12275 window.localStorage.removeItem('previousSid'); 12276 } 12277 } 12278}; 12279 12280/***/ }), 12281 12282/***/ 3567: 12283/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 12284 12285"use strict"; 12286 12287 12288var keyboardAccessibility = __webpack_require__(5987); 12289 12290module.exports = function () { 12291 $('.country-selector a').click(function (e) { 12292 e.preventDefault(); 12293 var action = $('.page').data('action'); 12294 var localeCode = $(this).data('locale'); 12295 var localeCurrencyCode = $(this).data('currencycode'); 12296 var queryString = $('.page').data('querystring'); 12297 var url = $('.country-selector').data('url'); 12298 $.ajax({ 12299 url: url, 12300 type: 'get', 12301 dataType: 'json', 12302 data: { 12303 code: localeCode, 12304 queryString: queryString, 12305 CurrencyCode: localeCurrencyCode, 12306 action: action 12307 }, 12308 success: function success(response) { 12309 $.spinner().stop(); 12310 12311 if (response && response.redirectUrl) { 12312 window.location.href = response.redirectUrl; 12313 } 12314 }, 12315 error: function error() { 12316 $.spinner().stop(); 12317 } 12318 }); 12319 }); 12320 keyboardAccessibility('.navbar-header .country-selector', { 12321 40: function _($countryOptions) { 12322 // down 12323 if ($(this).is(':focus')) { 12324 $countryOptions.first().focus(); 12325 } else { 12326 $(':focus').next().focus(); 12327 } 12328 }, 12329 38: function _($countryOptions) { 12330 // up 12331 if ($countryOptions.first().is(':focus') || $(this).is(':focus')) { 12332 $(this).focus(); 12333 $(this).removeClass('show'); 12334 } else { 12335 $(':focus').prev().focus(); 12336 } 12337 }, 12338 27: function _() { 12339 // escape 12340 $(this).focus(); 12341 $(this).removeClass('show').children('.dropdown-menu').removeClass('show'); 12342 }, 12343 9: function _() { 12344 // tab 12345 $(this).removeClass('show').children('.dropdown-menu').removeClass('show'); 12346 } 12347 }, function () { 12348 if (!$(this).hasClass('show')) { 12349 $(this).addClass('show'); 12350 } 12351 12352 return $(this).find('.dropdown-country-selector').children('a'); 12353 }); 12354 $('.navbar-header .country-selector').on('focusin', function () { 12355 $(this).addClass('show').children('.dropdown-menu').addClass('show'); 12356 }); 12357}; 12358 12359/***/ }), 12360 12361/***/ 7768: 12362/***/ ((module) => { 12363 12364"use strict"; 12365 12366 12367module.exports = { 12368 setTabNextFocus: function setTabNextFocus(focusParams) { 12369 var KEYCODE_TAB = 9; 12370 var isTabPressed = focusParams.event.key === 'Tab' || focusParams.event.keyCode === KEYCODE_TAB; 12371 12372 if (!isTabPressed) { 12373 return; 12374 } 12375 12376 var firstFocusableEl = $(focusParams.containerSelector + ' ' + focu
12376sParams.firstElementSelector); 12377 var lastFocusableEl = $(focusParams.containerSelector + ' ' + focusParams.lastElementSelector); 12378 12379 if ($(focusParams.containerSelector + ' ' + focusParams.lastElementSelector).is(':disabled')) { 12380 lastFocusableEl = $(focusParams.containerSelector + ' ' + focusParams.nextToLastElementSelector); 12381 12382 if ($('.product-quickview.product-set').length > 0) { 12383 var linkElements = $(focusParams.containerSelector + ' a#fa-link.share-icons'); 12384 lastFocusableEl = linkElements[linkElements.length - 1]; 12385 } 12386 } 12387 12388 if (focusParams.event.shiftKey) 12389 /* shift + tab */ 12390 { 12391 if ($(':focus').is(firstFocusableEl)) { 12392 lastFocusableEl.focus(); 12393 focusParams.event.preventDefault(); 12394 } 12395 } else 12396 /* tab */ 12397 { 12398 if ($(':focus').is(lastFocusableEl)) { 12399 // eslint-disable-line 12400 firstFocusableEl.focus(); 12401 focusParams.event.preventDefault(); 12402 } 12403 } 12404 } 12405}; 12406 12407/***/ }), 12408 12409/***/ 5987: 12410/***/ ((module) => { 12411 12412"use strict"; 12413 12414 12415module.exports = function (selector, keyFunctions, preFunction) { 12416 $(selector).on('keydown', function (e) { 12417 var key = e.which; 12418 var supportedKeyCodes = [37, 38, 39, 40, 27]; 12419 12420 if (supportedKeyCodes.indexOf(key) >= 0) { 12421 e.preventDefault(); 12422 } 12423 12424 var returnedScope = preFunction.call(this); 12425 12426 if (keyFunctions[key]) { 12427 keyFunctions[key].call(this, returnedScope); 12428 } 12429 }); 12430}; 12431 12432/***/ }), 12433 12434/***/ 1184: 12435/***/ ((module) => { 12436 12437"use strict"; 12438 12439 12440module.exports = function (element) { 12441 var position = element && element.length ? element.offset().top : 0; 12442 $('html, body').animate({ 12443 scrollTop: position 12444 }, 500); 12445 12446 if (!element) { 12447 $('.logo-home').focus(); 12448 } 12449}; 12450 12451/***/ }), 12452 12453/***/ 383: 12454/***/ ((module) => { 12455 12456"use strict"; 12457 12458 12459module.exports = function () { 12460 $('.info-icon').on('mouseenter focusin', function () { 12461 $(this).find('.tooltip').removeClass('d-none'); 12462 }); 12463 $('.info-icon').on('mouseleave focusout', function () { 12464 $(this).find('.tooltip').addClass('d-none'); 12465 }); 12466}; 12467 12468/***/ }), 12469 12470/***/ 7199: 12471/***/ ((module) => { 12472 12473"use strict"; 12474 12475 12476function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 12477 12478module.exports = function (include) { 12479 if (typeof include === 'function') { 12480 include(); 12481 } else if (_typeof(include) === 'object') { 12482 Object.keys(include).forEach(function (key) { 12483 if (typeof include[key] === 'function') { 12484 include[key](); 12485 } 12486 }); 12487 } 12488}; 12489 12490/***/ }), 12491 12492/***/ 1640: 12493/***/ (() => { 12494 12495var trustedshopsBadge = function trustedshopsBadge() { 12496 var id = document.getElementById('trustedShopsID'); 12497 12498 if (!id || id.value === 'null') { 12499 return; 12500 } 12501 12502 id = id.value; 12503 var _tsConfig = undefined; 12504 12505 try { 12506 _tsConfig = JSON.parse(document.getElementById('trustedShopsBadgeConfig').value); 12507 } catch (e) { 12508 _tsConfig = undefined; 12509 } 12510 12511 var _ts = document.createElement('script'); 12512 12513 _ts.type = 'text/javascript'; 12514 _ts.charset = 'utf-8'; 12515 _ts.async = true; 12516 _ts.src = '//widgets.trustedshops.com/js/' + id + '.js'; 12517 var __ts = document.getElementsByTagName('script')[0]; 12518 12519 __ts.parentNode.insertBefore(_ts, __ts); 12520 12521 window._tsConfig = _tsConfig; // this is important 12522 // there is no placeholder for this widget because it uses position fixed 12523 12524 return; 12525}; 12526 12527$(document).ready(function () { 12528 trustedshopsBadge(); 12529}); 12530 12531/***/ }), 12532 12533/***/ 4226: 12534/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 12535 12536"use strict"; 12537__webpack_require__.r(__webpack_exports__); 12538/* harmony export */ __webpack_require__.d(__webpack_exports__, { 12539/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 12540/* harmony export */ }); 12541/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4540); 12542/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(jquery__WEBPACK_IMPORTED_MODULE_0__); 12543/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(218); 12544function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 12545 12546function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); } 12547 12548function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } } 12549 12550function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; } 12551 12552function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; } 12553 12554function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } 12555 12556/** 12557 * -------------------------------------------------------------------------- 12558 * Bootstrap (v4.5.3): alert.js 12559 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 12560 * -------------------------------------------------------------------------- 12561 */ 12562 12563 12564/** 12565 * ------------------------------------------------------------------------ 12566 * Constants 12567 * ------------------------------------------------------------------------ 12568 */ 12569 12570var NAME = 'alert'; 12571var VERSION = '4.5.3'; 12572var DATA_KEY = 'bs.alert'; 12573var EVENT_KEY = ".".concat(DATA_KEY); 12574var DATA_API_KEY = '.data-api'; 12575var JQUERY_NO_CONFLICT = (jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME]; 12576var SELECTOR_DISMISS = '[data-dismiss="alert"]'; 12577var EVENT_CLOSE = "close".concat(EVENT_KEY); 12578var EVENT_CLOSED = "closed".concat(EVENT_KEY); 12579var EVENT_CLICK_DATA_API = "click".concat(EVENT_KEY).concat(DATA_API_KEY); 12580var CLASS_NAME_ALERT = 'alert'; 12581var CLASS_NAME_FADE = 'fade'; 12582var CLASS_NAME_SHOW = 'show'; 12583/** 12584 * ------------------------------------------------------------------------ 12585 * Class Definition 12586 * ------------------------------------------------------------------------ 12587 */ 12588 12589var Alert = /*#__PURE__*/function () { 12590 function Alert(element) { 12591 _classCallCheck(this, Alert); 12592 12593 this._element = element; 12594 } // Getters 12595 12596 12597 _createClass(Alert, [{ 12598 key: "close", 12599 // Public 12600 value: function close(element) { 12601 var rootElement = this._element; 12602 12603 if (element) { 12604 rootElement = this._getRootElement(element); 12605 } 12606 12607 var customEvent = this._triggerCloseEvent(rootElement); 12608 12609 if (customEvent.isDefaultPrevented()) { 12610 return; 12611 } 12612 12613 this._removeElement(rootElement); 12614 } 12615 }, { 12616 key: "dispose", 12617 value: function dispose() { 12618 jquery__WEBPACK_IMPORTED_MODULE_0___default().removeData(this._element, DATA_KEY); 12619 this._element = null; 12620 } // Private 12621 12622 }, { 12623 key: "_getRootElement", 12624 value: function _getRootElement(element) { 12625 var selector = _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.getSelectorFromElement(element); 12626 var parent = false;
12627 12628 if (selector) { 12629 parent = document.querySelector(selector); 12630 } 12631 12632 if (!parent) { 12633 parent = jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).closest(".".concat(CLASS_NAME_ALERT))[0]; 12634 } 12635 12636 return parent; 12637 } 12638 }, { 12639 key: "_triggerCloseEvent", 12640 value: function _triggerCloseEvent(element) { 12641 var closeEvent = jquery__WEBPACK_IMPORTED_MODULE_0___default().Event(EVENT_CLOSE); 12642 jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).trigger(closeEvent); 12643 return closeEvent; 12644 } 12645 }, { 12646 key: "_removeElement", 12647 value: function _removeElement(element) { 12648 var _this = this; 12649 12650 jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).removeClass(CLASS_NAME_SHOW); 12651 12652 if (!jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).hasClass(CLASS_NAME_FADE)) { 12653 this._destroyElement(element); 12654 12655 return; 12656 } 12657 12658 var transitionDuration = _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.getTransitionDurationFromElement(element); 12659 jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).one(_util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.TRANSITION_END, function (event) { 12660 return _this._destroyElement(element, event); 12661 }).emulateTransitionEnd(transitionDuration); 12662 } 12663 }, { 12664 key: "_destroyElement", 12665 value: function _destroyElement(element) { 12666 jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).detach().trigger(EVENT_CLOSED).remove(); 12667 } // Static 12668 12669 }], [{ 12670 key: "_jQueryInterface", 12671 value: function _jQueryInterface(config) { 12672 return this.each(function () { 12673 var $element = jquery__WEBPACK_IMPORTED_MODULE_0___default()(this); 12674 var data = $element.data(DATA_KEY); 12675 12676 if (!data) { 12677 data = new Alert(this); 12678 $element.data(DATA_KEY, data); 12679 } 12680 12681 if (config === 'close') { 12682 data[config](this); 12683 } 12684 }); 12685 } 12686 }, { 12687 key: "_handleDismiss", 12688 value: function _handleDismiss(alertInstance) { 12689 return function (event) { 12690 if (event) { 12691 event.preventDefault(); 12692 } 12693 12694 alertInstance.close(this); 12695 }; 12696 } 12697 }, { 12698 key: "VERSION", 12699 get: function get() { 12700 return VERSION; 12701 } 12702 }]); 12703 12704 return Alert; 12705}(); 12706/** 12707 * ------------------------------------------------------------------------ 12708 * Data Api implementation 12709 * ------------------------------------------------------------------------ 12710 */ 12711 12712 12713jquery__WEBPACK_IMPORTED_MODULE_0___default()(document).on(EVENT_CLICK_DATA_API, SELECTOR_DISMISS, Alert._handleDismiss(new Alert())); 12714/** 12715 * ------------------------------------------------------------------------ 12716 * jQuery 12717 * ------------------------------------------------------------------------ 12718 */ 12719 12720(jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME] = Alert._jQueryInterface; 12721(jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME].Constructor = Alert; 12722 12723(jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME].noConflict = function () { 12724 (jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME] = JQUERY_NO_CONFLICT; 12725 return Alert._jQueryInterface; 12726}; 12727 12728/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Alert); 12729 12730/***/ }), 12731 12732/***/ 8593: 12733/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 12734 12735"use strict"; 12736__webpack_require__.r(__webpack_exports__); 12737/* harmony export */ __webpack_require__.d(__webpack_exports__, { 12738/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 12739/* harmony export */ }); 12740/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4540); 12741/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(jquery__WEBPACK_IMPORTED_MODULE_0__); 12742/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(218); 12743function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 12744 12745function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } 12746 12747function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
12747 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } 12748 12749function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } 12750 12751function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); } 12752 12753function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } } 12754 12755function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; } 12756 12757function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; } 12758 12759function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } 12760 12761/** 12762 * -------------------------------------------------------------------------- 12763 * Bootstrap (v4.5.3): modal.js 12764 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 12765 * -------------------------------------------------------------------------- 12766 */ 12767 12768 12769/** 12770 * ------------------------------------------------------------------------ 12771 * Constants 12772 * ------------------------------------------------------------------------ 12773 */ 12774 12775var NAME = 'modal'; 12776var VERSION = '4.5.3'; 12777var DATA_KEY = 'bs.modal'; 12778var EVENT_KEY = ".".concat(DATA_KEY); 12779var DATA_API_KEY = '.data-api'; 12780var JQUERY_NO_CONFLICT = (jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME]; 12781var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key 12782 12783var Default = { 12784 backdrop: true, 12785 keyboard: true, 12786 focus: true, 12787 show: true 12788}; 12789var DefaultType = { 12790 backdrop: '(boolean|string)', 12791 keyboard: 'boolean', 12792 focus: 'boolean', 12793 show: 'boolean' 12794}; 12795var EVENT_HIDE = "hide".concat(EVENT_KEY); 12796var EVENT_HIDE_PREVENTED = "hidePrevented".concat(EVENT_KEY); 12797var EVENT_HIDDEN = "hidden".concat(EVENT_KEY); 12798var EVENT_SHOW = "show".concat(EVENT_KEY); 12799var EVENT_SHOWN = "shown".concat(EVENT_KEY); 12800var EVENT_FOCUSIN = "focusin".concat(EVENT_KEY); 12801var EVENT_RESIZE = "resize".concat(EVENT_KEY); 12802var EVENT_CLICK_DISMISS = "click.dismiss".concat(EVENT_KEY); 12803var EVENT_KEYDOWN_DISMISS = "keydown.dismiss".concat(EVENT_KEY); 12804var EVENT_MOUSEUP_DISMISS = "mouseup.dismiss".concat(EVENT_KEY); 12805var EVENT_MOUSEDOWN_DISMISS = "mousedown.dismiss".concat(EVENT_KEY); 12806var EVENT_CLICK_DATA_API = "click".concat(EVENT_KEY).concat(DATA_API_KEY); 12807var CLASS_NAME_SCROLLABLE = 'modal-dialog-scrollable'; 12808var CLASS_NAME_SCROLLBAR_MEASURER = 'modal-scrollbar-measure'; 12809var CLASS_NAME_BACKDROP = 'modal-backdrop'; 12810var CLASS_NAME_OPEN = 'modal-open'; 12811var CLASS_NAME_FADE = 'fade'; 12812var CLASS_NAME_SHOW = 'show'; 12813var CLASS_NAME_STATIC = 'modal-static'; 12814var SELECTOR_DIALOG = '.modal-dialog'; 12815var SELECTOR_MODAL_BODY = '.modal-body'; 12816var SELECTOR_DATA_TOGGLE = '[data-toggle="modal"]'; 12817var SELECTOR_DATA_DISMISS = '[data-dismiss="modal"]'; 12818var SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; 12819var SELECTOR_STICKY_CONTENT = '.sticky-top'; 12820/** 12821 * ------------------------------------------------------------------------ 12822 * Class Definition 12823 * ------------------------------------------------------------------------ 12824 */ 12825 12826var Modal = /*#__PURE__*/function () { 12827 function Modal(element, config) { 12828 _classCallCheck(this, Modal); 12829 12830 this._config = this._getConfig(config); 12831 this._element = element; 12832 this._dialog = element.querySelector(SELECTOR_DIALOG); 12833 this._backdrop = null; 12834 this._isShown = false;
12835 this._isBodyOverflowing = false; 12836 this._ignoreBackdropClick = false; 12837 this._isTransitioning = false; 12838 this._scrollbarWidth = 0; 12839 } // Getters 12840 12841 12842 _createClass(Modal, [{ 12843 key: "toggle", 12844 // Public 12845 value: function toggle(relatedTarget) { 12846 return this._isShown ? this.hide() : this.show(relatedTarget); 12847 } 12848 }, { 12849 key: "show", 12850 value: function show(relatedTarget) { 12851 var _this = this; 12852 12853 if (this._isShown || this._isTransitioning) { 12854 return; 12855 } 12856 12857 if (jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).hasClass(CLASS_NAME_FADE)) { 12858 this._isTransitioning = true; 12859 } 12860 12861 var showEvent = jquery__WEBPACK_IMPORTED_MODULE_0___default().Event(EVENT_SHOW, { 12862 relatedTarget: relatedTarget 12863 }); 12864 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).trigger(showEvent); 12865 12866 if (this._isShown || showEvent.isDefaultPrevented()) { 12867 return; 12868 } 12869 12870 this._isShown = true; 12871 12872 this._checkScrollbar(); 12873 12874 this._setScrollbar(); 12875 12876 this._adjustDialog(); 12877 12878 this._setEscapeEvent(); 12879 12880 this._setResizeEvent(); 12881 12882 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).on(EVENT_CLICK_DISMISS, SELECTOR_DATA_DISMISS, function (event) { 12883 return _this.hide(event); 12884 }); 12885 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._dialog).on(EVENT_MOUSEDOWN_DISMISS, function () { 12886 jquery__WEBPACK_IMPORTED_MODULE_0___default()(_this._element).one(EVENT_MOUSEUP_DISMISS, function (event) { 12887 if (jquery__WEBPACK_IMPORTED_MODULE_0___default()(event.target).is(_this._element)) { 12888 _this._ignoreBackdropClick = true; 12889 } 12890 }); 12891 }); 12892 12893 this._showBackdrop(function () { 12894 return _this._showElement(relatedTarget); 12895 }); 12896 } 12897 }, { 12898 key: "hide", 12899 value: function hide(event) { 12900 var _this2 = this; 12901 12902 if (event) { 12903 event.preventDefault(); 12904 } 12905 12906 if (!this._isShown || this._isTransitioning) { 12907 return; 12908 } 12909 12910 var hideEvent = jquery__WEBPACK_IMPORTED_MODULE_0___default().Event(EVENT_HIDE); 12911 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).trigger(hideEvent); 12912 12913 if (!this._isShown || hideEvent.isDefaultPrevented()) { 12914 return; 12915 } 12916 12917 this._isShown = false; 12918 var transition = jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).hasClass(CLASS_NAME_FADE); 12919 12920 if (transition) { 12921 this._isTransitioning = true; 12922 } 12923 12924 this._setEscapeEvent(); 12925 12926 this._setResizeEvent(); 12927 12928 jquery__WEBPACK_IMPORTED_MODULE_0___default()(document).off(EVENT_FOCUSIN); 12929 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).removeClass(CLASS_NAME_SHOW); 12930 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).off(EVENT_CLICK_DISMISS); 12931 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._dialog).off(EVENT_MOUSEDOWN_DISMISS); 12932 12933 if (transition) { 12934 var transitionDuration = _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.getTransitionDurationFromElement(this._element); 12935 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).one(_util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.TRANSITION_END, function (event) { 12936 return _this2._hideModal(event); 12937 }).emulateTransitionEnd(transitionDuration); 12938 } else { 12939 this._hideModal(); 12940 } 12941 } 12942 }, { 12943 key: "dispose", 12944 value: function dispose() { 12945 [window, this._element, this._dialog].forEach(function (htmlElement) { 12946 return jquery__WEBPACK_IMPORTED_MODULE_0___default()(htmlElement).off(EVENT_KEY); 12947 }); 12948 /** 12949 * `document` has 2 events `EVENT_FOCUSIN` and `EVENT_CLICK_DATA_API` 12950 * Do not move `document` in `htmlElements` array 12951 * It will remove `EVENT_CLICK_DATA_API` event that should remain 12952 */ 12953 12954 jquery__WEBPACK_IMPORTED_MODULE_0___default()(document).off(EVENT_FOCUSIN); 12955 jquery__WEBPACK_IMPORTED_MODULE_0___default().removeData(this._element, DATA_KEY); 12956 this._config = null; 12957 this._element = null; 12958 this._dialog = null; 12959 this._backdrop = null; 12960 this._isShown = null; 12961 this._isBodyOverflowing = null; 12962 this._ignoreBackdropClick = null; 12963 this._isTransitioning = null; 12964 this._scrollbarWidth = null; 12965 } 12966 }, { 12967 key: "handleUpdate", 12968 value: function handleUpdate() { 12969 this._adjustDialog(); 12970 } // Private 12971 12972 }, { 12973 key: "_getConfig", 12974 value: function _getConfig(config) { 12975 config = _objectSpread(_objectSpread({}, Default), config); 12976 _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.typeCheckConfig(NAME, config, DefaultType); 12977 return config; 12978 } 12979 }, { 12980 key: "_triggerBackdropTransition", 12981 value: function _triggerBackdropTransition() { 12982 var _this3 = this; 12983 12984 if (this._config.backdrop === 'static') { 12985 var hideEventPrevented = jquery__WEBPACK_IMPORTED_MODULE_0___default().Event(EVENT_HIDE_PREVENTED); 12986 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).trigger(hideEventPrevented); 12987 12988 if (hideEventPrevented.isDefaultPrevented()) { 12989 return; 12990 } 12991 12992 var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 12993 12994 if (!isModalOverflowing) { 12995 this._element.style.overflowY = 'hidden'; 12996 } 12997 12998 this._element.classList.add(CLASS_NAME_STATIC); 12999 13000 var modalTransitionDuration = _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.getTransitionDurationFromElement(this._dialog); 13001 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).off(_util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.TRANSITION_END); 13002 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).one(_util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.TRANSITION_END, function () { 13003 _this3._element.classList.remove(CLASS_NAME_STATIC); 13004 13005 if (!isModalOverflowing) { 13006 jquery__WEBPACK_IMPORTED_MODULE_0___default()(_this3._element).one(_util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.TRANSITION_END, function () { 13007 _this3._element.style.overflowY = ''; 13008 }).emulateTransitionEnd(_this3._element, modalTransitionDuration); 13009 } 13010 }).emulateTransitionEnd(modalTransitionDuration); 13011 13012 this._element.focus(); 13013 } else { 13014 this.hide(); 13015 } 13016 } 13017 }, { 13018 key: "_showElement", 13019 value: function _showElement(relatedTarget) { 13020 var _this4 = this; 13021 13022 var transition = jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).hasClass(CLASS_NAME_FADE); 13023 var modalBody = this._dialog ? this._dialog.querySelector(SELECTOR_MODAL_BODY) : null; 13024 13025 if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) { 13026 // Don't move modal's DOM position 13027 document.body.appendChild(this._element); 13028 } 13029 13030 this._element.style.display = 'block'; 13031 13032 this._element.removeAttribute('aria-hidden'); 13033 13034 this._element.setAttribute('aria-modal', true); 13035 13036 this._element.setAttribute('role', 'dialog'); 13037 13038 if (jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._dialog).hasClass(CLASS_NAME_SCROLLABLE) && modalBody) { 13039 modalBody.scrollTop = 0; 13040 } else { 13041 this._element.scrollTop = 0; 13042 } 13043 13044 if (transition) { 13045 _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.reflow(this._element); 13046 } 13047 13048 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).addClass(CLASS_NAME_SHOW); 13049 13050 if (this._config.focus) { 13051 this._enforceFocus(); 13052 } 13053 13054 var shownEvent = jquery__WEBPACK_IMPORTED_MODULE_0___default().Event(EVENT_SHOWN, { 13055 relatedTarget: relatedTarget 13056 }); 13057 13058 var transitionComplete = function transitionComplete() { 13059 if (_this4._config.focus) { 13060 _this4._element.focus(); 13061 } 13062 13063 _this4._isTransitioning = false;
13064 jquery__WEBPACK_IMPORTED_MODULE_0___default()(_this4._element).trigger(shownEvent); 13065 }; 13066 13067 if (transition) { 13068 var transitionDuration = _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.getTransitionDurationFromElement(this._dialog); 13069 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._dialog).one(_util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.TRANSITION_END, transitionComplete).emulateTransitionEnd(transitionDuration); 13070 } else { 13071 transitionComplete(); 13072 } 13073 } 13074 }, { 13075 key: "_enforceFocus", 13076 value: function _enforceFocus() { 13077 var _this5 = this; 13078 13079 jquery__WEBPACK_IMPORTED_MODULE_0___default()(document).off(EVENT_FOCUSIN) // Guard against infinite focus loop 13080 .on(EVENT_FOCUSIN, function (event) { 13081 if (document !== event.target && _this5._element !== event.target && jquery__WEBPACK_IMPORTED_MODULE_0___default()(_this5._element).has(event.target).length === 0) { 13082 _this5._element.focus(); 13083 } 13084 }); 13085 } 13086 }, { 13087 key: "_setEscapeEvent", 13088 value: function _setEscapeEvent() { 13089 var _this6 = this; 13090 13091 if (this._isShown) { 13092 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).on(EVENT_KEYDOWN_DISMISS, function (event) { 13093 if (_this6._config.keyboard && event.which === ESCAPE_KEYCODE) { 13094 event.preventDefault(); 13095 13096 _this6.hide(); 13097 } else if (!_this6._config.keyboard && event.which === ESCAPE_KEYCODE) { 13098 _this6._triggerBackdropTransition(); 13099 } 13100 }); 13101 } else if (!this._isShown) { 13102 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).off(EVENT_KEYDOWN_DISMISS); 13103 } 13104 } 13105 }, { 13106 key: "_setResizeEvent", 13107 value: function _setResizeEvent() { 13108 var _this7 = this; 13109 13110 if (this._isShown) { 13111 jquery__WEBPACK_IMPORTED_MODULE_0___default()(window).on(EVENT_RESIZE, function (event) { 13112 return _this7.handleUpdate(event); 13113 }); 13114 } else { 13115 jquery__WEBPACK_IMPORTED_MODULE_0___default()(window).off(EVENT_RESIZE); 13116 } 13117 } 13118 }, { 13119 key: "_hideModal", 13120 value: function _hideModal() { 13121 var _this8 = this; 13122 13123 this._element.style.display = 'none'; 13124 13125 this._element.setAttribute('aria-hidden', true); 13126 13127 this._element.removeAttribute('aria-modal'); 13128 13129 this._element.removeAttribute('role'); 13130 13131 this._isTransitioning = false; 13132 13133 this._showBackdrop(function () { 13134 jquery__WEBPACK_IMPORTED_MODULE_0___default()(document.body).removeClass(CLASS_NAME_OPEN); 13135 13136 _this8._resetAdjustments(); 13137 13138 _this8._resetScrollbar(); 13139 13140 jquery__WEBPACK_IMPORTED_MODULE_0___default()(_this8._element).trigger(EVENT_HIDDEN); 13141 }); 13142 } 13143 }, { 13144 key: "_removeBackdrop", 13145 value: function _removeBackdrop() { 13146 if (this._backdrop) { 13147 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._backdrop).remove(); 13148 this._backdrop = null; 13149 } 13150 } 13151 }, { 13152 key: "_showBackdrop", 13153 value: function _showBackdrop(callback) { 13154 var _this9 = this; 13155 13156 var animate = jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).hasClass(CLASS_NAME_FADE) ? CLASS_NAME_FADE : ''; 13157 13158 if (this._isShown && this._config.backdrop) { 13159 this._backdrop = document.createElement('div'); 13160 this._backdrop.className = CLASS_NAME_BACKDROP; 13161 13162 if (animate) { 13163 this._backdrop.classList.add(animate); 13164 } 13165 13166 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._backdrop).appendTo(document.body); 13167 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).on(EVENT_CLICK_DISMISS, function (event) { 13168 if (_this9._ignoreBackdropClick) { 13169 _this9._ignoreBackdropClick = false; 13170 return; 13171 } 13172 13173 if (event.target !== event.currentTarget) { 13174 return; 13175 } 13176 13177 _this9._triggerBackdropTransition(); 13178 }); 13179 13180 if (animate) { 13181 _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.reflow(this._backdrop); 13182 } 13183 13184 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._backdrop).addClass(CLASS_NAME_SHOW); 13185 13186 if (!callback) { 13187 return; 13188 } 13189 13190 if (!animate) { 13191 callback(); 13192 return; 13193 } 13194 13195 var backdropTransitionDuration = _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.getTransitionDurationFromElement(this._backdrop); 13196 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._backdrop).one(_util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.TRANSITION_END, callback).emulateTransitionEnd(backdropTransitionDuration); 13197 } else if (!this._isShown && this._backdrop) { 13198 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._backdrop).removeClass(CLASS_NAME_SHOW); 13199 13200 var callbackRemove = function callbackRemove() { 13201 _this9._removeBackdrop(); 13202 13203 if (callback) { 13204 callback(); 13205 } 13206 }; 13207 13208 if (jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).hasClass(CLASS_NAME_FADE)) { 13209 var _backdropTransitionDuration = _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.getTransitionDurationFromElement(this._backdrop); 13210 13211 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._backdrop).one(_util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration); 13212 } else { 13213 callbackRemove(); 13214 } 13215 } else if (callback) { 13216 callback(); 13217 } 13218 } // ---------------------------------------------------------------------- 13219 // the following methods are used to handle overflowing modals 13220 // todo (fat): these should probably be refactored out of modal.js 13221 // ---------------------------------------------------------------------- 13222 13223 }, { 13224 key: "_adjustDialog", 13225 value: function _adjustDialog() { 13226 var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 13227 13228 if (!this._isBodyOverflowing && isModalOverflowing) { 13229 this._element.style.paddingLeft = "".concat(this._scrollbarWidth, "px"); 13230 } 13231 13232 if (this._isBodyOverflowing && !isModalOverflowing) { 13233 this._element.style.paddingRight = "".concat(this._scrollbarWidth, "px"); 13234 } 13235 } 13236 }, { 13237 key: "_resetAdjustments", 13238 value: function _resetAdjustments() { 13239 this._element.style.paddingLeft = ''; 13240 this._element.style.paddingRight = ''; 13241 } 13242 }, { 13243 key: "_checkScrollbar", 13244 value: function _checkScrollbar() { 13245 var rect = document.body.getBoundingClientRect(); 13246 this._isBodyOverflowing = Math.round(rect.left + rect.right) < window.innerWidth; 13247 this._scrollbarWidth = this._getScrollbarWidth(); 13248 } 13249 }, { 13250 key: "_setScrollbar", 13251 value: function _setScrollbar() { 13252 var _this10 = this; 13253 13254 if (this._isBodyOverflowing) { 13255 // Note: DOMNode.style.paddingRight returns the actual value or '' if not set 13256 // while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set 13257 var fixedContent = [].slice.call(document.querySelectorAll(SELECTOR_FIXED_CONTENT)); 13258 var stickyContent = [].slice.call(document.querySelectorAll(SELECTOR_STICKY_CONTENT)); // Adjust fixed content padding 13259 13260 jquery__WEBPACK_IMPORTED_MODULE_0___default()(fixedContent).each(function (index, element) { 13261 var actualPadding = element.style.paddingRight; 13262 var calculatedPadding = jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).css('padding-right'); 13263 jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).data('padding-right', actualPadding).css('padding-right', "".concat(parseFloat(calculatedPadding) + _this10._scrollbarWidth, "px")); 13264 }); // Adjust sticky content margin 13265 13266 jquery__WEBPACK_IMPORTED_MODULE_0___default()(stickyContent).each(function (index, element) { 13267 var actualMargin = element.style.marginRight; 13268 var calculatedMargin = jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).css('margin-right'); 13269 jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).data('margin-right', actualMargin).css('margin-right', "".concat(parseFloat(calculatedMargin) - _this10._scrollbarWidth, "px")); 13270 }); // Adjust body padding 13271 13272 var actualPadding = document.body.style.paddingRight; 13273 var calculatedPadding = jquery__WEBPACK_IMPORTED_MODULE_0___default()(document.body).css('padding-right'); 13274 jquery__WEBPACK_IMPORTED_MODULE_0___default()(document.body).data('padding-right', actualPadding).css('padding-right', "".concat(parseFloat(calculatedPadding) + this._scrollbarWidth, "px")); 13275 } 13276 13277 jquery__WEBPACK_IMPORTED_MODULE_0___default()(document.body).addClass(CLASS_NAME_OPEN); 13278 } 13279 }, { 13280 key: "_resetScrollbar", 13281 value: function _resetScrollbar() { 13282 // Restore fixed content padding 13283 var fixedContent = [].slice.call(document.querySelectorAll(SELECTOR_FIXED_CONTENT)); 13284 jquery__WEBPACK_IMPORTED_MODULE_0___default()(fixedContent).each(function (index, element) { 13285 var padding = jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).data('padding-right'); 13286 jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).removeData('padding-right'); 13287 element.style.paddingRight = padding ? padding : ''; 13288 }); // Restore sticky content 13289 13290 var elements = [].slice.call(document.querySelectorAll("".concat(SELECTOR_STICKY_CONTENT))); 13291 jquery__WEBPACK_IMPORTED_MODULE_0___default()(elements).each(function (index, element) { 13292 var margin = jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).data('margin-right'); 13293 13294 if (typeof margin !== 'undefined') { 13295 jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).css('margin-right', margin).removeData('margin-right'); 13296 } 13297 }); // Restore body padding 13298 13299 var padding = jquery__WEBPACK_IMPORTED_MODULE_0___default()(document.body).data('padding-right'); 13300 jquery__WEBPACK_IMPORTED_MODULE_0___default()(document.body).removeData('padding-right'); 13301 document.body.style.paddingRight = padding ? padding : ''; 13302 } 13303 }, { 13304 key: "_getScrollbarWidth", 13305 value: function _getScrollbarWidth() { 13306 // thx d.walsh 13307 var scrollDiv = document.createElement('div'); 13308 scrollDiv.className = CLASS_NAME_SCROLLBAR_MEASURER; 13309 document.body.appendChild(scrollDiv); 13310 var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth; 13311 document.body.removeChild(scrollDiv); 13312 return scrollbarWidth; 13313 } // Static 13314 13315 }], [{ 13316 key: "_jQueryInterface", 13317 value: function _jQueryInterface(config, relatedTarget) { 13318 return this.each(function () { 13319 var data = jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).data(DATA_KEY); 13320 13321 var _config = _objectSpread(_objectSpread(_objectSpread({}, Default), jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).data()), _typeof(config) === 'object' && config ? config : {}); 13322 13323 if (!data) { 13324 data = new Modal(this, _config); 13325 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).data(DATA_KEY, data); 13326 } 13327 13328 if (typeof config === 'string') { 13329 if (typeof data[config] === 'undefined') {
13330 throw new TypeError("No method named \"".concat(config, "\"")); 13331 } 13332 13333 data[config](relatedTarget); 13334 } else if (_config.show) { 13335 data.show(relatedTarget); 13336 } 13337 }); 13338 } 13339 }, { 13340 key: "VERSION", 13341 get: function get() { 13342 return VERSION; 13343 } 13344 }, { 13345 key: "Default", 13346 get: function get() { 13347 return Default; 13348 } 13349 }]); 13350 13351 return Modal; 13352}(); 13353/** 13354 * ------------------------------------------------------------------------ 13355 * Data Api implementation 13356 * ------------------------------------------------------------------------ 13357 */ 13358 13359 13360jquery__WEBPACK_IMPORTED_MODULE_0___default()(document).on(EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 13361 var _this11 = this; 13362 13363 var target; 13364 var selector = _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.getSelectorFromElement(this); 13365 13366 if (selector) { 13367 target = document.querySelector(selector); 13368 } 13369 13370 var config = jquery__WEBPACK_IMPORTED_MODULE_0___default()(target).data(DATA_KEY) ? 'toggle' : _objectSpread(_objectSpread({}, jquery__WEBPACK_IMPORTED_MODULE_0___default()(target).data()), jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).data()); 13371 13372 if (this.tagName === 'A' || this.tagName === 'AREA') { 13373 event.preventDefault(); 13374 } 13375 13376 var $target = jquery__WEBPACK_IMPORTED_MODULE_0___default()(target).one(EVENT_SHOW, function (showEvent) { 13377 if (showEvent.isDefaultPrevented()) { 13378 // Only register focus restorer if modal will actually get shown 13379 return; 13380 } 13381 13382 $target.one(EVENT_HIDDEN, function () { 13383 if (jquery__WEBPACK_IMPORTED_MODULE_0___default()(_this11).is(':visible')) { 13384 _this11.focus(); 13385 } 13386 }); 13387 }); 13388 13389 Modal._jQueryInterface.call(jquery__WEBPACK_IMPORTED_MODULE_0___default()(target), config, this); 13390}); 13391/** 13392 * ------------------------------------------------------------------------ 13393 * jQuery 13394 * ------------------------------------------------------------------------ 13395 */ 13396 13397(jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME] = Modal._jQueryInterface; 13398(jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME].Constructor = Modal; 13399 13400(jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME].noConflict = function () { 13401 (jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME] = JQUERY_NO_CONFLICT; 13402 return Modal._jQueryInterface; 13403}; 13404 13405/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Modal); 13406 13407/***/ }), 13408 13409/***/ 2979: 13410/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 13411 13412"use strict"; 13413__webpack_require__.r(__webpack_exports__); 13414/* harmony export */ __webpack_require__.d(__webpack_exports__, { 13415/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 13416/* harmony export */ }); 13417/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4540); 13418/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(jquery__WEBPACK_IMPORTED_MODULE_0__); 13419/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(218); 13420function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 13421 13422function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); } 13423 13424function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } } 13425 13426function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; } 13427 13428function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; } 13429 13430function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } 13431 13432/** 13433 * -------------------------------------------------------------------------- 13434 * Bootstrap (v4.5.3): tab.js 13435 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13436 * -------------------------------------------------------------------------- 13437 */ 13438 13439 13440/** 13441 * ------------------------------------------------------------------------ 13442 * Constants 13443 * ------------------------------------------------------------------------ 13444 */ 13445 13446var NAME = 'tab'; 13447var VERSION = '4.5.3'; 13448var DATA_KEY = 'bs.tab'; 13449var EVENT_KEY = ".".concat(DATA_KEY); 13450var DATA_API_KEY = '.data-api'; 13451var JQUERY_NO_CONFLICT = (jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME]; 13452var EVENT_HIDE = "hide".concat(EVENT_KEY); 13453var EVENT_HIDDEN = "hidden".concat(EVENT_KEY); 13454var EVENT_SHOW = "show".concat(EVENT_KEY); 13455var EVENT_SHOWN = "shown".concat(EVENT_KEY); 13456var EVENT_CLICK_DATA_API = "click".concat(EVENT_KEY).concat(DATA_API_KEY); 13457var CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu'; 13458var CLASS_NAME_ACTIVE = 'active'; 13459var CLASS_NAME_DISABLED = 'disabled'; 13460var CLASS_NAME_FADE = 'fade'; 13461var CLASS_NAME_SHOW = 'show'; 13462var SELECTOR_DROPDOWN = '.dropdown'; 13463var SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'; 13464var SELECTOR_ACTIVE = '.active'; 13465var SELECTOR_ACTIVE_UL = '> li > .active'; 13466var SELECTOR_DATA_TOGGLE = '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]'; 13467var SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'; 13468var SELECTOR_DROPDOWN_ACTIVE_CHILD = '> .dropdown-menu .active'; 13469/** 13470 * ------------------------------------------------------------------------ 13471 * Class Definition 13472 * ------------------------------------------------------------------------ 13473 */ 13474 13475var Tab = /*#__PURE__*/function () { 13476 function Tab(element) { 13477 _classCallCheck(this, Tab); 13478 13479 this._element = element; 13480 } // Getters 13481 13482 13483 _createClass(Tab, [{ 13484 key: "show", 13485 // Public 13486 value: function show() { 13487 var _this = this; 13488 13489 if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).hasClass(CLASS_NAME_ACTIVE) || jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).hasClass(CLASS_NAME_DISABLED)) { 13490 return; 13491 } 13492 13493 var target; 13494 var previous; 13495 var listElement = jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).closest(SELECTOR_NAV_LIST_GROUP)[0]; 13496 var selector = _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.getSelectorFromElement(this._element); 13497 13498 if (listElement) { 13499 var itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE; 13500 previous = jquery__WEBPACK_IMPORTED_MODULE_0___default().makeArray(jquery__WEBPACK_IMPORTED_MODULE_0___default()(listElement).find(itemSelector)); 13501 previous = previous[previous.length - 1]; 13502 } 13503 13504 var hideEvent = jquery__WEBPACK_IMPORTED_MODULE_0___default().Event(EVENT_HIDE, { 13505 relatedTarget: this._element 13506 }); 13507 var showEvent = jquery__WEBPACK_IMPORTED_MODULE_0___default().Event(EVENT_SHOW, { 13508 relatedTarget: previous 13509 }); 13510 13511 if (previous) { 13512 jquery__WEBPACK_IMPORTED_MODULE_0___default()(previous).trigger(hideEvent); 13513 } 13514 13515 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this._element).trigger(showEvent); 13516 13517 if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) { 13518 return; 13519 } 13520 13521 if (selector) { 13522 target = document.querySelector(selector); 13523 } 13524 13525 this._activate(this._element, listElement); 13526 13527 var complete = function complete() { 13528 var hiddenEvent = jquery__WEBPACK_IMPORTED_MODULE_0___default().Event(EVENT_HIDDEN, { 13529 relatedTarget: _this._element 13530 }); 13531 var shownEvent = jquery__WEBPACK_IMPORTED_MODULE_0___default().Event(EVENT_SHOWN, { 13532 relatedTarget: previous 13533 }); 13534 jquery__WEBPACK_IMPORTED_MODULE_0___default()(previous).trigger(hiddenEvent); 13535 jquery__WEBPACK_IMPORTED_MODULE_0___default()(_this._element).trigger(shownEvent); 13536 }; 13537 13538 if (target) { 13539 this._activate(target, target.parentNode, complete); 13540 } else { 13541 complete(); 13542 } 13543 } 13544 }, { 13545 key: "dispose", 13546 value: function dispose() { 13547 jquery__WEBPACK_IMPORTED_MODULE_0___default().removeData(this._element, DATA_KEY); 13548 this._element = null; 13549 } // Private 13550 13551 }, { 13552 key: "_activate", 13553 value: function _activate(element, container, callback) { 13554 var _this2 = this; 13555 13556 var activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? jquery__WEBPACK_IMPORTED_MODULE_0___default()(container).find(SELECTOR_ACTIVE_UL) : jquery__WEBPACK_IMPORTED_MODULE_0___default()(container).children(SELECTOR_ACTIVE); 13557 var active = activeElements[0]; 13558 var isTransitioning = callback && active && jquery__WEBPACK_IMPORTED_MODULE_0___default()(active).hasClass(CLASS_NAME_FADE); 13559 13560 var complete = function complete() { 13561 return _this2._transitionComplete(element, active, callback); 13562 }; 13563 13564 if (active && isTransitioning) { 13565 var transitionDuration = _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.getTransitionDurationFromElement(active); 13566 jquery__WEBPACK_IMPORTED_MODULE_0___default()(active).removeClass(CLASS_NAME_SHOW).one(_util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 13567 } else { 13568 complete(); 13569 } 13570 } 13571 }, { 13572 key: "_transitionComplete", 13573 value: function _transitionComplete(element, active, callback) { 13574 if (active) { 13575 jquery__WEBPACK_IMPORTED_MODULE_0___default()(active).removeClass(CLASS_NAME_ACTIVE);
13576 var dropdownChild = jquery__WEBPACK_IMPORTED_MODULE_0___default()(active.parentNode).find(SELECTOR_DROPDOWN_ACTIVE_CHILD)[0]; 13577 13578 if (dropdownChild) { 13579 jquery__WEBPACK_IMPORTED_MODULE_0___default()(dropdownChild).removeClass(CLASS_NAME_ACTIVE); 13580 } 13581 13582 if (active.getAttribute('role') === 'tab') { 13583 active.setAttribute('aria-selected', false); 13584 } 13585 } 13586 13587 jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).addClass(CLASS_NAME_ACTIVE); 13588 13589 if (element.getAttribute('role') === 'tab') { 13590 element.setAttribute('aria-selected', true); 13591 } 13592 13593 _util__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.reflow(element); 13594 13595 if (element.classList.contains(CLASS_NAME_FADE)) { 13596 element.classList.add(CLASS_NAME_SHOW); 13597 } 13598 13599 if (element.parentNode && jquery__WEBPACK_IMPORTED_MODULE_0___default()(element.parentNode).hasClass(CLASS_NAME_DROPDOWN_MENU)) { 13600 var dropdownElement = jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).closest(SELECTOR_DROPDOWN)[0]; 13601 13602 if (dropdownElement) { 13603 var dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(SELECTOR_DROPDOWN_TOGGLE)); 13604 jquery__WEBPACK_IMPORTED_MODULE_0___default()(dropdownToggleList).addClass(CLASS_NAME_ACTIVE); 13605 } 13606 13607 element.setAttribute('aria-expanded', true); 13608 } 13609 13610 if (callback) { 13611 callback(); 13612 } 13613 } // Static 13614 13615 }], [{ 13616 key: "_jQueryInterface", 13617 value: function _jQueryInterface(config) { 13618 return this.each(function () { 13619 var $this = jquery__WEBPACK_IMPORTED_MODULE_0___default()(this); 13620 var data = $this.data(DATA_KEY); 13621 13622 if (!data) { 13623 data = new Tab(this); 13624 $this.data(DATA_KEY, data); 13625 } 13626 13627 if (typeof config === 'string') { 13628 if (typeof data[config] === 'undefined') { 13629 throw new TypeError("No method named \"".concat(config, "\"")); 13630 } 13631 13632 data[config](); 13633 } 13634 }); 13635 } 13636 }, { 13637 key: "VERSION", 13638 get: function get() { 13639 return VERSION; 13640 } 13641 }]); 13642 13643 return Tab; 13644}(); 13645/** 13646 * ------------------------------------------------------------------------ 13647 * Data Api implementation 13648 * ------------------------------------------------------------------------ 13649 */ 13650 13651 13652jquery__WEBPACK_IMPORTED_MODULE_0___default()(document).on(EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 13653 event.preventDefault(); 13654 13655 Tab._jQueryInterface.call(jquery__WEBPACK_IMPORTED_MODULE_0___default()(this), 'show'); 13656}); 13657/** 13658 * ------------------------------------------------------------------------ 13659 * jQuery 13660 * ------------------------------------------------------------------------ 13661 */ 13662 13663(jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME] = Tab._jQueryInterface; 13664(jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME].Constructor = Tab; 13665 13666(jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME].noConflict = function () { 13667 (jquery__WEBPACK_IMPORTED_MODULE_0___default().fn)[NAME] = JQUERY_NO_CONFLICT; 13668 return Tab._jQueryInterface; 13669}; 13670 13671/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Tab); 13672 13673/***/ }), 13674 13675/***/ 218: 13676/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 13677 13678"use strict"; 13679/* harmony export */ __webpack_require__.d(__webpack_exports__, { 13680/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__) 13681/* harmony export */ }); 13682/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4540); 13683/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(jquery__WEBPACK_IMPORTED_MODULE_0__); 13684/** 13685 * -------------------------------------------------------------------------- 13686 * Bootstrap (v4.5.3): util.js 13687 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13688 * -------------------------------------------------------------------------- 13689 */ 13690 13691/** 13692 * ------------------------------------------------------------------------ 13693 * Private TransitionEnd Helpers 13694 * ------------------------------------------------------------------------ 13695 */ 13696 13697var TRANSITION_END = 'transitionend'; 13698var MAX_UID = 1000000; 13699var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp) 13700 13701function toType(obj) { 13702 if (obj === null || typeof obj === 'undefined') { 13703 return "".concat(obj); 13704 } 13705 13706 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 13707} 13708 13709function getSpecialTransitionEndEvent() { 13710 return { 13711 bindType: TRANSITION_END, 13712 delegateType: TRANSITION_END, 13713 handle: function handle(event) { 13714 if (jquery__WEBPACK_IMPORTED_MODULE_0___default()(event.target).is(this)) { 13715 return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params 13716 } 13717 13718 return undefined; 13719 } 13720 }; 13721} 13722 13723function transitionEndEmulator(duration) { 13724 var _this = this; 13725 13726 var called = false;
13727 jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).one(Util.TRANSITION_END, function () { 13728 called = true; 13729 }); 13730 setTimeout(function () { 13731 if (!called) { 13732 Util.triggerTransitionEnd(_this); 13733 } 13734 }, duration); 13735 return this; 13736} 13737 13738function setTransitionEndSupport() { 13739 (jquery__WEBPACK_IMPORTED_MODULE_0___default().fn).emulateTransitionEnd = transitionEndEmulator; 13740 (jquery__WEBPACK_IMPORTED_MODULE_0___default().event).special[Util.TRANSITION_END] = getSpecialTransitionEndEvent(); 13741} 13742/** 13743 * -------------------------------------------------------------------------- 13744 * Public Util Api 13745 * -------------------------------------------------------------------------- 13746 */ 13747 13748 13749var Util = { 13750 TRANSITION_END: 'bsTransitionEnd', 13751 getUID: function getUID(prefix) { 13752 do { 13753 prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here 13754 } while (document.getElementById(prefix)); 13755 13756 return prefix; 13757 }, 13758 getSelectorFromElement: function getSelectorFromElement(element) { 13759 var selector = element.getAttribute('data-target'); 13760 13761 if (!selector || selector === '#') { 13762 var hrefAttr = element.getAttribute('href'); 13763 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : ''; 13764 } 13765 13766 try { 13767 return document.querySelector(selector) ? selector : null; 13768 } catch (_) { 13769 return null; 13770 } 13771 }, 13772 getTransitionDurationFromElement: function getTransitionDurationFromElement(element) { 13773 if (!element) { 13774 return 0; 13775 } // Get transition-duration of the element 13776 13777 13778 var transitionDuration = jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).css('transition-duration'); 13779 var transitionDelay = jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).css('transition-delay'); 13780 var floatTransitionDuration = parseFloat(transitionDuration); 13781 var floatTransitionDelay = parseFloat(transitionDelay); // Return 0 if element or transition duration is not found 13782 13783 if (!floatTransitionDuration && !floatTransitionDelay) { 13784 return 0; 13785 } // If multiple durations are defined, take the first 13786 13787 13788 transitionDuration = transitionDuration.split(',')[0]; 13789 transitionDelay = transitionDelay.split(',')[0]; 13790 return (parseFloat(transitionDuration) + parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; 13791 }, 13792 reflow: function reflow(element) { 13793 return element.offsetHeight; 13794 }, 13795 triggerTransitionEnd: function triggerTransitionEnd(element) { 13796 jquery__WEBPACK_IMPORTED_MODULE_0___default()(element).trigger(TRANSITION_END); 13797 }, 13798 supportsTransitionEnd: function supportsTransitionEnd() { 13799 return Boolean(TRANSITION_END); 13800 }, 13801 isElement: function isElement(obj) { 13802 return (obj[0] || obj).nodeType; 13803 }, 13804 typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) { 13805 for (var property in configTypes) { 13806 if (Object.prototype.hasOwnProperty.call(configTypes, property)) { 13807 var expectedTypes = configTypes[property]; 13808 var value = config[property]; 13809 var valueType = value && Util.isElement(value) ? 'element' : toType(value); 13810 13811 if (!new RegExp(expectedTypes).test(valueType)) { 13812 throw new Error("".concat(componentName.toUpperCase(), ": ") + "Option \"".concat(property, "\" provided type \"").concat(valueType, "\" ") + "but expected type \"".concat(expectedTypes, "\".")); 13813 } 13814 } 13815 } 13816 }, 13817 findShadowRoot: function findShadowRoot(element) { 13818 if (!document.documentElement.attachShadow) { 13819 return null; 13820 } // Can find the shadow root otherwise it'll return the document 13821 13822 13823 if (typeof element.getRootNode === 'function') { 13824 var root = element.getRootNode(); 13825 return root instanceof ShadowRoot ? root : null; 13826 } 13827 13828 if (element instanceof ShadowRoot) { 13829 return element; 13830 } // when we don't find a shadow root 13831 13832 13833 if (!element.parentNode) { 13834 return null; 13835 } 13836 13837 return Util.findShadowRoot(element.parentNode); 13838 }, 13839 jQueryDetection: function jQueryDetection() { 13840 if (typeof (jquery__WEBPACK_IMPORTED_MODULE_0___default()) === 'undefined') { 13841 throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.'); 13842 } 13843 13844 var version = jquery__WEBPACK_IMPORTED_MODULE_0___default().fn.jquery.split(' ')[0].split('.'); 13845 var minMajor = 1; 13846 var ltMajor = 2; 13847 var minMinor = 9; 13848 var minPatch = 1; 13849 var maxMajor = 4; 13850 13851 if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >
13851= maxMajor) { 13852 throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0'); 13853 } 13854 } 13855}; 13856Util.jQueryDetection(); 13857setTransitionEndSupport(); 13858/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Util); 13859 13860/***/ }), 13861 13862/***/ 4540: 13863/***/ (function(module, exports, __webpack_require__) { 13864 13865/* module decorator */ module = __webpack_require__.nmd(module); 13866var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 13867 13868/*! 13869 * jQuery JavaScript Library v3.5.1 13870 * https://jquery.com/ 13871 * 13872 * Includes Sizzle.js 13873 * https://sizzlejs.com/ 13874 * 13875 * Copyright JS Foundation and other contributors 13876 * Released under the MIT license 13877 * https://jquery.org/license 13878 * 13879 * Date: 2020-05-04T22:49Z 13880 */ 13881(function (global, factory) { 13882 "use strict"; 13883 13884 if (( false ? 0 : _typeof(module)) === "object" && _typeof(module.exports) === "object") { 13885 // For CommonJS and CommonJS-like environments where a proper `window` 13886 // is present, execute the factory and get jQuery. 13887 // For environments that do not have a `window` with a `document` 13888 // (such as Node.js), expose a factory as module.exports. 13889 // This accentuates the need for the creation of a real `window`. 13890 // e.g. var jQuery = require("jquery")(window); 13891 // See ticket #14549 for more info. 13892 module.exports = global.document ? factory(global, true) : function (w) { 13893 if (!w.document) { 13894 throw new Error("jQuery requires a window with a document"); 13895 } 13896 13897 return factory(w); 13898 }; 13899 } else { 13900 factory(global); 13901 } // Pass this if window is not defined yet 13902 13903})(typeof window !== "undefined" ? window : this, function (window, noGlobal) { 13904 // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 13905 // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode 13906 // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common 13907 // enough that all such attempts are guarded in a try block. 13908 "use strict"; 13909 13910 var arr = []; 13911 var getProto = Object.getPrototypeOf; 13912 var _slice = arr.slice; 13913 var flat = arr.flat ? function (array) { 13914 return arr.flat.call(array); 13915 } : function (array) { 13916 return arr.concat.apply([], array); 13917 }; 13918 var push = arr.push; 13919 var indexOf = arr.indexOf; 13920 var class2type = {}; 13921 var toString = class2type.toString; 13922 var hasOwn = class2type.hasOwnProperty; 13923 var fnToString = hasOwn.toString; 13924 var ObjectFunctionString = fnToString.call(Object); 13925 var support = {}; 13926 13927 var isFunction = function isFunction(obj) { 13928 // Support: Chrome <=57, Firefox <=52 13929 // In some browsers, typeof returns "function" for HTML <object> elements 13930 // (i.e., `typeof document.createElement( "object" ) === "function"`). 13931 // We don't want to classify *any* DOM node as a function. 13932 return typeof obj === "function" && typeof obj.nodeType !== "number"; 13933 }; 13934 13935 var isWindow = function isWindow(obj) { 13936 return obj != null && obj === obj.window; 13937 }; 13938 13939 var document = window.document; 13940 var preservedScriptAttributes = { 13941 type: true, 13942 src: true, 13943 nonce: true, 13944 noModule: true 13945 }; 13946 13947 function DOMEval(code, node, doc) { 13948 doc = doc || document; 13949 var i, 13950 val, 13951 script = doc.createElement("script"); 13952 script.text = code; 13953 13954 if (node) { 13955 for (i in preservedScriptAttributes) { 13956 // Support: Firefox 64+, Edge 18+ 13957 // Some browsers don't support the "nonce" property on scripts. 13958 // On the other hand, just using `getAttribute` is not enough as 13959 // the `nonce` attribute is reset to an empty string whenever it 13960 // becomes browsing-context connected. 13961 // See https://github.com/whatwg/html/issues/2369 13962 // See https://html.spec.whatwg.org/#nonce-attributes 13963 // The `node.getAttribute` check was added for the sake of 13964 // `jQuery.globalEval` so that it can fake a nonce-containing node 13965 // via an object. 13966 val = node[i] || node.getAttribute && node.getAttribute(i); 13967 13968 if (val) { 13969 script.setAttribute(i, val); 13970 } 13971 } 13972 } 13973 13974 doc.head.appendChild(script).parentNode.removeChild(script); 13975 } 13976 13977 function toType(obj) { 13978 if (obj == null) { 13979 return obj + ""; 13980 } // Support: Android <=2.3 only (functionish RegExp) 13981 13982 13983 return _typeof(obj) === "object" || typeof obj === "function" ? class2type[toString.call(obj)] || "object" : _typeof(obj); 13984 } 13985 /* global Symbol */ 13986 // Defining this global in .eslintrc.json would create a danger of using the global 13987 // unguarded in another place, it seems safer to define global only for this module 13988 13989 13990 var version = "3.5.1", 13991 // Define a local copy of jQuery 13992 jQuery = function jQuery(selector, context) { 13993 // The jQuery object is actually just the init constructor 'enhanced' 13994 // Need init if jQuery is called (just allow error to be thrown if not included) 13995 return new jQuery.fn.init(selector, context); 13996 }; 13997 13998 jQuery.fn = jQuery.prototype = { 13999 // The current version of jQuery being used 14000 jquery: version, 14001 constructor: jQuery, 14002 // The default length of a jQuery object is 0 14003 length: 0, 14004 toArray: function toArray() { 14005 return _slice.call(this); 14006 }, 14007 // Get the Nth element in the matched element set OR 14008 // Get the whole matched element set as a clean array 14009 get: function get(num) { 14010 // Return all the elements in a clean array 14011 if (num == null) { 14012 return _slice.call(this); 14013 } // Return just the one element from the set 14014 14015 14016 return num < 0 ? this[num + this.length] : this[num]; 14017 }, 14018 // Take an array of elements and push it onto the stack 14019 // (returning the new matched element set) 14020 pushStack: function pushStack(elems) { 14021 // Build a new jQuery matched element set 14022 var ret = jQuery.merge(this.constructor(), elems); // Add the old object onto the stack (as a reference) 14023
vendor: 8,475 bytes, lines 14024-14331
14024 ret.prevObject = this; // Return the newly-formed element set 14025 14026 return ret; 14027 }, 14028 // Execute a callback for every element in the matched set. 14029 each: function each(callback) { 14030 return jQuery.each(this, callback); 14031 }, 14032 map: function map(callback) { 14033 return this.pushStack(jQuery.map(this, function (elem, i) { 14034 return callback.call(elem, i, elem); 14035 })); 14036 }, 14037 slice: function slice() { 14038 return this.pushStack(_slice.apply(this, arguments)); 14039 }, 14040 first: function first() { 14041 return this.eq(0); 14042 }, 14043 last: function last() { 14044 return this.eq(-1); 14045 }, 14046 even: function even() { 14047 return this.pushStack(jQuery.grep(this, function (_elem, i) { 14048 return (i + 1) % 2; 14049 })); 14050 }, 14051 odd: function odd() { 14052 return this.pushStack(jQuery.grep(this, function (_elem, i) { 14053 return i % 2; 14054 })); 14055 }, 14056 eq: function eq(i) { 14057 var len = this.length, 14058 j = +i + (i < 0 ? len : 0); 14059 return this.pushStack(j >= 0 && j < len ? [this[j]] : []); 14060 }, 14061 end: function end() { 14062 return this.prevObject || this.constructor(); 14063 }, 14064 // For internal use only. 14065 // Behaves like an Array's method, not like a jQuery method. 14066 push: push, 14067 sort: arr.sort, 14068 splice: arr.splice 14069 }; 14070 14071 jQuery.extend = jQuery.fn.extend = function () { 14072 var options, 14073 name, 14074 src, 14075 copy, 14076 copyIsArray, 14077 clone, 14078 target = arguments[0] || {}, 14079 i = 1, 14080 length = arguments.length, 14081 deep = false; // Handle a deep copy situation 14082 14083 if (typeof target === "boolean") { 14084 deep = target; // Skip the boolean and the target 14085 14086 target = arguments[i] || {}; 14087 i++; 14088 } // Handle case when target is a string or something (possible in deep copy) 14089 14090 14091 if (_typeof(target) !== "object" && !isFunction(target)) { 14092 target = {}; 14093 } // Extend jQuery itself if only one argument is passed 14094 14095 14096 if (i === length) { 14097 target = this; 14098 i--; 14099 } 14100 14101 for (; i < length; i++) { 14102 // Only deal with non-null/undefined values 14103 if ((options = arguments[i]) != null) { 14104 // Extend the base object 14105 for (name in options) { 14106 copy = options[name]; // Prevent Object.prototype pollution 14107 // Prevent never-ending loop 14108 14109 if (name === "__proto__" || target === copy) { 14110 continue; 14111 } // Recurse if we're merging plain objects or arrays 14112 14113 14114 if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) { 14115 src = target[name]; // Ensure proper type for the source value 14116 14117 if (copyIsArray && !Array.isArray(src)) { 14118 clone = []; 14119 } else if (!copyIsArray && !jQuery.isPlainObject(src)) { 14120 clone = {}; 14121 } else { 14122 clone = src; 14123 } 14124 14125 copyIsArray = false; // Never move original objects, clone them 14126 14127 target[name] = jQuery.extend(deep, clone, copy); // Don't bring in undefined values 14128 } else if (copy !== undefined) { 14129 target[name] = copy; 14130 } 14131 } 14132 } 14133 } // Return the modified object 14134 14135 14136 return target; 14137 }; 14138 14139 jQuery.extend({ 14140 // Unique for each copy of jQuery on the page 14141 expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""), 14142 // Assume jQuery is ready without the ready module 14143 isReady: true, 14144 error: function error(msg) { 14145 throw new Error(msg); 14146 }, 14147 noop: function noop() {}, 14148 isPlainObject: function isPlainObject(obj) { 14149 var proto, Ctor; // Detect obvious negatives 14150 // Use toString instead of jQuery.type to catch host objects 14151 14152 if (!obj || toString.call(obj) !== "[object Object]") { 14153 return false; 14154 } 14155 14156 proto = getProto(obj); // Objects with no prototype (e.g., `Object.create( null )`) are plain 14157 14158 if (!proto) { 14159 return true; 14160 } // Objects with prototype are plain iff they were constructed by a global Object function 14161 14162 14163 Ctor = hasOwn.call(proto, "constructor") && proto.constructor; 14164 return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString; 14165 }, 14166 isEmptyObject: function isEmptyObject(obj) { 14167 var name; 14168 14169 for (name in obj) { 14170 return false; 14171 } 14172 14173 return true; 14174 }, 14175 // Evaluates a script in a provided context; falls back to the global one 14176 // if not specified. 14177 globalEval: function globalEval(code, options, doc) { 14178 DOMEval(code, { 14179 nonce: options && options.nonce 14180 }, doc); 14181 }, 14182 each: function each(obj, callback) { 14183 var length, 14184 i = 0; 14185 14186 if (isArrayLike(obj)) { 14187 length = obj.length; 14188 14189 for (; i < length; i++) { 14190 if (callback.call(obj[i], i, obj[i]) === false) { 14191 break; 14192 } 14193 } 14194 } else { 14195 for (i in obj) { 14196 if (callback.call(obj[i], i, obj[i]) === false) { 14197 break; 14198 } 14199 } 14200 } 14201 14202 return obj; 14203 }, 14204 // results is for internal usage only 14205 makeArray: function makeArray(arr, results) { 14206 var ret = results || []; 14207 14208 if (arr != null) { 14209 if (isArrayLike(Object(arr))) { 14210 jQuery.merge(ret, typeof arr === "string" ? [arr] : arr); 14211 } else { 14212 push.call(ret, arr); 14213 } 14214 } 14215 14216 return ret; 14217 }, 14218 inArray: function inArray(elem, arr, i) { 14219 return arr == null ? -1 : indexOf.call(arr, elem, i); 14220 }, 14221 // Support: Android <=4.0 only, PhantomJS 1 only 14222 // push.apply(_, arraylike) throws on ancient WebKit 14223 merge: function merge(first, second) { 14224 var len = +second.length, 14225 j = 0, 14226 i = first.length; 14227 14228 for (; j < len; j++) { 14229 first[i++] = second[j]; 14230 } 14231 14232 first.length = i; 14233 return first; 14234 }, 14235 grep: function grep(elems, callback, invert) { 14236 var callbackInverse, 14237 matches = [], 14238 i = 0, 14239 length = elems.length, 14240 callbackExpect = !invert; // Go through the array, only saving the items 14241 // that pass the validator function 14242 14243 for (; i < length; i++) { 14244 callbackInverse = !callback(elems[i], i); 14245 14246 if (callbackInverse !== callbackExpect) { 14247 matches.push(elems[i]); 14248 } 14249 } 14250 14251 return matches; 14252 }, 14253 // arg is for internal usage only 14254 map: function map(elems, callback, arg) { 14255 var length, 14256 value, 14257 i = 0, 14258 ret = []; // Go through the array, translating each of the items to their new values 14259 14260 if (isArrayLike(elems)) { 14261 length = elems.length; 14262 14263 for (; i < length; i++) { 14264 value = callback(elems[i], i, arg); 14265 14266 if (value != null) { 14267 ret.push(value); 14268 } 14269 } // Go through every key on the object, 14270 14271 } else { 14272 for (i in elems) { 14273 value = callback(elems[i], i, arg); 14274 14275 if (value != null) { 14276 ret.push(value); 14277 } 14278 } 14279 } // Flatten any nested arrays 14280 14281 14282 return flat(ret); 14283 }, 14284 // A global GUID counter for objects 14285 guid: 1, 14286 // jQuery.support is not used in Core but other projects attach their 14287 // properties to it so it needs to exist. 14288 support: support 14289 }); 14290 14291 if (typeof Symbol === "function") { 14292 jQuery.fn[Symbol.iterator] = arr[Symbol.iterator]; 14293 } // Populate the class2type map 14294 14295 14296 jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function (_i, name) { 14297 class2type["[object " + name + "]"] = name.toLowerCase(); 14298 }); 14299 14300 function isArrayLike(obj) { 14301 // Support: real iOS 8.2 only (not reproducible in simulator) 14302 // `in` check used to prevent JIT error (gh-2145) 14303 // hasOwn isn't used here due to false negatives 14304 // regarding Nodelist length in IE 14305 var length = !!obj && "length" in obj && obj.length, 14306 type = toType(obj); 14307 14308 if (isFunction(obj) || isWindow(obj)) { 14309 return false; 14310 } 14311 14312 return type === "array" || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj; 14313 } 14314 14315 var Sizzle = 14316 /*! 14317 * Sizzle CSS Selector Engine v2.3.5 14318 * https://sizzlejs.com/ 14319 * 14320 * Copyright JS Foundation and other contributors 14321 * Released under the MIT license 14322 * https://js.foundation/ 14323 * 14324 * Date: 2020-03-14 14325 */ 14326 function (window) { 14327 var i, 14328 support, 14329 Expr, 14330 getText, 14331 isXML,
vendor: 30,534 bytes, lines 14332-15119
14332 tokenize, 14333 compile, 14334 select, 14335 outermostContext, 14336 sortInput, 14337 hasDuplicate, 14338 // Local document vars 14339 setDocument, 14340 document, 14341 docElem, 14342 documentIsHTML, 14343 rbuggyQSA, 14344 rbuggyMatches, 14345 matches, 14346 contains, 14347 // Instance-specific data 14348 expando = "sizzle" + 1 * new Date(), 14349 preferredDoc = window.document, 14350 dirruns = 0, 14351 done = 0, 14352 classCache = createCache(), 14353 tokenCache = createCache(), 14354 compilerCache = createCache(), 14355 nonnativeSelectorCache = createCache(), 14356 sortOrder = function sortOrder(a, b) { 14357 if (a === b) { 14358 hasDuplicate = true; 14359 } 14360 14361 return 0; 14362 }, 14363 // Instance methods 14364 hasOwn = {}.hasOwnProperty, 14365 arr = [], 14366 pop = arr.pop, 14367 pushNative = arr.push, 14368 push = arr.push, 14369 slice = arr.slice, 14370 // Use a stripped-down indexOf as it's faster than native 14371 // https://jsperf.com/thor-indexof-vs-for/5 14372 indexOf = function indexOf(list, elem) { 14373 var i = 0, 14374 len = list.length; 14375 14376 for (; i < len; i++) { 14377 if (list[i] === elem) { 14378 return i; 14379 } 14380 } 14381 14382 return -1; 14383 }, 14384 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" + "ismap|loop|multiple|open|readonly|required|scoped", 14385 // Regular expressions 14386 // http://www.w3.org/TR/css3-selectors/#whitespace 14387 whitespace = "[\\x20\\t\\r\\n\\f]", 14388 // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram 14389 identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", 14390 // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors 14391 attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + // Operator (capture 2) 14392 "*([*^$|!~]?=)" + whitespace + // "Attribute values must be CSS identifiers [capture 5] 14393 // or strings [capture 3 or capture 4]" 14394 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]", 14395 pseudos = ":(" + identifier + ")(?:\\((" + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: 14396 // 1. quoted (capture 3; capture 4 or capture 5) 14397 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + // 2. simple (capture 6) 14398 "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + // 3. anything else (capture 2) 14399 ".*" + ")\\)|)", 14400 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 14401 rwhitespace = new RegExp(whitespace + "+", "g"), 14402 rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"), 14403 rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"), 14404 rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"), 14405 rdescend = new RegExp(whitespace + "|>"), 14406 rpseudo = new RegExp(pseudos), 14407 ridentifier = new RegExp("^" + identifier + "$"), 14408 matchExpr = { 14409 "ID": new RegExp("^#(" + identifier + ")"), 14410 "CLASS": new RegExp("^\\.(" + identifier + ")"), 14411 "TAG": new RegExp("^(" + identifier + "|[*])"), 14412 "ATTR": new RegExp("^" + attributes), 14413 "PSEUDO": new RegExp("^" + pseudos), 14414 "CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"), 14415 "bool": new RegExp("^(?:" + booleans + ")$", "i"), 14416 // For use in libraries implementing .is() 14417 // We use this for POS matching in `select` 14418 "needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i") 14419 }, 14420 rhtml = /HTML$/i, 14421 rinputs = /^(?:input|select|textarea|button)$/i, 14422 rheader = /^h\d$/i, 14423 rnative = /^[^{]+\{\s*\[native \w/, 14424 // Easily-parseable/retrievable ID or TAG or CLASS selectors 14425 rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, 14426 rsibling = /[+~]/, 14427 // CSS escapes 14428 // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters 14429 runescape = new RegExp("\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g"), 14430 funescape = function funescape(escape, nonHex) { 14431 var high = "0x" + escape.slice(1) - 0x10000; 14432 return nonHex ? // Strip the backslash prefix from a non-hex escape sequence 14433 nonHex : // Replace a hexadecimal escape sequence with the encoded Unicode code point 14434 // Support: IE <=11+ 14435 // For values outside the Basic Multilingual Plane (BMP), manually construct a 14436 // surrogate pair 14437 high < 0 ? String.fromCharCode(high + 0x10000) : String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00); 14438 }, 14439 // CSS string/identifier serialization 14440 // https://drafts.csswg.org/cssom/#common-serializing-idioms 14441 rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, 14442 fcssescape = function fcssescape(ch, asCodePoint) { 14443 if (asCodePoint) { 14444 // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER 14445 if (ch === "\0") { 14446 return "\uFFFD"; 14447 } // Control characters and (dependent upon position) numbers get escaped as code points 14448 14449 14450 return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " "; 14451 } // Other potentially-special ASCII characters get backslash-escaped 14452 14453 14454 return "\\" + ch; 14455 }, 14456 // Used for iframes 14457 // See setDocument() 14458 // Removing the function wrapper causes a "Permission Denied" 14459 // error in IE 14460 unloadHandler = function unloadHandler() { 14461 setDocument(); 14462 }, 14463 inDisabledFieldset = addCombinator(function (elem) { 14464 return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset"; 14465 }, { 14466 dir: "parentNode", 14467 next: "legend" 14468 }); // Optimize for push.apply( _, NodeList ) 14469 14470 14471 try { 14472 push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes); // Support: Android<4.0 14473 // Detect silently failing push.apply 14474 // eslint-disable-next-line no-unused-expressions 14475 14476 arr[preferredDoc.childNodes.length].nodeType; 14477 } catch (e) { 14478 push = { 14479 apply: arr.length ? // Leverage slice if possible 14480 function (target, els) { 14481 pushNative.apply(target, slice.call(els)); 14482 } : // Support: IE<9 14483 // Otherwise append directly 14484 function (target, els) { 14485 var j = target.length, 14486 i = 0; // Can't trust NodeList.length 14487 14488 while (target[j++] = els[i++]) {} 14489 14490 target.length = j - 1; 14491 } 14492 }; 14493 } 14494 14495 function Sizzle(selector, context, results, seed) { 14496 var m, 14497 i, 14498 elem, 14499 nid, 14500 match, 14501 groups, 14502 newSelector, 14503 newContext = context && context.ownerDocument, 14504 // nodeType defaults to 9, since context defaults to document 14505 nodeType = context ? context.nodeType : 9; 14506 results = results || []; // Return early from calls with invalid selector or context 14507 14508 if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) { 14509 return results; 14510 } // Try to shortcut find operations (as opposed to filters) in HTML documents 14511 14512 14513 if (!seed) { 14514 setDocument(context); 14515 context = context || document; 14516 14517 if (documentIsHTML) { 14518 // If the selector is sufficiently simple, try using a "get*By*" DOM method 14519 // (excepting DocumentFragment context, where the methods don't exist) 14520 if (nodeType !== 11 && (match = rquickExpr.exec(selector))) { 14521 // ID selector 14522 if (m = match[1]) { 14523 // Document context 14524 if (nodeType === 9) { 14525 if (elem = context.getElementById(m)) { 14526 // Support: IE, Opera, Webkit 14527 // TODO: identify versions 14528 // getElementById can match elements by name instead of ID 14529 if (elem.id === m) { 14530 results.push(elem); 14531 return results; 14532 } 14533 } else { 14534 return results; 14535 } // Element context 14536 14537 } else { 14538 // Support: IE, Opera, Webkit 14539 // TODO: identify versions 14540 // getElementById can match elements by name instead of ID 14541 if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) { 14542 results.push(elem); 14543 return results; 14544 } 14545 } // Type selector 14546 14547 } else if (match[2]) { 14548 push.apply(results, context.getElementsByTagName(selector)); 14549 return results; // Class selector 14550 } else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) { 14551 push.apply(results, context.getElementsByClassName(m)); 14552 return results; 14553 } 14554 } // Take advantage of querySelectorAll 14555 14556 14557 if (support.qsa && !nonnativeSelectorCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector)) && ( // Support: IE 8 only 14558 // Exclude object elements 14559 nodeType !== 1 || context.nodeName.toLowerCase() !== "object")) { 14560 newSelector = selector; 14561 newContext = context; // qSA considers elements outside a scoping root when evaluating child or 14562 // descendant combinators, which is not what we want. 14563 // In such cases, we work around the behavior by prefixing every selector in the 14564 // list with an ID selector referencing the scope context. 14565 // The technique has to be used as well when a leading combinator is used 14566 // as such selectors are not recognized by querySelectorAll. 14567 // Thanks to Andrew Dupont for this technique. 14568 14569 if (nodeType === 1 && (rdescend.test(selector) || rcombinators.test(selector))) { 14570 // Expand context for sibling selectors 14571 newContext = rsibling.test(selector) && testContext(context.parentNode) || context; // We can use :scope instead of the ID hack if the browser 14572 // supports it & if we're not changing the context. 14573 14574 if (newContext !== context || !support.scope) { 14575 // Capture the context ID, setting it first if necessary 14576 if (nid = context.getAttribute("id")) { 14577 nid = nid.replace(rcssescape, fcssescape); 14578 } else { 14579 context.setAttribute("id", nid = expando); 14580 } 14581 } // Prefix every selector in the list 14582 14583 14584 groups = tokenize(selector); 14585 i = groups.length; 14586 14587 while (i--) { 14588 groups[i] = (nid ? "#" + nid : ":scope") + " " + toSelector(groups[i]); 14589 } 14590 14591 newSelector = groups.join(","); 14592 } 14593 14594 try { 14595 push.apply(results, newContext.querySelectorAll(newSelector)); 14596 return results; 14597 } catch (qsaError) { 14598 nonnativeSelectorCache(selector, true); 14599 } finally { 14600 if (nid === expando) { 14601 context.removeAttribute("id"); 14602 } 14603 } 14604 } 14605 } 14606 } // All others 14607 14608 14609 return select(selector.replace(rtrim, "$1"), context, results, seed); 14610 } 14611 /** 14612 * Create key-value caches of limited size 14613 * @returns {function(string, object)} Returns the Object data after storing it on itself with 14614 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) 14615 * deleting the oldest entry 14616 */ 14617 14618 14619 function createCache() { 14620 var keys = []; 14621 14622 function cache(key, value) { 14623 // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) 14624 if (keys.push(key + " ") > Expr.cacheLength) { 14625 // Only keep the most recent entries 14626 delete cache[keys.shift()]; 14627 } 14628 14629 return cache[key + " "] = value; 14630 } 14631 14632 return cache; 14633 } 14634 /** 14635 * Mark a function for special use by Sizzle 14636 * @param {Function} fn The function to mark 14637 */ 14638 14639 14640 function markFunction(fn) { 14641 fn[expando] = true; 14642 return fn; 14643 } 14644 /** 14645 * Support testing using an element 14646 * @param {Function} fn Passed the created element and returns a boolean result 14647 */ 14648 14649 14650 function assert(fn) { 14651 var el = document.createElement("fieldset"); 14652 14653 try { 14654 return !!fn(el); 14655 } catch (e) { 14656 return false; 14657 } finally { 14658 // Remove from its parent by default 14659 if (el.parentNode) { 14660 el.parentNode.removeChild(el); 14661 } // release memory in IE 14662 14663 14664 el = null; 14665 } 14666 } 14667 /** 14668 * Adds the same handler for all of the specified attrs 14669 * @param {String} attrs Pipe-separated list of attributes 14670 * @param {Function} handler The method that will be applied 14671 */ 14672 14673 14674 function addHandle(attrs, handler) { 14675 var arr = attrs.split("|"), 14676 i = arr.length; 14677 14678 while (i--) { 14679 Expr.attrHandle[arr[i]] = handler; 14680 } 14681 } 14682 /** 14683 * Checks document order of two siblings 14684 * @param {Element} a 14685 * @param {Element} b 14686 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b 14687 */ 14688 14689 14690 function siblingCheck(a, b) { 14691 var cur = b && a, 14692 diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex; // Use IE sourceIndex if available on both nodes 14693 14694 if (diff) { 14695 return diff; 14696 } // Check if b follows a 14697 14698 14699 if (cur) { 14700 while (cur = cur.nextSibling) { 14701 if (cur === b) { 14702 return -1; 14703 } 14704 } 14705 } 14706 14707 return a ? 1 : -1; 14708 } 14709 /** 14710 * Returns a function to use in pseudos for input types 14711 * @param {String} type 14712 */ 14713 14714 14715 function createInputPseudo(type) { 14716 return function (elem) { 14717 var name = elem.nodeName.toLowerCase(); 14718 return name === "input" && elem.type === type; 14719 }; 14720 } 14721 /** 14722 * Returns a function to use in pseudos for buttons 14723 * @param {String} type 14724 */ 14725 14726 14727 function createButtonPseudo(type) { 14728 return function (elem) { 14729 var name = elem.nodeName.toLowerCase(); 14730 return (name === "input" || name === "button") && elem.type === type; 14731 }; 14732 } 14733 /** 14734 * Returns a function to use in pseudos for :enabled/:disabled 14735 * @param {Boolean} disabled true for :disabled; false for :enabled 14736 */ 14737 14738 14739 function createDisabledPseudo(disabled) { 14740 // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable 14741 return function (elem) { 14742 // Only certain elements can match :enabled or :disabled 14743 // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled 14744 // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled 14745 if ("form" in elem) { 14746 // Check for inherited disabledness on relevant non-disabled elements: 14747 // * listed form-associated elements in a disabled fieldset 14748 // https://html.spec.whatwg.org/multipage/forms.html#category-listed 14749 // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled 14750 // * option elements in a disabled optgroup 14751 // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled 14752 // All such elements have a "form" property. 14753 if (elem.parentNode && elem.disabled === false) { 14754 // Option elements defer to a parent optgroup if present 14755 if ("label" in elem) { 14756 if ("label" in elem.parentNode) { 14757 return elem.parentNode.disabled === disabled; 14758 } else { 14759 return elem.disabled === disabled; 14760 } 14761 } // Support: IE 6 - 11 14762 // Use the isDisabled shortcut property to check for disabled fieldset ancestors 14763 14764 14765 return elem.isDisabled === disabled || // Where there is no isDisabled, check manually 14766 14767 /* jshint -W018 */ 14768 elem.isDisabled !== !disabled && inDisabledFieldset(elem) === disabled; 14769 } 14770 14771 return elem.disabled === disabled; // Try to winnow out elements that can't be disabled before trusting the disabled property. 14772 // Some victims get caught in our net (label, legend, menu, track), but it shouldn't 14773 // even exist on them, let alone have a boolean value. 14774 } else if ("label" in elem) { 14775 return elem.disabled === disabled; 14776 } // Remaining elements are neither :enabled nor :disabled 14777 14778 14779 return false; 14780 }; 14781 } 14782 /** 14783 * Returns a function to use in pseudos for positionals 14784 * @param {Function} fn 14785 */ 14786 14787 14788 function createPositionalPseudo(fn) { 14789 return markFunction(function (argument) { 14790 argument = +argument; 14791 return markFunction(function (seed, matches) { 14792 var j, 14793 matchIndexes = fn([], seed.length, argument), 14794 i = matchIndexes.length; // Match elements found at the specified indexes 14795 14796 while (i--) { 14797 if (seed[j = matchIndexes[i]]) { 14798 seed[j] = !(matches[j] = seed[j]); 14799 } 14800 } 14801 }); 14802 }); 14803 } 14804 /** 14805 * Checks a node for validity as a Sizzle context 14806 * @param {Element|Object=} context 14807 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value 14808 */ 14809 14810 14811 function testContext(context) { 14812 return context && typeof context.getElementsByTagName !== "undefined" && context; 14813 } // Expose support vars for convenience 14814 14815 14816 support = Sizzle.support = {}; 14817 /** 14818 * Detects XML nodes 14819 * @param {Element|Object} elem An element or a document 14820 * @returns {Boolean} True iff elem is a non-HTML XML node 14821 */ 14822 14823 isXML = Sizzle.isXML = function (elem) { 14824 var namespace = elem.namespaceURI, 14825 docElem = (elem.ownerDocument || elem).documentElement; // Support: IE <=8 14826 // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes 14827 // https://bugs.jquery.com/ticket/4833 14828 14829 return !rhtml.test(namespace || docElem && docElem.nodeName || "HTML"); 14830 }; 14831 /** 14832 * Sets document-related variables once based on the current document 14833 * @param {Element|Object} [doc] An element or document object to use to set the document 14834 * @returns {Object} Returns the current document 14835 */ 14836 14837 14838 setDocument = Sizzle.setDocument = function (node) { 14839 var hasCompare, 14840 subWindow, 14841 doc = node ? node.ownerDocument || node : preferredDoc; // Return early if doc is invalid or already selected 14842 // Support: IE 11+, Edge 17 - 18+ 14843 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 14844 // two documents; shallow comparisons work. 14845 // eslint-disable-next-line eqeqeq 14846 14847 if (doc == document || doc.nodeType !== 9 || !doc.documentElement) { 14848 return document; 14849 } // Update global variables 14850 14851 14852 document = doc; 14853 docElem = document.documentElement; 14854 documentIsHTML = !isXML(document); // Support: IE 9 - 11+, Edge 12 - 18+ 14855 // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) 14856 // Support: IE 11+, Edge 17 - 18+ 14857 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 14858 // two documents; shallow comparisons work. 14859 // eslint-disable-next-line eqeqeq 14860 14861 if (preferredDoc != document && (subWindow = document.defaultView) && subWindow.top !== subWindow) { 14862 // Support: IE 11, Edge 14863 if (subWindow.addEventListener) { 14864 subWindow.addEventListener("unload", unloadHandler, false); // Support: IE 9 - 10 only 14865 } else if (subWindow.attachEvent) { 14866 subWindow.attachEvent("onunload", unloadHandler); 14867 } 14868 } // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only, 14869 // Safari 4 - 5 only, Opera <=11.6 - 12.x only 14870 // IE/Edge & older browsers don't support the :scope pseudo-class. 14871 // Support: Safari 6.0 only 14872 // Safari 6.0 supports :scope but it's an alias of :root there. 14873 14874 14875 support.scope = assert(function (el) { 14876 docElem.appendChild(el).appendChild(document.createElement("div")); 14877 return typeof el.querySelectorAll !== "undefined" && !el.querySelectorAll(":scope fieldset div").length; 14878 }); 14879 /* Attributes 14880 ---------------------------------------------------------------------- */ 14881 // Support: IE<8 14882 // Verify that getAttribute really returns attributes and not properties 14883 // (excepting IE8 booleans) 14884 14885 support.attributes = assert(function (el) { 14886 el.className = "i"; 14887 return !el.getAttribute("className"); 14888 }); 14889 /* getElement(s)By* 14890 ---------------------------------------------------------------------- */ 14891 // Check if getElementsByTagName("*") returns only elements 14892 14893 support.getElementsByTagName = assert(function (el) { 14894 el.appendChild(document.createComment("")); 14895 return !el.getElementsByTagName("*").length; 14896 }); // Support: IE<9 14897 14898 support.getElementsByClassName = rnative.test(document.getElementsByClassName); // Support: IE<10 14899 // Check if getElementById returns elements by name 14900 // The broken getElementById methods don't pick up programmatically-set names, 14901 // so use a roundabout getElementsByName test 14902 14903 support.getById = assert(function (el) { 14904 docElem.appendChild(el).id = expando; 14905 return !document.getElementsByName || !document.getElementsByName(expando).length; 14906 }); // ID filter and find 14907 14908 if (support.getById) { 14909 Expr.filter["ID"] = function (id) { 14910 var attrId = id.replace(runescape, funescape); 14911 return function (elem) { 14912 return elem.getAttribute("id") === attrId; 14913 }; 14914 }; 14915 14916 Expr.find["ID"] = function (id, context) { 14917 if (typeof context.getElementById !== "undefined" && documentIsHTML) { 14918 var elem = context.getElementById(id); 14919 return elem ? [elem] : []; 14920 } 14921 }; 14922 } else { 14923 Expr.filter["ID"] = function (id) { 14924 var attrId = id.replace(runescape, funescape); 14925 return function (elem) { 14926 var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); 14927 return node && node.value === attrId; 14928 }; 14929 }; // Support: IE 6 - 7 only 14930 // getElementById is not reliable as a find shortcut 14931 14932 14933 Expr.find["ID"] = function (id, context) { 14934 if (typeof context.getElementById !== "undefined" && documentIsHTML) { 14935 var node, 14936 i, 14937 elems, 14938 elem = context.getElementById(id); 14939 14940 if (elem) { 14941 // Verify the id attribute 14942 node = elem.getAttributeNode("id"); 14943 14944 if (node && node.value === id) { 14945 return [elem]; 14946 } // Fall back on getElementsByName 14947 14948 14949 elems = context.getElementsByName(id); 14950 i = 0; 14951 14952 while (elem = elems[i++]) { 14953 node = elem.getAttributeNode("id"); 14954 14955 if (node && node.value === id) { 14956 return [elem]; 14957 } 14958 } 14959 } 14960 14961 return []; 14962 } 14963 }; 14964 } // Tag 14965 14966 14967 Expr.find["TAG"] = support.getElementsByTagName ? function (tag, context) { 14968 if (typeof context.getElementsByTagName !== "undefined") { 14969 return context.getElementsByTagName(tag); // DocumentFragment nodes don't have gEBTN 14970 } else if (support.qsa) { 14971 return context.querySelectorAll(tag); 14972 } 14973 } : function (tag, context) { 14974 var elem, 14975 tmp = [], 14976 i = 0, 14977 // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too 14978 results = context.getElementsByTagName(tag); // Filter out possible comments 14979 14980 if (tag === "*") { 14981 while (elem = results[i++]) { 14982 if (elem.nodeType === 1) { 14983 tmp.push(elem); 14984 } 14985 } 14986 14987 return tmp; 14988 } 14989 14990 return results; 14991 }; // Class 14992 14993 Expr.find["CLASS"] = support.getElementsByClassName && function (className, context) { 14994 if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) { 14995 return context.getElementsByClassName(className); 14996 } 14997 }; 14998 /* QSA/matchesSelector 14999 ---------------------------------------------------------------------- */ 15000 // QSA and matchesSelector support 15001 // matchesSelector(:active) reports false when true (IE9/Opera 11.5) 15002 15003 15004 rbuggyMatches = []; // qSa(:focus) reports false when true (Chrome 21) 15005 // We allow this because of a bug in IE8/9 that throws an error 15006 // whenever `document.activeElement` is accessed on an iframe 15007 // So, we allow :focus to pass through QSA all the time to avoid the IE error 15008 // See https://bugs.jquery.com/ticket/13378 15009 15010 rbuggyQSA = []; 15011 15012 if (support.qsa = rnative.test(document.querySelectorAll)) { 15013 // Build QSA regex 15014 // Regex strategy adopted from Diego Perini 15015 assert(function (el) { 15016 var input; // Select is set to empty string on purpose 15017 // This is to test IE's treatment of not explicitly 15018 // setting a boolean content attribute, 15019 // since its presence should be enough 15020 // https://bugs.jquery.com/ticket/12359 15021 15022 docElem.appendChild(el).innerHTML = "<a id='" + expando + "'></a>" + "<select id='" + expando + "-\r\\' msallowcapture=''>" + "<option selected=''></option></select>"; // Support: IE8, Opera 11-12.16 15023 // Nothing should be selected when empty strings follow ^= or $= or *= 15024 // The test attribute must be unknown in Opera but "safe" for WinRT 15025 // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section 15026 15027 if (el.querySelectorAll("[msallowcapture^='']").length) { 15028 rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")"); 15029 } // Support: IE8 15030 // Boolean attributes and "value" are not treated correctly 15031 15032 15033 if (!el.querySelectorAll("[selected]").length) { 15034 rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")"); 15035 } // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ 15036 15037 15038 if (!el.querySelectorAll("[id~=" + expando + "-]").length) { 15039 rbuggyQSA.push("~="); 15040 } // Support: IE 11+, Edge 15 - 18+ 15041 // IE 11/Edge don't find elements on a `[name='']` query in some cases. 15042 // Adding a temporary attribute to the document before the selection works 15043 // around the issue. 15044 // Interestingly, IE 10 & older don't seem to have the issue. 15045 15046 15047 input = document.createElement("input"); 15048 input.setAttribute("name", ""); 15049 el.appendChild(input); 15050 15051 if (!el.querySelectorAll("[name='']").length) { 15052 rbuggyQSA.push("\\[" + whitespace + "*name" + whitespace + "*=" + whitespace + "*(?:''|\"\")"); 15053 } // Webkit/Opera - :checked should return selected option elements 15054 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 15055 // IE8 throws error here and will not see later tests 15056 15057 15058 if (!el.querySelectorAll(":checked").length) { 15059 rbuggyQSA.push(":checked"); 15060 } // Support: Safari 8+, iOS 8+ 15061 // https://bugs.webkit.org/show_bug.cgi?id=136851 15062 // In-page `selector#id sibling-combinator selector` fails 15063 15064 15065 if (!el.querySelectorAll("a#" + expando + "+*").length) { 15066 rbuggyQSA.push(".#.+[+~]"); 15067 } // Support: Firefox <=3.6 - 5 only 15068 // Old Firefox doesn't throw on a badly-escaped identifier. 15069 15070 15071 el.querySelectorAll("\\\f"); 15072 rbuggyQSA.push("[\\r\\n\\f]"); 15073 }); 15074 assert(function (el) { 15075 el.innerHTML = "<a href='' disabled='disabled'></a>" + "<select disabled='disabled'><option/></select>"; // Support: Windows 8 Native Apps 15076 // The type and name attributes are restricted during .innerHTML assignment 15077 15078 var input = document.createElement("input"); 15079 input.setAttribute("type", "hidden"); 15080 el.appendChild(input).setAttribute("name", "D"); // Support: IE8 15081 // Enforce case-sensitivity of name attribute 15082 15083 if (el.querySelectorAll("[name=d]").length) { 15084 rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?="); 15085 } // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) 15086 // IE8 throws error here and will not see later tests 15087 15088 15089 if (el.querySelectorAll(":enabled").length !== 2) { 15090 rbuggyQSA.push(":enabled", ":disabled"); 15091 } // Support: IE9-11+ 15092 // IE's :disabled selector does not pick up the children of disabled fieldsets 15093 15094 15095 docElem.appendChild(el).disabled = true; 15096 15097 if (el.querySelectorAll(":disabled").length !== 2) { 15098 rbuggyQSA.push(":enabled", ":disabled"); 15099 } // Support: Opera 10 - 11 only 15100 // Opera 10-11 does not throw on post-comma invalid pseudos 15101 15102 15103 el.querySelectorAll("*,:x"); 15104 rbuggyQSA.push(",.*:"); 15105 }); 15106 } 15107 15108 if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) { 15109 assert(function (el) { 15110 // Check to see if it's possible to do matchesSelector 15111 // on a disconnected node (IE 9) 15112 support.disconnectedMatch = matches.call(el, "*"); // This should fail with an exception 15113 // Gecko does not error, returns false instead 15114 15115 matches.call(el, "[s!='']:x"); 15116 rbuggyMatches.push("!=", pseudos); 15117 }); 15118 } 15119
15120 rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|")); 15121 rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|")); 15122 /* Contains 15123 ---------------------------------------------------------------------- */ 15124 15125 hasCompare = rnative.test(docElem.compareDocumentPosition); // Element contains another 15126 // Purposefully self-exclusive 15127 // As in, an element does not contain itself 15128 15129 contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) { 15130 var adown = a.nodeType === 9 ? a.documentElement : a, 15131 bup = b && b.parentNode; 15132 return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16)); 15133 } : function (a, b) { 15134 if (b) { 15135 while (b = b.parentNode) { 15136 if (b === a) { 15137 return true; 15138 } 15139 } 15140 } 15141 15142 return false; 15143 }; 15144 /* Sorting 15145 ---------------------------------------------------------------------- */ 15146 // Document order sorting 15147 15148 sortOrder = hasCompare ? function (a, b) { 15149 // Flag for duplicate removal 15150 if (a === b) { 15151 hasDuplicate = true; 15152 return 0; 15153 } // Sort on method existence if only one input has compareDocumentPosition 15154 15155 15156 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; 15157 15158 if (compare) { 15159 return compare; 15160 } // Calculate position if both inputs belong to the same document 15161 // Support: IE 11+, Edge 17 - 18+ 15162 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 15163 // two documents; shallow comparisons work. 15164 // eslint-disable-next-line eqeqeq 15165 15166 15167 compare = (a.ownerDocument || a) == (b.ownerDocument || b) ? a.compareDocumentPosition(b) : // Otherwise we know they are disconnected 15168 1; // Disconnected nodes 15169 15170 if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) { 15171 // Choose the first element that is related to our preferred document 15172 // Support: IE 11+, Edge 17 - 18+ 15173 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 15174 // two documents; shallow comparisons work. 15175 // eslint-disable-next-line eqeqeq 15176 if (a == document || a.ownerDocument == preferredDoc && contains(preferredDoc, a)) { 15177 return -1; 15178 } // Support: IE 11+, Edge 17 - 18+ 15179 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 15180 // two documents; shallow comparisons work. 15181 // eslint-disable-next-line eqeqeq 15182 15183 15184 if (b == document || b.ownerDocument == preferredDoc && contains(preferredDoc, b)) { 15185 return 1; 15186 } // Maintain original order 15187 15188 15189 return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0; 15190 } 15191 15192 return compare & 4 ? -1 : 1; 15193 } : function (a, b) { 15194 // Exit early if the nodes are identical 15195 if (a === b) { 15196 hasDuplicate = true; 15197 return 0; 15198 } 15199 15200 var cur, 15201 i = 0, 15202 aup = a.parentNode, 15203 bup = b.parentNode, 15204 ap = [a], 15205 bp = [b]; // Parentless nodes are either documents or disconnected 15206 15207 if (!aup || !bup) { 15208 // Support: IE 11+, Edge 17 - 18+ 15209 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 15210 // two documents; shallow comparisons work. 15211 15212 /* eslint-disable eqeqeq */ 15213 return a == document ? -1 : b == document ? 1 : 15214 /* eslint-enable eqeqeq */ 15215 aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0; // If the nodes are siblings, we can do a quick check 15216 } else if (aup === bup) { 15217 return siblingCheck(a, b); 15218 } // Otherwise we need full lists of their ancestors for comparison 15219 15220 15221 cur = a; 15222 15223 while (cur = cur.parentNode) { 15224 ap.unshift(cur); 15225 } 15226 15227 cur = b; 15228 15229 while (cur = cur.parentNode) { 15230 bp.unshift(cur); 15231 } // Walk down the tree looking for a discrepancy 15232 15233 15234 while (ap[i] === bp[i]) { 15235 i++; 15236 } 15237 15238 return i ? // Do a sibling check if the nodes have a common ancestor 15239 siblingCheck(ap[i], bp[i]) : // Otherwise nodes in our document sort first
vendor: 4,700 bytes, lines 15240-15382
15240 // Support: IE 11+, Edge 17 - 18+ 15241 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 15242 // two documents; shallow comparisons work. 15243 15244 /* eslint-disable eqeqeq */ 15245 ap[i] == preferredDoc ? -1 : bp[i] == preferredDoc ? 1 : 15246 /* eslint-enable eqeqeq */ 15247 0; 15248 }; 15249 return document; 15250 }; 15251 15252 Sizzle.matches = function (expr, elements) { 15253 return Sizzle(expr, null, null, elements); 15254 }; 15255 15256 Sizzle.matchesSelector = function (elem, expr) { 15257 setDocument(elem); 15258 15259 if (support.matchesSelector && documentIsHTML && !nonnativeSelectorCache[expr + " "] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) { 15260 try { 15261 var ret = matches.call(elem, expr); // IE 9's matchesSelector returns false on disconnected nodes 15262 15263 if (ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document 15264 // fragment in IE 9 15265 elem.document && elem.document.nodeType !== 11) { 15266 return ret; 15267 } 15268 } catch (e) { 15269 nonnativeSelectorCache(expr, true); 15270 } 15271 } 15272 15273 return Sizzle(expr, document, null, [elem]).length > 0; 15274 }; 15275 15276 Sizzle.contains = function (context, elem) { 15277 // Set document vars if needed 15278 // Support: IE 11+, Edge 17 - 18+ 15279 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 15280 // two documents; shallow comparisons work. 15281 // eslint-disable-next-line eqeqeq 15282 if ((context.ownerDocument || context) != document) { 15283 setDocument(context); 15284 } 15285 15286 return contains(context, elem); 15287 }; 15288 15289 Sizzle.attr = function (elem, name) { 15290 // Set document vars if needed 15291 // Support: IE 11+, Edge 17 - 18+ 15292 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 15293 // two documents; shallow comparisons work. 15294 // eslint-disable-next-line eqeqeq 15295 if ((elem.ownerDocument || elem) != document) { 15296 setDocument(elem); 15297 } 15298 15299 var fn = Expr.attrHandle[name.toLowerCase()], 15300 // Don't get fooled by Object.prototype properties (jQuery #13807) 15301 val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined; 15302 return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; 15303 }; 15304 15305 Sizzle.escape = function (sel) { 15306 return (sel + "").replace(rcssescape, fcssescape); 15307 }; 15308 15309 Sizzle.error = function (msg) { 15310 throw new Error("Syntax error, unrecognized expression: " + msg); 15311 }; 15312 /** 15313 * Document sorting and removing duplicates 15314 * @param {ArrayLike} results 15315 */ 15316 15317 15318 Sizzle.uniqueSort = function (results) { 15319 var elem, 15320 duplicates = [], 15321 j = 0, 15322 i = 0; // Unless we *know* we can detect duplicates, assume their presence 15323 15324 hasDuplicate = !support.detectDuplicates; 15325 sortInput = !support.sortStable && results.slice(0); 15326 results.sort(sortOrder); 15327 15328 if (hasDuplicate) { 15329 while (elem = results[i++]) { 15330 if (elem === results[i]) { 15331 j = duplicates.push(i); 15332 } 15333 } 15334 15335 while (j--) { 15336 results.splice(duplicates[j], 1); 15337 } 15338 } // Clear input after sorting to release objects 15339 // See https://github.com/jquery/sizzle/pull/225 15340 15341 15342 sortInput = null; 15343 return results; 15344 }; 15345 /** 15346 * Utility function for retrieving the text value of an array of DOM nodes 15347 * @param {Array|Element} elem 15348 */ 15349 15350 15351 getText = Sizzle.getText = function (elem) { 15352 var node, 15353 ret = "", 15354 i = 0, 15355 nodeType = elem.nodeType; 15356 15357 if (!nodeType) { 15358 // If no nodeType, this is expected to be an array 15359 while (node = elem[i++]) { 15360 // Do not traverse comment nodes 15361 ret += getText(node); 15362 } 15363 } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) { 15364 // Use textContent for elements 15365 // innerText usage removed for consistency of new lines (jQuery #11153) 15366 if (typeof elem.textContent === "string") { 15367 return elem.textContent; 15368 } else { 15369 // Traverse its children 15370 for (elem = elem.firstChild; elem; elem = elem.nextSibling) { 15371 ret += getText(elem); 15372 } 15373 } 15374 } else if (nodeType === 3 || nodeType === 4) { 15375 return elem.nodeValue; 15376 } // Do not include comment or processing instruction nodes 15377 15378 15379 return ret; 15380 }; 15381 15382 Expr = Sizzle.selectors = {
vendor: 4,541 bytes, lines 15383-15499
15383 // Can be adjusted by the user 15384 cacheLength: 50, 15385 createPseudo: markFunction, 15386 match: matchExpr, 15387 attrHandle: {}, 15388 find: {}, 15389 relative: { 15390 ">": { 15391 dir: "parentNode", 15392 first: true 15393 }, 15394 " ": { 15395 dir: "parentNode" 15396 }, 15397 "+": { 15398 dir: "previousSibling", 15399 first: true 15400 }, 15401 "~": { 15402 dir: "previousSibling" 15403 } 15404 }, 15405 preFilter: { 15406 "ATTR": function ATTR(match) { 15407 match[1] = match[1].replace(runescape, funescape); // Move the given value to match[3] whether quoted or unquoted 15408 15409 match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape); 15410 15411 if (match[2] === "~=") { 15412 match[3] = " " + match[3] + " "; 15413 } 15414 15415 return match.slice(0, 4); 15416 }, 15417 "CHILD": function CHILD(match) { 15418 /* matches from matchExpr["CHILD"] 15419 1 type (only|nth|...) 15420 2 what (child|of-type) 15421 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 15422 4 xn-component of xn+y argument ([+-]?\d*n|) 15423 5 sign of xn-component 15424 6 x of xn-component 15425 7 sign of y-component 15426 8 y of y-component 15427 */ 15428 match[1] = match[1].toLowerCase(); 15429 15430 if (match[1].slice(0, 3) === "nth") { 15431 // nth-* requires argument 15432 if (!match[3]) { 15433 Sizzle.error(match[0]); 15434 } // numeric x and y parameters for Expr.filter.CHILD 15435 // remember that false/true cast respectively to 0/1 15436 15437 15438 match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd")); 15439 match[5] = +(match[7] + match[8] || match[3] === "odd"); // other types prohibit arguments 15440 } else if (match[3]) { 15441 Sizzle.error(match[0]); 15442 } 15443 15444 return match; 15445 }, 15446 "PSEUDO": function PSEUDO(match) { 15447 var excess, 15448 unquoted = !match[6] && match[2]; 15449 15450 if (matchExpr["CHILD"].test(match[0])) { 15451 return null; 15452 } // Accept quoted arguments as-is 15453 15454 15455 if (match[3]) { 15456 match[2] = match[4] || match[5] || ""; // Strip excess characters from unquoted arguments 15457 } else if (unquoted && rpseudo.test(unquoted) && ( // Get excess from tokenize (recursively) 15458 excess = tokenize(unquoted, true)) && ( // advance to the next closing parenthesis 15459 excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) { 15460 // excess is a negative index 15461 match[0] = match[0].slice(0, excess); 15462 match[2] = unquoted.slice(0, excess); 15463 } // Return only captures needed by the pseudo filter method (type and argument) 15464 15465 15466 return match.slice(0, 3); 15467 } 15468 }, 15469 filter: { 15470 "TAG": function TAG(nodeNameSelector) { 15471 var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase(); 15472 return nodeNameSelector === "*" ? function () { 15473 return true; 15474 } : function (elem) { 15475 return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; 15476 }; 15477 }, 15478 "CLASS": function CLASS(className) { 15479 var pattern = classCache[className + " "]; 15480 return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function (elem) { 15481 return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || ""); 15482 }); 15483 }, 15484 "ATTR": function ATTR(name, operator, check) { 15485 return function (elem) { 15486 var result = Sizzle.attr(elem, name); 15487 15488 if (result == null) { 15489 return operator === "!="; 15490 } 15491 15492 if (!operator) { 15493 return true; 15494 } 15495 15496 result += ""; 15497 /* eslint-disable max-len */ 15498 15499 return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf(check) === 0 : operator === "*=" ? check && result.indexOf(check) > -1 : operator === "$=" ? check && result.slice(-check.length) === check : operator === "~=" ? (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1 : operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" : false;
15500 /* eslint-enable max-len */ 15501 }; 15502 }, 15503 "CHILD": function CHILD(type, what, _argument, first, last) { 15504 var simple = type.slice(0, 3) !== "nth", 15505 forward = type.slice(-4) !== "last", 15506 ofType = what === "of-type"; 15507 return first === 1 && last === 0 ? // Shortcut for :nth-*(n) 15508 function (elem) { 15509 return !!elem.parentNode; 15510 } : function (elem, _context, xml) { 15511 var cache, 15512 uniqueCache, 15513 outerCache, 15514 node, 15515 nodeIndex, 15516 start, 15517 dir = simple !== forward ? "nextSibling" : "previousSibling", 15518 parent = elem.parentNode, 15519 name = ofType && elem.nodeName.toLowerCase(), 15520 useCache = !xml && !ofType, 15521 diff = false; 15522 15523 if (parent) { 15524 // :(first|last|only)-(child|of-type) 15525 if (simple) { 15526 while (dir) { 15527 node = elem; 15528 15529 while (node = node[dir]) { 15530 if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) { 15531 return false; 15532 } 15533 } // Reverse direction for :only-* (if we haven't yet done so) 15534 15535 15536 start = dir = type === "only" && !start && "nextSibling"; 15537 } 15538 15539 return true; 15540 } 15541 15542 start = [forward ? parent.firstChild : parent.lastChild]; // non-xml :nth-child(...) stores cache data on `parent` 15543 15544 if (forward && useCache) { 15545 // Seek `elem` from a previously-cached index 15546 // ...in a gzip-friendly way 15547 node = parent; 15548 outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only 15549 // Defend against cloned attroperties (jQuery gh-1709) 15550 15551 uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {}); 15552 cache = uniqueCache[type] || []; 15553 nodeIndex = cache[0] === dirruns && cache[1]; 15554 diff = nodeIndex && cache[2]; 15555 node = nodeIndex && parent.childNodes[nodeIndex]; 15556 15557 while (node = ++nodeIndex && node && node[dir] || ( // Fallback to seeking `elem` from the start 15558 diff = nodeIndex = 0) || start.pop()) { 15559 // When found, cache indexes on `parent` and break 15560 if (node.nodeType === 1 && ++diff && node === elem) { 15561 uniqueCache[type] = [dirruns, nodeIndex, diff]; 15562 break; 15563 } 15564 } 15565 } else { 15566 // Use previously-cached element index if available 15567 if (useCache) { 15568 // ...in a gzip-friendly way 15569 node = elem; 15570 outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only 15571 // Defend against cloned attroperties (jQuery gh-1709) 15572 15573 uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {}); 15574 cache = uniqueCache[type] || []; 15575 nodeIndex = cache[0] === dirruns && cache[1]; 15576 diff = nodeIndex; 15577 } // xml :nth-child(...) 15578 // or :nth-last-child(...) or :nth(-last)?-of-type(...) 15579 15580 15581 if (diff === false) { 15582 // Use the same loop as above to seek `elem` from the start 15583 while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) { 15584 if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) { 15585 // Cache the index of each encountered element 15586 if (useCache) { 15587 outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only 15588 // Defend against cloned attroperties (jQuery gh-1709) 15589 15590 uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {}); 15591 uniqueCache[type] = [dirruns, diff]; 15592 } 15593 15594 if (node === elem) { 15595 break; 15596 } 15597 } 15598 } 15599 } 15600 } // Incorporate the offset, then check against cycle size 15601 15602 15603 diff -= last; 15604 return diff === first || diff % first === 0 && diff / first >= 0; 15605 } 15606 }; 15607 }, 15608 "PSEUDO": function PSEUDO(pseudo, argument) { 15609 // pseudo-class names are case-insensitive
vendor: 8,781 bytes, lines 15610-15851
15610 // http://www.w3.org/TR/selectors/#pseudo-classes 15611 // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters 15612 // Remember that setFilters inherits from pseudos 15613 var args, 15614 fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo); // The user may use createPseudo to indicate that 15615 // arguments are needed to create the filter function 15616 // just as Sizzle does 15617 15618 if (fn[expando]) { 15619 return fn(argument); 15620 } // But maintain support for old signatures 15621 15622 15623 if (fn.length > 1) { 15624 args = [pseudo, pseudo, "", argument]; 15625 return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) { 15626 var idx, 15627 matched = fn(seed, argument), 15628 i = matched.length; 15629 15630 while (i--) { 15631 idx = indexOf(seed, matched[i]); 15632 seed[idx] = !(matches[idx] = matched[i]); 15633 } 15634 }) : function (elem) { 15635 return fn(elem, 0, args); 15636 }; 15637 } 15638 15639 return fn; 15640 } 15641 }, 15642 pseudos: { 15643 // Potentially complex pseudos 15644 "not": markFunction(function (selector) { 15645 // Trim the selector passed to compile 15646 // to avoid treating leading and trailing 15647 // spaces as combinators 15648 var input = [], 15649 results = [], 15650 matcher = compile(selector.replace(rtrim, "$1")); 15651 return matcher[expando] ? markFunction(function (seed, matches, _context, xml) { 15652 var elem, 15653 unmatched = matcher(seed, null, xml, []), 15654 i = seed.length; // Match elements unmatched by `matcher` 15655 15656 while (i--) { 15657 if (elem = unmatched[i]) { 15658 seed[i] = !(matches[i] = elem); 15659 } 15660 } 15661 }) : function (elem, _context, xml) { 15662 input[0] = elem; 15663 matcher(input, null, xml, results); // Don't keep the element (issue #299) 15664 15665 input[0] = null; 15666 return !results.pop(); 15667 }; 15668 }), 15669 "has": markFunction(function (selector) { 15670 return function (elem) { 15671 return Sizzle(selector, elem).length > 0; 15672 }; 15673 }), 15674 "contains": markFunction(function (text) { 15675 text = text.replace(runescape, funescape); 15676 return function (elem) { 15677 return (elem.textContent || getText(elem)).indexOf(text) > -1; 15678 }; 15679 }), 15680 // "Whether an element is represented by a :lang() selector 15681 // is based solely on the element's language value 15682 // being equal to the identifier C, 15683 // or beginning with the identifier C immediately followed by "-". 15684 // The matching of C against the element's language value is performed case-insensitively. 15685 // The identifier C does not have to be a valid language name." 15686 // http://www.w3.org/TR/selectors/#lang-pseudo 15687 "lang": markFunction(function (lang) { 15688 // lang value must be a valid identifier 15689 if (!ridentifier.test(lang || "")) { 15690 Sizzle.error("unsupported lang: " + lang); 15691 } 15692 15693 lang = lang.replace(runescape, funescape).toLowerCase(); 15694 return function (elem) { 15695 var elemLang; 15696 15697 do { 15698 if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) { 15699 elemLang = elemLang.toLowerCase(); 15700 return elemLang === lang || elemLang.indexOf(lang + "-") === 0; 15701 } 15702 } while ((elem = elem.parentNode) && elem.nodeType === 1); 15703 15704 return false; 15705 }; 15706 }), 15707 // Miscellaneous 15708 "target": function target(elem) { 15709 var hash = window.location && window.location.hash; 15710 return hash && hash.slice(1) === elem.id; 15711 }, 15712 "root": function root(elem) { 15713 return elem === docElem; 15714 }, 15715 "focus": function focus(elem) { 15716 return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); 15717 }, 15718 // Boolean properties 15719 "enabled": createDisabledPseudo(false), 15720 "disabled": createDisabledPseudo(true), 15721 "checked": function checked(elem) { 15722 // In CSS3, :checked should return both checked and selected elements 15723 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 15724 var nodeName = elem.nodeName.toLowerCase(); 15725 return nodeName === "input" && !!elem.checked || nodeName === "option" && !!elem.selected; 15726 }, 15727 "selected": function selected(elem) { 15728 // Accessing this property makes selected-by-default 15729 // options in Safari work properly 15730 if (elem.parentNode) { 15731 // eslint-disable-next-line no-unused-expressions 15732 elem.parentNode.selectedIndex; 15733 } 15734 15735 return elem.selected === true; 15736 }, 15737 // Contents 15738 "empty": function empty(elem) { 15739 // http://www.w3.org/TR/selectors/#empty-pseudo 15740 // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), 15741 // but not by others (comment: 8; processing instruction: 7; etc.) 15742 // nodeType < 6 works because attributes (2) do not appear as children 15743 for (elem = elem.firstChild; elem; elem = elem.nextSibling) { 15744 if (elem.nodeType < 6) { 15745 return false; 15746 } 15747 } 15748 15749 return true; 15750 }, 15751 "parent": function parent(elem) { 15752 return !Expr.pseudos["empty"](elem); 15753 }, 15754 // Element/input types 15755 "header": function header(elem) { 15756 return rheader.test(elem.nodeName); 15757 }, 15758 "input": function input(elem) { 15759 return rinputs.test(elem.nodeName); 15760 }, 15761 "button": function button(elem) { 15762 var name = elem.nodeName.toLowerCase(); 15763 return name === "input" && elem.type === "button" || name === "button"; 15764 }, 15765 "text": function text(elem) { 15766 var attr; 15767 return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && ( // Support: IE<8 15768 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" 15769 (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text"); 15770 }, 15771 // Position-in-collection 15772 "first": createPositionalPseudo(function () { 15773 return [0]; 15774 }), 15775 "last": createPositionalPseudo(function (_matchIndexes, length) { 15776 return [length - 1]; 15777 }), 15778 "eq": createPositionalPseudo(function (_matchIndexes, length, argument) { 15779 return [argument < 0 ? argument + length : argument]; 15780 }), 15781 "even": createPositionalPseudo(function (matchIndexes, length) { 15782 var i = 0; 15783 15784 for (; i < length; i += 2) { 15785 matchIndexes.push(i); 15786 } 15787 15788 return matchIndexes; 15789 }), 15790 "odd": createPositionalPseudo(function (matchIndexes, length) { 15791 var i = 1; 15792 15793 for (; i < length; i += 2) { 15794 matchIndexes.push(i); 15795 } 15796 15797 return matchIndexes; 15798 }), 15799 "lt": createPositionalPseudo(function (matchIndexes, length, argument) { 15800 var i = argument < 0 ? argument + length : argument > length ? length : argument; 15801 15802 for (; --i >= 0;) { 15803 matchIndexes.push(i); 15804 } 15805 15806 return matchIndexes; 15807 }), 15808 "gt": createPositionalPseudo(function (matchIndexes, length, argument) { 15809 var i = argument < 0 ? argument + length : argument; 15810 15811 for (; ++i < length;) { 15812 matchIndexes.push(i); 15813 } 15814 15815 return matchIndexes; 15816 }) 15817 } 15818 }; 15819 Expr.pseudos["nth"] = Expr.pseudos["eq"]; // Add button/input type pseudos 15820 15821 for (i in { 15822 radio: true, 15823 checkbox: true, 15824 file: true, 15825 password: true, 15826 image: true 15827 }) { 15828 Expr.pseudos[i] = createInputPseudo(i); 15829 } 15830 15831 for (i in { 15832 submit: true, 15833 reset: true 15834 }) { 15835 Expr.pseudos[i] = createButtonPseudo(i); 15836 } // Easy API for creating new setFilters 15837 15838 15839 function setFilters() {} 15840 15841 setFilters.prototype = Expr.filters = Expr.pseudos; 15842 Expr.setFilters = new setFilters(); 15843 15844 tokenize = Sizzle.tokenize = function (selector, parseOnly) { 15845 var matched, 15846 match, 15847 tokens, 15848 type, 15849 soFar, 15850 groups, 15851 preFilters,
15852 cached = tokenCache[selector + " "]; 15853 15854 if (cached) { 15855 return parseOnly ? 0 : cached.slice(0); 15856 } 15857 15858 soFar = selector; 15859 groups = []; 15860 preFilters = Expr.preFilter; 15861 15862 while (soFar) { 15863 // Comma and first run 15864 if (!matched || (match = rcomma.exec(soFar))) { 15865 if (match) { 15866 // Don't consume trailing commas as valid 15867 soFar = soFar.slice(match[0].length) || soFar; 15868 } 15869 15870 groups.push(tokens = []); 15871 } 15872 15873 matched = false; // Combinators 15874 15875 if (match = rcombinators.exec(soFar)) { 15876 matched = match.shift(); 15877 tokens.push({ 15878 value: matched, 15879 // Cast descendant combinators to space 15880 type: match[0].replace(rtrim, " ") 15881 }); 15882 soFar = soFar.slice(matched.length); 15883 } // Filters 15884 15885 15886 for (type in Expr.filter) { 15887 if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) { 15888 matched = match.shift(); 15889 tokens.push({ 15890 value: matched, 15891 type: type, 15892 matches: match 15893 }); 15894 soFar = soFar.slice(matched.length); 15895 } 15896 } 15897 15898 if (!matched) { 15899 break; 15900 } 15901 } // Return the length of the invalid excess 15902 // if we're just parsing 15903 // Otherwise, throw an error or return tokens 15904 15905 15906 return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : // Cache the tokens 15907 tokenCache(selector, groups).slice(0); 15908 }; 15909 15910 function toSelector(tokens) { 15911 var i = 0, 15912 len = tokens.length, 15913 selector = ""; 15914 15915 for (; i < len; i++) { 15916 selector += tokens[i].value; 15917 } 15918 15919 return selector; 15920 } 15921 15922 function addCombinator(matcher, combinator, base) { 15923 var dir = combinator.dir, 15924 skip = combinator.next, 15925 key = skip || dir, 15926 checkNonElements = base && key === "parentNode", 15927 doneName = done++; 15928 return combinator.first ? // Check against closest ancestor/preceding element 15929 function (elem, context, xml) { 15930 while (elem = elem[dir]) { 15931 if (elem.nodeType === 1 || checkNonElements) { 15932 return matcher(elem, context, xml); 15933 } 15934 } 15935 15936 return false; 15937 } : // Check against all ancestor/preceding elements 15938 function (elem, context, xml) { 15939 var oldCache, 15940 uniqueCache, 15941 outerCache, 15942 newCache = [dirruns, doneName]; // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching 15943 15944 if (xml) { 15945 while (elem = elem[dir]) { 15946 if (elem.nodeType === 1 || checkNonElements) { 15947 if (matcher(elem, context, xml)) { 15948 return true; 15949 } 15950 } 15951 } 15952 } else { 15953 while (elem = elem[dir]) { 15954 if (elem.nodeType === 1 || checkNonElements) { 15955 outerCache = elem[expando] || (elem[expando] = {}); // Support: IE <9 only 15956 // Defend against cloned attroperties (jQuery gh-1709) 15957 15958 uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {}); 15959 15960 if (skip && skip === elem.nodeName.toLowerCase()) { 15961 elem = elem[dir] || elem; 15962 } else if ((oldCache = uniqueCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) { 15963 // Assign to newCache so results back-propagate to previous elements 15964 return newCache[2] = oldCache[2]; 15965 } else { 15966 // Reuse newcache so results back-propagate to previous elements 15967 uniqueCache[key] = newCache; // A match means we're done; a fail means we have to keep checking 15968 15969 if (newCache[2] = matcher(elem, context, xml)) { 15970 return true; 15971 } 15972 } 15973 } 15974 } 15975 } 15976 15977 return false; 15978 }; 15979 } 15980 15981 function elementMatcher(matchers) { 15982 return matchers.length > 1 ? function (elem, context, xml) { 15983 var i = matchers.length; 15984 15985 while (i--) { 15986 if (!matchers[i](elem, context, xml)) { 15987 return false;
vendor: 6,780 bytes, lines 15988-16179
15988 } 15989 } 15990 15991 return true; 15992 } : matchers[0]; 15993 } 15994 15995 function multipleContexts(selector, contexts, results) { 15996 var i = 0, 15997 len = contexts.length; 15998 15999 for (; i < len; i++) { 16000 Sizzle(selector, contexts[i], results); 16001 } 16002 16003 return results; 16004 } 16005 16006 function condense(unmatched, map, filter, context, xml) { 16007 var elem, 16008 newUnmatched = [], 16009 i = 0, 16010 len = unmatched.length, 16011 mapped = map != null; 16012 16013 for (; i < len; i++) { 16014 if (elem = unmatched[i]) { 16015 if (!filter || filter(elem, context, xml)) { 16016 newUnmatched.push(elem); 16017 16018 if (mapped) { 16019 map.push(i); 16020 } 16021 } 16022 } 16023 } 16024 16025 return newUnmatched; 16026 } 16027 16028 function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) { 16029 if (postFilter && !postFilter[expando]) { 16030 postFilter = setMatcher(postFilter); 16031 } 16032 16033 if (postFinder && !postFinder[expando]) { 16034 postFinder = setMatcher(postFinder, postSelector); 16035 } 16036 16037 return markFunction(function (seed, results, context, xml) { 16038 var temp, 16039 i, 16040 elem, 16041 preMap = [], 16042 postMap = [], 16043 preexisting = results.length, 16044 // Get initial elements from seed or context 16045 elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []), 16046 // Prefilter to get matcher input, preserving a map for seed-results synchronization 16047 matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems, 16048 matcherOut = matcher ? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, 16049 postFinder || (seed ? preFilter : preexisting || postFilter) ? // ...intermediate processing is necessary 16050 [] : // ...otherwise use results directly 16051 results : matcherIn; // Find primary matches 16052 16053 if (matcher) { 16054 matcher(matcherIn, matcherOut, context, xml); 16055 } // Apply postFilter 16056 16057 16058 if (postFilter) { 16059 temp = condense(matcherOut, postMap); 16060 postFilter(temp, [], context, xml); // Un-match failing elements by moving them back to matcherIn 16061 16062 i = temp.length; 16063 16064 while (i--) { 16065 if (elem = temp[i]) { 16066 matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem); 16067 } 16068 } 16069 } 16070 16071 if (seed) { 16072 if (postFinder || preFilter) { 16073 if (postFinder) { 16074 // Get the final matcherOut by condensing this intermediate into postFinder contexts 16075 temp = []; 16076 i = matcherOut.length; 16077 16078 while (i--) { 16079 if (elem = matcherOut[i]) { 16080 // Restore matcherIn since elem is not yet a final match 16081 temp.push(matcherIn[i] = elem); 16082 } 16083 } 16084 16085 postFinder(null, matcherOut = [], temp, xml); 16086 } // Move matched elements from seed to results to keep them synchronized 16087 16088 16089 i = matcherOut.length; 16090 16091 while (i--) { 16092 if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) { 16093 seed[temp] = !(results[temp] = elem); 16094 } 16095 } 16096 } // Add elements to results, through postFinder if defined 16097 16098 } else { 16099 matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut); 16100 16101 if (postFinder) { 16102 postFinder(null, results, matcherOut, xml); 16103 } else { 16104 push.apply(results, matcherOut); 16105 } 16106 } 16107 }); 16108 } 16109 16110 function matcherFromTokens(tokens) { 16111 var checkContext, 16112 matcher, 16113 j, 16114 len = tokens.length, 16115 leadingRelative = Expr.relative[tokens[0].type], 16116 implicitRelative = leadingRelative || Expr.relative[" "], 16117 i = leadingRelative ? 1 : 0, 16118 // The foundational matcher ensures that elements are reachable from top-level context(s) 16119 matchContext = addCombinator(function (elem) { 16120 return elem === checkContext; 16121 }, implicitRelative, true), 16122 matchAnyContext = addCombinator(function (elem) { 16123 return indexOf(checkContext, elem) > -1; 16124 }, implicitRelative, true), 16125 matchers = [function (elem, context, xml) { 16126 var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml)); // Avoid hanging onto element (issue #299) 16127 16128 checkContext = null; 16129 return ret; 16130 }]; 16131 16132 for (; i < len; i++) { 16133 if (matcher = Expr.relative[tokens[i].type]) { 16134 matchers = [addCombinator(elementMatcher(matchers), matcher)]; 16135 } else { 16136 matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches); // Return special upon seeing a positional matcher 16137 16138 if (matcher[expando]) { 16139 // Find the next relative operator (if any) for proper handling 16140 j = ++i; 16141 16142 for (; j < len; j++) { 16143 if (Expr.relative[tokens[j].type]) { 16144 break; 16145 } 16146 } 16147 16148 return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector( // If the preceding token was a descendant combinator, insert an implicit any-element `*` 16149 tokens.slice(0, i - 1).concat({ 16150 value: tokens[i - 2].type === " " ? "*" : "" 16151 })).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens)); 16152 } 16153 16154 matchers.push(matcher); 16155 } 16156 } 16157 16158 return elementMatcher(matchers); 16159 } 16160 16161 function matcherFromGroupMatchers(elementMatchers, setMatchers) { 16162 var bySet = setMatchers.length > 0, 16163 byElement = elementMatchers.length > 0, 16164 superMatcher = function superMatcher(seed, context, xml, results, outermost) { 16165 var elem, 16166 j, 16167 matcher, 16168 matchedCount = 0, 16169 i = "0", 16170 unmatched = seed && [], 16171 setMatched = [], 16172 contextBackup = outermostContext, 16173 // We must always have either seed elements or outermost context 16174 elems = seed || byElement && Expr.find["TAG"]("*", outermost), 16175 // Use integer dirruns iff this is the outermost matcher 16176 dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1, 16177 len = elems.length; 16178 16179 if (outermost) {
16180 // Support: IE 11+, Edge 17 - 18+ 16181 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 16182 // two documents; shallow comparisons work. 16183 // eslint-disable-next-line eqeqeq 16184 outermostContext = context == document || context || outermost; 16185 } // Add elements passing elementMatchers directly to results 16186 // Support: IE<9, Safari 16187 // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id 16188 16189 16190 for (; i !== len && (elem = elems[i]) != null; i++) { 16191 if (byElement && elem) { 16192 j = 0; // Support: IE 11+, Edge 17 - 18+ 16193 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 16194 // two documents; shallow comparisons work. 16195 // eslint-disable-next-line eqeqeq 16196 16197 if (!context && elem.ownerDocument != document) { 16198 setDocument(elem); 16199 xml = !documentIsHTML; 16200 } 16201 16202 while (matcher = elementMatchers[j++]) { 16203 if (matcher(elem, context || document, xml)) { 16204 results.push(elem); 16205 break; 16206 } 16207 } 16208 16209 if (outermost) { 16210 dirruns = dirrunsUnique; 16211 } 16212 } // Track unmatched elements for set filters 16213 16214 16215 if (bySet) { 16216 // They will have gone through all possible matchers 16217 if (elem = !matcher && elem) { 16218 matchedCount--; 16219 } // Lengthen the array for every element, matched or not 16220 16221 16222 if (seed) { 16223 unmatched.push(elem); 16224 } 16225 } 16226 } // `i` is now the count of elements visited above, and adding it to `matchedCount` 16227 // makes the latter nonnegative. 16228 16229 16230 matchedCount += i; // Apply set filters to unmatched elements 16231 // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` 16232 // equals `i`), unless we didn't visit _any_ elements in the above loop because we have 16233 // no element matchers and no seed. 16234 // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that 16235 // case, which will result in a "00" `matchedCount` that differs from `i` but is also 16236 // numerically zero. 16237 16238 if (bySet && i !== matchedCount) { 16239 j = 0; 16240 16241 while (matcher = setMatchers[j++]) { 16242 matcher(unmatched, setMatched, context, xml); 16243 } 16244 16245 if (seed) { 16246 // Reintegrate element matches to eliminate the need for sorting 16247 if (matchedCount > 0) { 16248 while (i--) { 16249 if (!(unmatched[i] || setMatched[i])) { 16250 setMatched[i] = pop.call(results); 16251 } 16252 } 16253 } // Discard index placeholder values to get only actual matches 16254 16255 16256 setMatched = condense(setMatched); 16257 } // Add matches to results 16258 16259 16260 push.apply(results, setMatched); // Seedless set matches succeeding multiple successful matchers stipulate sorting 16261 16262 if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) { 16263 Sizzle.uniqueSort(results); 16264 } 16265 } // Override manipulation of globals by nested matchers 16266 16267 16268 if (outermost) { 16269 dirruns = dirrunsUnique; 16270 outermostContext = contextBackup; 16271 } 16272 16273 return unmatched; 16274 }; 16275 16276 return bySet ? markFunction(superMatcher) : superMatcher; 16277 } 16278 16279 compile = Sizzle.compile = function (selector, match 16280 /* Internal Use Only */ 16281 ) { 16282 var i, 16283 setMatchers = [], 16284 elementMatchers = [], 16285 cached = compilerCache[selector + " "]; 16286 16287 if (!cached) { 16288 // Generate a function of recursive functions that can be used to check each element 16289 if (!match) { 16290 match = tokenize(selector); 16291 } 16292 16293 i = match.length; 16294 16295 while (i--) { 16296 cached = matcherFromTokens(match[i]); 16297 16298 if (cached[expando]) { 16299 setMatchers.push(cached); 16300 } else { 16301 elementMatchers.push(cached); 16302 } 16303 } // Cache the compiled function 16304 16305 16306 cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers)); // Save selector and tokenization 16307 16308 cached.selector = selector; 16309 } 16310 16311 return cached; 16312 }; 16313 /** 16314 * A low-level selection function that works with Sizzle's compiled 16315 * selector functions 16316 * @param {String|Function} selector A selector or a pre-compiled 16317 * selector function built with Sizzle.compile 16318 * @param {Element} context 16319 * @param {Array} [results] 16320 * @param {Array} [seed] A set of elements to match against 16321 */ 16322 16323 16324 select = Sizzle.select = function (selector, context, results, seed) { 16325 var i, 16326 tokens, 16327 token, 16328 type, 16329 find, 16330 compiled = typeof selector === "function" && selector, 16331 match = !seed && tokenize(selector = compiled.selector || selector); 16332 results = results || []; // Try to minimize operations if there is only one selector in the list and no seed 16333 // (the latter of which guarantees us context) 16334 16335 if (match.length === 1) { 16336 // Reduce context if the leading compound selector is an ID 16337 tokens = match[0] = match[0].slice(0); 16338 16339 if (tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) { 16340 context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0]; 16341 16342 if (!context) { 16343 return results; // Precompiled matchers will still verify ancestry, so step up a level 16344 } else if (compiled) { 16345 context = context.parentNode; 16346 } 16347 16348 selector = selector.slice(tokens.shift().value.length); 16349 } // Fetch a seed set for right-to-left matching 16350 16351 16352 i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length; 16353 16354 while (i--) { 16355 token = tokens[i]; // Abort if we hit a combinator 16356 16357 if (Expr.relative[type = token.type]) { 16358 break; 16359 } 16360 16361 if (find = Expr.find[type]) { 16362 // Search, expanding context for leading sibling combinators 16363 if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testC
vendor: 6,901 bytes, lines 16363-16583
16363ontext(context.parentNode) || context)) { 16364 // If seed is empty or no tokens remain, we can return early 16365 tokens.splice(i, 1); 16366 selector = seed.length && toSelector(tokens); 16367 16368 if (!selector) { 16369 push.apply(results, seed); 16370 return results; 16371 } 16372 16373 break; 16374 } 16375 } 16376 } 16377 } // Compile and execute a filtering function if one is not provided 16378 // Provide `match` to avoid retokenization if we modified the selector above 16379 16380 16381 (compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context); 16382 return results; 16383 }; // One-time assignments 16384 // Sort stability 16385 16386 16387 support.sortStable = expando.split("").sort(sortOrder).join("") === expando; // Support: Chrome 14-35+ 16388 // Always assume duplicates if they aren't passed to the comparison function 16389 16390 support.detectDuplicates = !!hasDuplicate; // Initialize against the default document 16391 16392 setDocument(); // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) 16393 // Detached nodes confoundingly follow *each other* 16394 16395 support.sortDetached = assert(function (el) { 16396 // Should return 1, but returns 4 (following) 16397 return el.compareDocumentPosition(document.createElement("fieldset")) & 1; 16398 }); // Support: IE<8 16399 // Prevent attribute/property "interpolation" 16400 // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx 16401 16402 if (!assert(function (el) { 16403 el.innerHTML = "<a href='#'></a>"; 16404 return el.firstChild.getAttribute("href") === "#"; 16405 })) { 16406 addHandle("type|href|height|width", function (elem, name, isXML) { 16407 if (!isXML) { 16408 return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2); 16409 } 16410 }); 16411 } // Support: IE<9 16412 // Use defaultValue in place of getAttribute("value") 16413 16414 16415 if (!support.attributes || !assert(function (el) { 16416 el.innerHTML = "<input/>"; 16417 el.firstChild.setAttribute("value", ""); 16418 return el.firstChild.getAttribute("value") === ""; 16419 })) { 16420 addHandle("value", function (elem, _name, isXML) { 16421 if (!isXML && elem.nodeName.toLowerCase() === "input") { 16422 return elem.defaultValue; 16423 } 16424 }); 16425 } // Support: IE<9 16426 // Use getAttributeNode to fetch booleans when getAttribute lies 16427 16428 16429 if (!assert(function (el) { 16430 return el.getAttribute("disabled") == null; 16431 })) { 16432 addHandle(booleans, function (elem, name, isXML) { 16433 var val; 16434 16435 if (!isXML) { 16436 return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; 16437 } 16438 }); 16439 } 16440 16441 return Sizzle; 16442 }(window); 16443 16444 jQuery.find = Sizzle; 16445 jQuery.expr = Sizzle.selectors; // Deprecated 16446 16447 jQuery.expr[":"] = jQuery.expr.pseudos; 16448 jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; 16449 jQuery.text = Sizzle.getText; 16450 jQuery.isXMLDoc = Sizzle.isXML; 16451 jQuery.contains = Sizzle.contains; 16452 jQuery.escapeSelector = Sizzle.escape; 16453 16454 var dir = function dir(elem, _dir, until) { 16455 var matched = [], 16456 truncate = until !== undefined; 16457 16458 while ((elem = elem[_dir]) && elem.nodeType !== 9) { 16459 if (elem.nodeType === 1) { 16460 if (truncate && jQuery(elem).is(until)) { 16461 break; 16462 } 16463 16464 matched.push(elem); 16465 } 16466 } 16467 16468 return matched; 16469 }; 16470 16471 var _siblings = function siblings(n, elem) { 16472 var matched = []; 16473 16474 for (; n; n = n.nextSibling) { 16475 if (n.nodeType === 1 && n !== elem) { 16476 matched.push(n); 16477 } 16478 } 16479 16480 return matched; 16481 }; 16482 16483 var rneedsContext = jQuery.expr.match.needsContext; 16484 16485 function nodeName(elem, name) { 16486 return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); 16487 } 16488 16489 ; 16490 var rsingleTag = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i; // Implement the identical functionality for filter and not 16491 16492 function winnow(elements, qualifier, not) { 16493 if (isFunction(qualifier)) { 16494 return jQuery.grep(elements, function (elem, i) { 16495 return !!qualifier.call(elem, i, elem) !== not; 16496 }); 16497 } // Single element 16498 16499 16500 if (qualifier.nodeType) { 16501 return jQuery.grep(elements, function (elem) { 16502 return elem === qualifier !== not; 16503 }); 16504 } // Arraylike of elements (jQuery, arguments, Array) 16505 16506 16507 if (typeof qualifier !== "string") { 16508 return jQuery.grep(elements, function (elem) { 16509 return indexOf.call(qualifier, elem) > -1 !== not; 16510 }); 16511 } // Filtered directly for both simple and complex selectors 16512 16513 16514 return jQuery.filter(qualifier, elements, not); 16515 } 16516 16517 jQuery.filter = function (expr, elems, not) { 16518 var elem = elems[0]; 16519 16520 if (not) { 16521 expr = ":not(" + expr + ")"; 16522 } 16523 16524 if (elems.length === 1 && elem.nodeType === 1) { 16525 return jQuery.find.matchesSelector(elem, expr) ? [elem] : []; 16526 } 16527 16528 return jQuery.find.matches(expr, jQuery.grep(elems, function (elem) { 16529 return elem.nodeType === 1; 16530 })); 16531 }; 16532 16533 jQuery.fn.extend({ 16534 find: function find(selector) { 16535 var i, 16536 ret, 16537 len = this.length, 16538 self = this; 16539 16540 if (typeof selector !== "string") { 16541 return this.pushStack(jQuery(selector).filter(function () { 16542 for (i = 0; i < len; i++) { 16543 if (jQuery.contains(self[i], this)) { 16544 return true; 16545 } 16546 } 16547 })); 16548 } 16549 16550 ret = this.pushStack([]); 16551 16552 for (i = 0; i < len; i++) { 16553 jQuery.find(selector, self[i], ret); 16554 } 16555 16556 return len > 1 ? jQuery.uniqueSort(ret) : ret; 16557 }, 16558 filter: function filter(selector) { 16559 return this.pushStack(winnow(this, selector || [], false)); 16560 }, 16561 not: function not(selector) { 16562 return this.pushStack(winnow(this, selector || [], true)); 16563 }, 16564 is: function is(selector) { 16565 return !!winnow(this, // If this is a positional/relative selector, check membership in the returned set 16566 // so $("p:first").is("p:last") won't return true for a doc with two "p". 16567 typeof selector === "string" && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length; 16568 } 16569 }); // Initialize a jQuery object 16570 // A central reference to the root jQuery(document) 16571 16572 var rootjQuery, 16573 // A simple way to check for HTML strings 16574 // Prioritize #id over <tag> to avoid XSS via location.hash (#9521) 16575 // Strict HTML recognition (#11290: must start with <) 16576 // Shortcut simple #id case for speed 16577 rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, 16578 init = jQuery.fn.init = function (selector, context, root) { 16579 var match, elem; // HANDLE: $(""), $(null), $(undefined), $(false) 16580 16581 if (!selector) { 16582 return this; 16583 } // Method init() accepts an alternate rootjQuery
vendor: 9,878 bytes, lines 16584-16875
16584 // so migrate can support jQuery.sub (gh-2101) 16585 16586 16587 root = root || rootjQuery; // Handle HTML strings 16588 16589 if (typeof selector === "string") { 16590 if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) { 16591 // Assume that strings that start and end with <> are HTML and skip the regex check 16592 match = [null, selector, null]; 16593 } else { 16594 match = rquickExpr.exec(selector); 16595 } // Match html or make sure no context is specified for #id 16596 16597 16598 if (match && (match[1] || !context)) { 16599 // HANDLE: $(html) -> $(array) 16600 if (match[1]) { 16601 context = context instanceof jQuery ? context[0] : context; // Option to run scripts is true for back-compat 16602 // Intentionally let the error be thrown if parseHTML is not present 16603 16604 jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true)); // HANDLE: $(html, props) 16605 16606 if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) { 16607 for (match in context) { 16608 // Properties of context are called as methods if possible 16609 if (isFunction(this[match])) { 16610 this[match](context[match]); // ...and otherwise set as attributes 16611 } else { 16612 this.attr(match, context[match]); 16613 } 16614 } 16615 } 16616 16617 return this; // HANDLE: $(#id) 16618 } else { 16619 elem = document.getElementById(match[2]); 16620 16621 if (elem) { 16622 // Inject the element directly into the jQuery object 16623 this[0] = elem; 16624 this.length = 1; 16625 } 16626 16627 return this; 16628 } // HANDLE: $(expr, $(...)) 16629 16630 } else if (!context || context.jquery) { 16631 return (context || root).find(selector); // HANDLE: $(expr, context) 16632 // (which is just equivalent to: $(context).find(expr) 16633 } else { 16634 return this.constructor(context).find(selector); 16635 } // HANDLE: $(DOMElement) 16636 16637 } else if (selector.nodeType) { 16638 this[0] = selector; 16639 this.length = 1; 16640 return this; // HANDLE: $(function) 16641 // Shortcut for document ready 16642 } else if (isFunction(selector)) { 16643 return root.ready !== undefined ? root.ready(selector) : // Execute immediately if ready is not present 16644 selector(jQuery); 16645 } 16646 16647 return jQuery.makeArray(selector, this); 16648 }; // Give the init function the jQuery prototype for later instantiation 16649 16650 16651 init.prototype = jQuery.fn; // Initialize central reference 16652 16653 rootjQuery = jQuery(document); 16654 var rparentsprev = /^(?:parents|prev(?:Until|All))/, 16655 // Methods guaranteed to produce a unique set when starting from a unique set 16656 guaranteedUnique = { 16657 children: true, 16658 contents: true, 16659 next: true, 16660 prev: true 16661 }; 16662 jQuery.fn.extend({ 16663 has: function has(target) { 16664 var targets = jQuery(target, this), 16665 l = targets.length; 16666 return this.filter(function () { 16667 var i = 0; 16668 16669 for (; i < l; i++) { 16670 if (jQuery.contains(this, targets[i])) { 16671 return true; 16672 } 16673 } 16674 }); 16675 }, 16676 closest: function closest(selectors, context) { 16677 var cur, 16678 i = 0, 16679 l = this.length, 16680 matched = [], 16681 targets = typeof selectors !== "string" && jQuery(selectors); // Positional selectors never match, since there's no _selection_ context 16682 16683 if (!rneedsContext.test(selectors)) { 16684 for (; i < l; i++) { 16685 for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) { 16686 // Always skip document fragments 16687 if (cur.nodeType < 11 && (targets ? targets.index(cur) > -1 : // Don't pass non-elements to Sizzle 16688 cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) { 16689 matched.push(cur); 16690 break; 16691 } 16692 } 16693 } 16694 } 16695 16696 return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched); 16697 }, 16698 // Determine the position of an element within the set 16699 index: function index(elem) { 16700 // No argument, return index in parent 16701 if (!elem) { 16702 return this[0] && this[0].parentNode ? this.first().prevAll().length : -1; 16703 } // Index in selector 16704 16705 16706 if (typeof elem === "string") { 16707 return indexOf.call(jQuery(elem), this[0]); 16708 } // Locate the position of the desired element 16709 16710 16711 return indexOf.call(this, // If it receives a jQuery object, the first element is used 16712 elem.jquery ? elem[0] : elem); 16713 }, 16714 add: function add(selector, context) { 16715 return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(selector, context)))); 16716 }, 16717 addBack: function addBack(selector) { 16718 return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector)); 16719 } 16720 }); 16721 16722 function sibling(cur, dir) { 16723 while ((cur = cur[dir]) && cur.nodeType !== 1) {} 16724 16725 return cur; 16726 } 16727 16728 jQuery.each({ 16729 parent: function parent(elem) { 16730 var parent = elem.parentNode; 16731 return parent && parent.nodeType !== 11 ? parent : null; 16732 }, 16733 parents: function parents(elem) { 16734 return dir(elem, "parentNode"); 16735 }, 16736 parentsUntil: function parentsUntil(elem, _i, until) { 16737 return dir(elem, "parentNode", until); 16738 }, 16739 next: function next(elem) { 16740 return sibling(elem, "nextSibling"); 16741 }, 16742 prev: function prev(elem) { 16743 return sibling(elem, "previousSibling"); 16744 }, 16745 nextAll: function nextAll(elem) { 16746 return dir(elem, "nextSibling"); 16747 }, 16748 prevAll: function prevAll(elem) { 16749 return dir(elem, "previousSibling"); 16750 }, 16751 nextUntil: function nextUntil(elem, _i, until) { 16752 return dir(elem, "nextSibling", until); 16753 }, 16754 prevUntil: function prevUntil(elem, _i, until) { 16755 return dir(elem, "previousSibling", until); 16756 }, 16757 siblings: function siblings(elem) { 16758 return _siblings((elem.parentNode || {}).firstChild, elem); 16759 }, 16760 children: function children(elem) { 16761 return _siblings(elem.firstChild); 16762 }, 16763 contents: function contents(elem) { 16764 if (elem.contentDocument != null && // Support: IE 11+ 16765 // <object> elements with no `data` attribute has an object 16766 // `contentDocument` with a `null` prototype. 16767 getProto(elem.contentDocument)) { 16768 return elem.contentDocument; 16769 } // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only 16770 // Treat the template element as a regular one in browsers that 16771 // don't support it. 16772 16773 16774 if (nodeName(elem, "template")) { 16775 elem = elem.content || elem; 16776 } 16777 16778 return jQuery.merge([], elem.childNodes); 16779 } 16780 }, function (name, fn) { 16781 jQuery.fn[name] = function (until, selector) { 16782 var matched = jQuery.map(this, fn, until); 16783 16784 if (name.slice(-5) !== "Until") { 16785 selector = until; 16786 } 16787 16788 if (selector && typeof selector === "string") { 16789 matched = jQuery.filter(selector, matched); 16790 } 16791 16792 if (this.length > 1) { 16793 // Remove duplicates 16794 if (!guaranteedUnique[name]) { 16795 jQuery.uniqueSort(matched); 16796 } // Reverse order for parents* and prev-derivatives 16797 16798 16799 if (rparentsprev.test(name)) { 16800 matched.reverse(); 16801 } 16802 } 16803 16804 return this.pushStack(matched); 16805 }; 16806 }); 16807 var rnothtmlwhite = /[^\x20\t\r\n\f]+/g; // Convert String-formatted options into Object-formatted ones 16808 16809 function createOptions(options) { 16810 var object = {}; 16811 jQuery.each(options.match(rnothtmlwhite) || [], function (_, flag) { 16812 object[flag] = true; 16813 }); 16814 return object; 16815 } 16816 /* 16817 * Create a callback list using the following parameters: 16818 * 16819 * options: an optional list of space-separated options that will change how 16820 * the callback list behaves or a more traditional option object 16821 * 16822 * By default a callback list will act like an event callback list and can be 16823 * "fired" multiple times. 16824 * 16825 * Possible options: 16826 * 16827 * once: will ensure the callback list can only be fired once (like a Deferred) 16828 * 16829 * memory: will keep track of previous values and will call any callback added 16830 * after the list has been fired right away with the latest "memorized" 16831 * values (like a Deferred) 16832 * 16833 * unique: will ensure a callback can only be added once (no duplicate in the list) 16834 * 16835 * stopOnFalse: interrupt callings when a callback returns false 16836 * 16837 */ 16838 16839 16840 jQuery.Callbacks = function (options) { 16841 // Convert options from String-formatted to Object-formatted if needed 16842 // (we check in cache first) 16843 options = typeof options === "string" ? createOptions(options) : jQuery.extend({}, options); 16844 16845 var // Flag to know if list is currently firing 16846 firing, 16847 // Last fire value for non-forgettable lists 16848 memory, 16849 // Flag to know if list was already fired 16850 _fired, 16851 // Flag to prevent firing 16852 _locked, 16853 // Actual callback list 16854 list = [], 16855 // Queue of execution data for repeatable lists 16856 queue = [], 16857 // Index of currently firing callback (modified by add/remove as needed) 16858 firingIndex = -1, 16859 // Fire callbacks 16860 fire = function fire() { 16861 // Enforce single-firing 16862 _locked = _locked || options.once; // Execute callbacks for all pending executions, 16863 // respecting firingIndex overrides and runtime changes 16864 16865 _fired = firing = true; 16866 16867 for (; queue.length; firingIndex = -1) { 16868 memory = queue.shift(); 16869 16870 while (++firingIndex < list.length) { 16871 // Run callback and check for early termination 16872 if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) { 16873 // Jump to end and forget the data so .add doesn't re-fire 16874 firingIndex = list.length; 16875 memory = false;
16876 } 16877 } 16878 } // Forget the data if we're done with it 16879 16880 16881 if (!options.memory) { 16882 memory = false; 16883 } 16884 16885 firing = false; // Clean up if we're done firing for good 16886 16887 if (_locked) { 16888 // Keep an empty list if we have data for future add calls 16889 if (memory) { 16890 list = []; // Otherwise, this object is spent 16891 } else { 16892 list = ""; 16893 } 16894 } 16895 }, 16896 // Actual Callbacks object 16897 self = { 16898 // Add a callback or a collection of callbacks to the list 16899 add: function add() { 16900 if (list) { 16901 // If we have memory from a past run, we should fire after adding 16902 if (memory && !firing) { 16903 firingIndex = list.length - 1; 16904 queue.push(memory); 16905 } 16906 16907 (function add(args) { 16908 jQuery.each(args, function (_, arg) { 16909 if (isFunction(arg)) { 16910 if (!options.unique || !self.has(arg)) { 16911 list.push(arg); 16912 } 16913 } else if (arg && arg.length && toType(arg) !== "string") { 16914 // Inspect recursively 16915 add(arg); 16916 } 16917 }); 16918 })(arguments); 16919 16920 if (memory && !firing) { 16921 fire(); 16922 } 16923 } 16924 16925 return this; 16926 }, 16927 // Remove a callback from the list 16928 remove: function remove() { 16929 jQuery.each(arguments, function (_, arg) { 16930 var index; 16931 16932 while ((index = jQuery.inArray(arg, list, index)) > -1) { 16933 list.splice(index, 1); // Handle firing indexes 16934 16935 if (index <= firingIndex) { 16936 firingIndex--; 16937 } 16938 } 16939 }); 16940 return this; 16941 }, 16942 // Check if a given callback is in the list. 16943 // If no argument is given, return whether or not list has callbacks attached. 16944 has: function has(fn) { 16945 return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0; 16946 }, 16947 // Remove all callbacks from the list 16948 empty: function empty() { 16949 if (list) { 16950 list = []; 16951 } 16952 16953 return this; 16954 }, 16955 // Disable .fire and .add 16956 // Abort any current/pending executions 16957 // Clear all callbacks and values 16958 disable: function disable() { 16959 _locked = queue = []; 16960 list = memory = ""; 16961 return this; 16962 }, 16963 disabled: function disabled() { 16964 return !list; 16965 }, 16966 // Disable .fire 16967 // Also disable .add unless we have memory (since it would have no effect) 16968 // Abort any pending executions 16969 lock: function lock() { 16970 _locked = queue = []; 16971 16972 if (!memory && !firing) { 16973 list = memory = ""; 16974 } 16975 16976 return this; 16977 }, 16978 locked: function locked() { 16979 return !!_locked; 16980 }, 16981 // Call all callbacks with the given context and arguments 16982 fireWith: function fireWith(context, args) { 16983 if (!_locked) { 16984 args = args || []; 16985 args = [context, args.slice ? args.slice() : args]; 16986 queue.push(args); 16987 16988 if (!firing) { 16989 fire(); 16990 } 16991 } 16992 16993 return this; 16994 }, 16995 // Call all the callbacks with the given arguments 16996 fire: function fire() { 16997 self.fireWith(this, arguments); 16998 return this; 16999 }, 17000 // To know if the callbacks have already been called at least once 17001 fired: function fired() { 17002 return !!_fired; 17003 } 17004 }; 17005 17006 return self; 17007 }; 17008 17009 function Identity(v) { 17010 return v; 17011 } 17012 17013 function Thrower(ex) { 17014 throw ex; 17015 } 17016 17017 function adoptValue(value, resolve, reject, noValue) { 17018 var method; 17019 17020 try { 17021 // Check for promise aspect first to privilege synchronous behavior 17022 if (value && isFunction(method = value.promise)) { 17023 method.call(value).done(resolve).fail(reject); // Other thenables 17024 } else if (value && isFunction(method = value.then)) { 17025 method.call(value, resolve, reject); // Other non-thenables 17026 } else { 17027 // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: 17028 // * false: [ value ].slice( 0 ) => resolve( value ) 17029 // * true: [ value ].slice( 1 ) => resolve() 17030 resolve.apply(undefined, [value].slice(noValue)); 17031 } // For Promises/A+, convert exceptions into rejections 17032 // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in 17033 // Deferred#then to conditionally suppress rejection. 17034 17035 } catch (value) {
vendor: 5,677 bytes, lines 17036-17162
17036 // Support: Android 4.0 only 17037 // Strict mode functions invoked without .call/.apply get global-object context 17038 reject.apply(undefined, [value]); 17039 } 17040 } 17041 17042 jQuery.extend({ 17043 Deferred: function Deferred(func) { 17044 var tuples = [// action, add listener, callbacks, 17045 // ... .then handlers, argument index, [final state] 17046 ["notify", "progress", jQuery.Callbacks("memory"), jQuery.Callbacks("memory"), 2], ["resolve", "done", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 0, "resolved"], ["reject", "fail", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 1, "rejected"]], 17047 _state = "pending", 17048 _promise = { 17049 state: function state() { 17050 return _state; 17051 }, 17052 always: function always() { 17053 deferred.done(arguments).fail(arguments); 17054 return this; 17055 }, 17056 "catch": function _catch(fn) { 17057 return _promise.then(null, fn); 17058 }, 17059 // Keep pipe for back-compat 17060 pipe: function pipe() 17061 /* fnDone, fnFail, fnProgress */ 17062 { 17063 var fns = arguments; 17064 return jQuery.Deferred(function (newDefer) { 17065 jQuery.each(tuples, function (_i, tuple) { 17066 // Map tuples (progress, done, fail) to arguments (done, fail, progress) 17067 var fn = isFunction(fns[tuple[4]]) && fns[tuple[4]]; // deferred.progress(function() { bind to newDefer or newDefer.notify }) 17068 // deferred.done(function() { bind to newDefer or newDefer.resolve }) 17069 // deferred.fail(function() { bind to newDefer or newDefer.reject }) 17070 17071 deferred[tuple[1]](function () { 17072 var returned = fn && fn.apply(this, arguments); 17073 17074 if (returned && isFunction(returned.promise)) { 17075 returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject); 17076 } else { 17077 newDefer[tuple[0] + "With"](this, fn ? [returned] : arguments); 17078 } 17079 }); 17080 }); 17081 fns = null; 17082 }).promise(); 17083 }, 17084 then: function then(onFulfilled, onRejected, onProgress) { 17085 var maxDepth = 0; 17086 17087 function resolve(depth, deferred, handler, special) { 17088 return function () { 17089 var that = this, 17090 args = arguments, 17091 mightThrow = function mightThrow() { 17092 var returned, then; // Support: Promises/A+ section 2.3.3.3.3 17093 // https://promisesaplus.com/#point-59 17094 // Ignore double-resolution attempts 17095 17096 if (depth < maxDepth) { 17097 return; 17098 } 17099 17100 returned = handler.apply(that, args); // Support: Promises/A+ section 2.3.1 17101 // https://promisesaplus.com/#point-48 17102 17103 if (returned === deferred.promise()) { 17104 throw new TypeError("Thenable self-resolution"); 17105 } // Support: Promises/A+ sections 2.3.3.1, 3.5 17106 // https://promisesaplus.com/#point-54 17107 // https://promisesaplus.com/#point-75 17108 // Retrieve `then` only once 17109 17110 17111 then = returned && ( // Support: Promises/A+ section 2.3.4 17112 // https://promisesaplus.com/#point-64 17113 // Only check objects and functions for thenability 17114 _typeof(returned) === "object" || typeof returned === "function") && returned.then; // Handle a returned thenable 17115 17116 if (isFunction(then)) { 17117 // Special processors (notify) just wait for resolution 17118 if (special) { 17119 then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special)); // Normal processors (resolve) also hook into progress 17120 } else { 17121 // ...and disregard older resolution values 17122 maxDepth++; 17123 then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special), resolve(maxDepth, deferred, Identity, deferred.notifyWith)); 17124 } // Handle all other returned values 17125 17126 } else { 17127 // Only substitute handlers pass on context 17128 // and multiple values (non-spec behavior) 17129 if (handler !== Identity) { 17130 that = undefined; 17131 args = [returned]; 17132 } // Process the value(s) 17133 // Default process is resolve 17134 17135 17136 (special || deferred.resolveWith)(that, args); 17137 } 17138 }, 17139 // Only normal processors (resolve) catch and reject exceptions 17140 process = special ? mightThrow : function () { 17141 try { 17142 mightThrow(); 17143 } catch (e) { 17144 if (jQuery.Deferred.exceptionHook) { 17145 jQuery.Deferred.exceptionHook(e, process.stackTrace); 17146 } // Support: Promises/A+ section 2.3.3.3.4.1 17147 // https://promisesaplus.com/#point-61 17148 // Ignore post-resolution exceptions 17149 17150 17151 if (depth + 1 >= maxDepth) { 17152 // Only substitute handlers pass on context 17153 // and multiple values (non-spec behavior) 17154 if (handler !== Thrower) { 17155 that = undefined; 17156 args = [e]; 17157 } 17158 17159 deferred.rejectWith(that, args); 17160 } 17161 } 17162 };
vendor: 4,854 bytes, lines 17162-17293
17162 // Support: Promises/A+ section 2.3.3.3.1 17163 // https://promisesaplus.com/#point-57 17164 // Re-resolve promises immediately to dodge false rejection from 17165 // subsequent errors 17166 17167 17168 if (depth) { 17169 process(); 17170 } else { 17171 // Call an optional hook to record the stack, in case of exception 17172 // since it's otherwise lost when execution goes async 17173 if (jQuery.Deferred.getStackHook) { 17174 process.stackTrace = jQuery.Deferred.getStackHook(); 17175 } 17176 17177 window.setTimeout(process); 17178 } 17179 }; 17180 } 17181 17182 return jQuery.Deferred(function (newDefer) { 17183 // progress_handlers.add( ... ) 17184 tuples[0][3].add(resolve(0, newDefer, isFunction(onProgress) ? onProgress : Identity, newDefer.notifyWith)); // fulfilled_handlers.add( ... ) 17185 17186 tuples[1][3].add(resolve(0, newDefer, isFunction(onFulfilled) ? onFulfilled : Identity)); // rejected_handlers.add( ... ) 17187 17188 tuples[2][3].add(resolve(0, newDefer, isFunction(onRejected) ? onRejected : Thrower)); 17189 }).promise(); 17190 }, 17191 // Get a promise for this deferred 17192 // If obj is provided, the promise aspect is added to the object 17193 promise: function promise(obj) { 17194 return obj != null ? jQuery.extend(obj, _promise) : _promise; 17195 } 17196 }, 17197 deferred = {}; // Add list-specific methods 17198 17199 jQuery.each(tuples, function (i, tuple) { 17200 var list = tuple[2], 17201 stateString = tuple[5]; // promise.progress = list.add 17202 // promise.done = list.add 17203 // promise.fail = list.add 17204 17205 _promise[tuple[1]] = list.add; // Handle state 17206 17207 if (stateString) { 17208 list.add(function () { 17209 // state = "resolved" (i.e., fulfilled) 17210 // state = "rejected" 17211 _state = stateString; 17212 }, // rejected_callbacks.disable 17213 // fulfilled_callbacks.disable 17214 tuples[3 - i][2].disable, // rejected_handlers.disable 17215 // fulfilled_handlers.disable 17216 tuples[3 - i][3].disable, // progress_callbacks.lock 17217 tuples[0][2].lock, // progress_handlers.lock 17218 tuples[0][3].lock); 17219 } // progress_handlers.fire 17220 // fulfilled_handlers.fire 17221 // rejected_handlers.fire 17222 17223 17224 list.add(tuple[3].fire); // deferred.notify = function() { deferred.notifyWith(...) } 17225 // deferred.resolve = function() { deferred.resolveWith(...) } 17226 // deferred.reject = function() { deferred.rejectWith(...) } 17227 17228 deferred[tuple[0]] = function () { 17229 deferred[tuple[0] + "With"](this === deferred ? undefined : this, arguments); 17230 return this; 17231 }; // deferred.notifyWith = list.fireWith 17232 // deferred.resolveWith = list.fireWith 17233 // deferred.rejectWith = list.fireWith 17234 17235 17236 deferred[tuple[0] + "With"] = list.fireWith; 17237 }); // Make the deferred a promise 17238 17239 _promise.promise(deferred); // Call given func if any 17240 17241 17242 if (func) { 17243 func.call(deferred, deferred); 17244 } // All done! 17245 17246 17247 return deferred; 17248 }, 17249 // Deferred helper 17250 when: function when(singleValue) { 17251 var // count of uncompleted subordinates 17252 remaining = arguments.length, 17253 // count of unprocessed arguments 17254 i = remaining, 17255 // subordinate fulfillment data 17256 resolveContexts = Array(i), 17257 resolveValues = _slice.call(arguments), 17258 // the master Deferred 17259 master = jQuery.Deferred(), 17260 // subordinate callback factory 17261 updateFunc = function updateFunc(i) { 17262 return function (value) { 17263 resolveContexts[i] = this; 17264 resolveValues[i] = arguments.length > 1 ? _slice.call(arguments) : value; 17265 17266 if (! --remaining) { 17267 master.resolveWith(resolveContexts, resolveValues); 17268 } 17269 }; 17270 }; // Single- and empty arguments are adopted like Promise.resolve 17271 17272 17273 if (remaining <= 1) { 17274 adoptValue(singleValue, master.done(updateFunc(i)).resolve, master.reject, !remaining); // Use .then() to unwrap secondary thenables (cf. gh-3000) 17275 17276 if (master.state() === "pending" || isFunction(resolveValues[i] && resolveValues[i].then)) { 17277 return master.then(); 17278 } 17279 } // Multiple arguments are aggregated like Promise.all array elements 17280 17281 17282 while (i--) { 17283 adoptValue(resolveValues[i], updateFunc(i), master.reject); 17284 } 17285 17286 return master.promise(); 17287 } 17288 }); // These usually indicate a programmer mistake during development, 17289 // warn about them ASAP rather than swallowing them by default. 17290 17291 var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; 17292 17293 jQuery.Deferred.exceptionHook = function (error, stack) {
vendor: 16,741 bytes, lines 17294-17863
17294 // Support: IE 8 - 9 only 17295 // Console exists when dev tools are open, which can happen at any time 17296 if (window.console && window.console.warn && error && rerrorNames.test(error.name)) { 17297 window.console.warn("jQuery.Deferred exception: " + error.message, error.stack, stack); 17298 } 17299 }; 17300 17301 jQuery.readyException = function (error) { 17302 window.setTimeout(function () { 17303 throw error; 17304 }); 17305 }; // The deferred used on DOM ready 17306 17307 17308 var readyList = jQuery.Deferred(); 17309 17310 jQuery.fn.ready = function (fn) { 17311 readyList.then(fn) // Wrap jQuery.readyException in a function so that the lookup 17312 // happens at the time of error handling instead of callback 17313 // registration. 17314 ["catch"](function (error) { 17315 jQuery.readyException(error); 17316 }); 17317 return this; 17318 }; 17319 17320 jQuery.extend({ 17321 // Is the DOM ready to be used? Set to true once it occurs. 17322 isReady: false, 17323 // A counter to track how many items to wait for before 17324 // the ready event fires. See #6781 17325 readyWait: 1, 17326 // Handle when the DOM is ready 17327 ready: function ready(wait) { 17328 // Abort if there are pending holds or we're already ready 17329 if (wait === true ? --jQuery.readyWait : jQuery.isReady) { 17330 return; 17331 } // Remember that the DOM is ready 17332 17333 17334 jQuery.isReady = true; // If a normal DOM Ready event fired, decrement, and wait if need be 17335 17336 if (wait !== true && --jQuery.readyWait > 0) { 17337 return; 17338 } // If there are functions bound, to execute 17339 17340 17341 readyList.resolveWith(document, [jQuery]); 17342 } 17343 }); 17344 jQuery.ready.then = readyList.then; // The ready event handler and self cleanup method 17345 17346 function completed() { 17347 document.removeEventListener("DOMContentLoaded", completed); 17348 window.removeEventListener("load", completed); 17349 jQuery.ready(); 17350 } // Catch cases where $(document).ready() is called 17351 // after the browser event has already occurred. 17352 // Support: IE <=9 - 10 only 17353 // Older IE sometimes signals "interactive" too soon 17354 17355 17356 if (document.readyState === "complete" || document.readyState !== "loading" && !document.documentElement.doScroll) { 17357 // Handle it asynchronously to allow scripts the opportunity to delay ready 17358 window.setTimeout(jQuery.ready); 17359 } else { 17360 // Use the handy event callback 17361 document.addEventListener("DOMContentLoaded", completed); // A fallback to window.onload, that will always work 17362 17363 window.addEventListener("load", completed); 17364 } // Multifunctional method to get and set values of a collection 17365 // The value/s can optionally be executed if it's a function 17366 17367 17368 var access = function access(elems, fn, key, value, chainable, emptyGet, raw) { 17369 var i = 0, 17370 len = elems.length, 17371 bulk = key == null; // Sets many values 17372 17373 if (toType(key) === "object") { 17374 chainable = true; 17375 17376 for (i in key) { 17377 access(elems, fn, i, key[i], true, emptyGet, raw); 17378 } // Sets one value 17379 17380 } else if (value !== undefined) { 17381 chainable = true; 17382 17383 if (!isFunction(value)) { 17384 raw = true; 17385 } 17386 17387 if (bulk) { 17388 // Bulk operations run against the entire set 17389 if (raw) { 17390 fn.call(elems, value); 17391 fn = null; // ...except when executing function values 17392 } else { 17393 bulk = fn; 17394 17395 fn = function fn(elem, _key, value) { 17396 return bulk.call(jQuery(elem), value); 17397 }; 17398 } 17399 } 17400 17401 if (fn) { 17402 for (; i < len; i++) { 17403 fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key))); 17404 } 17405 } 17406 } 17407 17408 if (chainable) { 17409 return elems; 17410 } // Gets 17411 17412 17413 if (bulk) { 17414 return fn.call(elems); 17415 } 17416 17417 return len ? fn(elems[0], key) : emptyGet; 17418 }; // Matches dashed string for camelizing 17419 17420 17421 var rmsPrefix = /^-ms-/, 17422 rdashAlpha = /-([a-z])/g; // Used by camelCase as callback to replace() 17423 17424 function fcamelCase(_all, letter) { 17425 return letter.toUpperCase(); 17426 } // Convert dashed to camelCase; used by the css and data modules 17427 // Support: IE <=9 - 11, Edge 12 - 15 17428 // Microsoft forgot to hump their vendor prefix (#9572) 17429 17430 17431 function camelCase(string) { 17432 return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase); 17433 } 17434 17435 var acceptData = function acceptData(owner) { 17436 // Accepts only: 17437 // - Node 17438 // - Node.ELEMENT_NODE 17439 // - Node.DOCUMENT_NODE 17440 // - Object 17441 // - Any 17442 return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType; 17443 }; 17444 17445 function Data() { 17446 this.expando = jQuery.expando + Data.uid++; 17447 } 17448 17449 Data.uid = 1; 17450 Data.prototype = { 17451 cache: function cache(owner) { 17452 // Check if the owner object already has a cache 17453 var value = owner[this.expando]; // If not, create one 17454 17455 if (!value) { 17456 value = {}; // We can accept data for non-element nodes in modern browsers, 17457 // but we should not, see #8335. 17458 // Always return an empty object. 17459 17460 if (acceptData(owner)) { 17461 // If it is a node unlikely to be stringify-ed or looped over 17462 // use plain assignment 17463 if (owner.nodeType) { 17464 owner[this.expando] = value; // Otherwise secure it in a non-enumerable property 17465 // configurable must be true to allow the property to be 17466 // deleted when data is removed 17467 } else { 17468 Object.defineProperty(owner, this.expando, { 17469 value: value, 17470 configurable: true 17471 }); 17472 } 17473 } 17474 } 17475 17476 return value; 17477 }, 17478 set: function set(owner, data, value) { 17479 var prop, 17480 cache = this.cache(owner); // Handle: [ owner, key, value ] args 17481 // Always use camelCase key (gh-2257) 17482 17483 if (typeof data === "string") { 17484 cache[camelCase(data)] = value; // Handle: [ owner, { properties } ] args 17485 } else { 17486 // Copy the properties one-by-one to the cache object 17487 for (prop in data) { 17488 cache[camelCase(prop)] = data[prop]; 17489 } 17490 } 17491 17492 return cache; 17493 }, 17494 get: function get(owner, key) { 17495 return key === undefined ? this.cache(owner) : // Always use camelCase key (gh-2257) 17496 owner[this.expando] && owner[this.expando][camelCase(key)]; 17497 }, 17498 access: function access(owner, key, value) { 17499 // In cases where either: 17500 // 17501 // 1. No key was specified 17502 // 2. A string key was specified, but no value provided 17503 // 17504 // Take the "read" path and allow the get method to determine 17505 // which value to return, respectively either: 17506 // 17507 // 1. The entire cache object 17508 // 2. The data stored at the key 17509 // 17510 if (key === undefined || key && typeof key === "string" && value === undefined) { 17511 return this.get(owner, key); 17512 } // When the key is not a string, or both a key and value 17513 // are specified, set or extend (existing objects) with either: 17514 // 17515 // 1. An object of properties 17516 // 2. A key and value 17517 // 17518 17519 17520 this.set(owner, key, value); // Since the "set" path can have two possible entry points 17521 // return the expected data based on which path was taken[*] 17522 17523 return value !== undefined ? value : key; 17524 }, 17525 remove: function remove(owner, key) { 17526 var i, 17527 cache = owner[this.expando]; 17528 17529 if (cache === undefined) { 17530 return; 17531 } 17532 17533 if (key !== undefined) { 17534 // Support array or space separated string of keys 17535 if (Array.isArray(key)) { 17536 // If key is an array of keys... 17537 // We always set camelCase keys, so remove that. 17538 key = key.map(camelCase); 17539 } else { 17540 key = camelCase(key); // If a key with the spaces exists, use it. 17541 // Otherwise, create an array by matching non-whitespace 17542 17543 key = key in cache ? [key] : key.match(rnothtmlwhite) || []; 17544 } 17545 17546 i = key.length; 17547 17548 while (i--) { 17549 delete cache[key[i]]; 17550 } 17551 } // Remove the expando if there's no more data 17552 17553 17554 if (key === undefined || jQuery.isEmptyObject(cache)) { 17555 // Support: Chrome <=35 - 45 17556 // Webkit & Blink performance suffers when deleting properties 17557 // from DOM nodes, so set to undefined instead 17558 // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) 17559 if (owner.nodeType) { 17560 owner[this.expando] = undefined; 17561 } else { 17562 delete owner[this.expando]; 17563 } 17564 } 17565 }, 17566 hasData: function hasData(owner) { 17567 var cache = owner[this.expando]; 17568 return cache !== undefined && !jQuery.isEmptyObject(cache); 17569 } 17570 }; 17571 var dataPriv = new Data(); 17572 var dataUser = new Data(); // Implementation Summary 17573 // 17574 // 1. Enforce API surface and semantic compatibility with 1.9.x branch 17575 // 2. Improve the module's maintainability by reducing the storage 17576 // paths to a single mechanism. 17577 // 3. Use the same single mechanism to support "private" and "user" data. 17578 // 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) 17579 // 5. Avoid exposing implementation details on user objects (eg. expando properties) 17580 // 6. Provide a clear path for implementation upgrade to WeakMap in 2014 17581 17582 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, 17583 rmultiDash = /[A-Z]/g; 17584 17585 function getData(data) { 17586 if (data === "true") { 17587 return true; 17588 } 17589 17590 if (data === "false") { 17591 return false; 17592 } 17593 17594 if (data === "null") { 17595 return null; 17596 } // Only convert to a number if it doesn't change the string 17597 17598 17599 if (data === +data + "") { 17600 return +data; 17601 } 17602 17603 if (rbrace.test(data)) { 17604 return JSON.parse(data); 17605 } 17606 17607 return data; 17608 } 17609 17610 function dataAttr(elem, key, data) { 17611 var name; // If nothing was found internally, try to fetch any 17612 // data from the HTML5 data-* attribute 17613 17614 if (data === undefined && elem.nodeType === 1) { 17615 name = "data-" + key.replace(rmultiDash, "-$&").toLowerCase(); 17616 data = elem.getAttribute(name); 17617 17618 if (typeof data === "string") { 17619 try { 17620 data = getData(data); 17621 } catch (e) {} // Make sure we set the data so it isn't changed later 17622 17623 17624 dataUser.set(elem, key, data); 17625 } else { 17626 data = undefined; 17627 } 17628 } 17629 17630 return data; 17631 } 17632 17633 jQuery.extend({ 17634 hasData: function hasData(elem) { 17635 return dataUser.hasData(elem) || dataPriv.hasData(elem); 17636 }, 17637 data: function data(elem, name, _data) { 17638 return dataUser.access(elem, name, _data); 17639 }, 17640 removeData: function removeData(elem, name) { 17641 dataUser.remove(elem, name); 17642 }, 17643 // TODO: Now that all calls to _data and _removeData have been replaced 17644 // with direct calls to dataPriv methods, these can be deprecated. 17645 _data: function _data(elem, name, data) { 17646 return dataPriv.access(elem, name, data); 17647 }, 17648 _removeData: function _removeData(elem, name) { 17649 dataPriv.remove(elem, name); 17650 } 17651 }); 17652 jQuery.fn.extend({ 17653 data: function data(key, value) { 17654 var i, 17655 name, 17656 data, 17657 elem = this[0], 17658 attrs = elem && elem.attributes; // Gets all values 17659 17660 if (key === undefined) { 17661 if (this.length) { 17662 data = dataUser.get(elem); 17663 17664 if (elem.nodeType === 1 && !dataPriv.get(elem, "hasDataAttrs")) { 17665 i = attrs.length; 17666 17667 while (i--) { 17668 // Support: IE 11 only 17669 // The attrs elements can be null (#14894) 17670 if (attrs[i]) { 17671 name = attrs[i].name; 17672 17673 if (name.indexOf("data-") === 0) { 17674 name = camelCase(name.slice(5)); 17675 dataAttr(elem, name, data[name]); 17676 } 17677 } 17678 } 17679 17680 dataPriv.set(elem, "hasDataAttrs", true); 17681 } 17682 } 17683 17684 return data; 17685 } // Sets multiple values 17686 17687 17688 if (_typeof(key) === "object") { 17689 return this.each(function () { 17690 dataUser.set(this, key); 17691 }); 17692 } 17693 17694 return access(this, function (value) { 17695 var data; // The calling jQuery object (element matches) is not empty 17696 // (and therefore has an element appears at this[ 0 ]) and the 17697 // `value` parameter was not undefined. An empty jQuery object 17698 // will result in `undefined` for elem = this[ 0 ] which will 17699 // throw an exception if an attempt to read a data cache is made. 17700 17701 if (elem && value === undefined) { 17702 // Attempt to get data from the cache 17703 // The key will always be camelCased in Data 17704 data = dataUser.get(elem, key); 17705 17706 if (data !== undefined) { 17707 return data; 17708 } // Attempt to "discover" the data in 17709 // HTML5 custom data-* attrs 17710 17711 17712 data = dataAttr(elem, key); 17713 17714 if (data !== undefined) { 17715 return data; 17716 } // We tried really hard, but the data doesn't exist. 17717 17718 17719 return; 17720 } // Set the data... 17721 17722 17723 this.each(function () { 17724 // We always store the camelCased key 17725 dataUser.set(this, key, value); 17726 }); 17727 }, null, value, arguments.length > 1, null, true); 17728 }, 17729 removeData: function removeData(key) { 17730 return this.each(function () { 17731 dataUser.remove(this, key); 17732 }); 17733 } 17734 }); 17735 jQuery.extend({ 17736 queue: function queue(elem, type, data) { 17737 var queue; 17738 17739 if (elem) { 17740 type = (type || "fx") + "queue"; 17741 queue = dataPriv.get(elem, type); // Speed up dequeue by getting out quickly if this is just a lookup 17742 17743 if (data) { 17744 if (!queue || Array.isArray(data)) { 17745 queue = dataPriv.access(elem, type, jQuery.makeArray(data)); 17746 } else { 17747 queue.push(data); 17748 } 17749 } 17750 17751 return queue || []; 17752 } 17753 }, 17754 dequeue: function dequeue(elem, type) { 17755 type = type || "fx"; 17756 17757 var queue = jQuery.queue(elem, type), 17758 startLength = queue.length, 17759 fn = queue.shift(), 17760 hooks = jQuery._queueHooks(elem, type), 17761 next = function next() { 17762 jQuery.dequeue(elem, type); 17763 }; // If the fx queue is dequeued, always remove the progress sentinel 17764 17765 17766 if (fn === "inprogress") { 17767 fn = queue.shift(); 17768 startLength--; 17769 } 17770 17771 if (fn) { 17772 // Add a progress sentinel to prevent the fx queue from being 17773 // automatically dequeued 17774 if (type === "fx") { 17775 queue.unshift("inprogress"); 17776 } // Clear up the last queue stop function 17777 17778 17779 delete hooks.stop; 17780 fn.call(elem, next, hooks); 17781 } 17782 17783 if (!startLength && hooks) { 17784 hooks.empty.fire(); 17785 } 17786 }, 17787 // Not public - generate a queueHooks object, or return the current one 17788 _queueHooks: function _queueHooks(elem, type) { 17789 var key = type + "queueHooks"; 17790 return dataPriv.get(elem, key) || dataPriv.access(elem, key, { 17791 empty: jQuery.Callbacks("once memory").add(function () { 17792 dataPriv.remove(elem, [type + "queue", key]); 17793 }) 17794 }); 17795 } 17796 }); 17797 jQuery.fn.extend({ 17798 queue: function queue(type, data) { 17799 var setter = 2; 17800 17801 if (typeof type !== "string") { 17802 data = type; 17803 type = "fx"; 17804 setter--; 17805 } 17806 17807 if (arguments.length < setter) { 17808 return jQuery.queue(this[0], type); 17809 } 17810 17811 return data === undefined ? this : this.each(function () { 17812 var queue = jQuery.queue(this, type, data); // Ensure a hooks for this queue 17813 17814 jQuery._queueHooks(this, type); 17815 17816 if (type === "fx" && queue[0] !== "inprogress") { 17817 jQuery.dequeue(this, type); 17818 } 17819 }); 17820 }, 17821 dequeue: function dequeue(type) { 17822 return this.each(function () { 17823 jQuery.dequeue(this, type); 17824 }); 17825 }, 17826 clearQueue: function clearQueue(type) { 17827 return this.queue(type || "fx", []); 17828 }, 17829 // Get a promise resolved when queues of a certain type 17830 // are emptied (fx is the type by default) 17831 promise: function promise(type, obj) { 17832 var tmp, 17833 count = 1, 17834 defer = jQuery.Deferred(), 17835 elements = this, 17836 i = this.length, 17837 resolve = function resolve() { 17838 if (! --count) { 17839 defer.resolveWith(elements, [elements]); 17840 } 17841 }; 17842 17843 if (typeof type !== "string") { 17844 obj = type; 17845 type = undefined; 17846 } 17847 17848 type = type || "fx"; 17849 17850 while (i--) { 17851 tmp = dataPriv.get(elements[i], type + "queueHooks"); 17852 17853 if (tmp && tmp.empty) { 17854 count++; 17855 tmp.empty.add(resolve); 17856 } 17857 } 17858 17859 resolve(); 17860 return defer.promise(obj); 17861 } 17862 }); 17863 var pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
vendor: 4,298 bytes, lines 17864-17994
17864 var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i"); 17865 var cssExpand = ["Top", "Right", "Bottom", "Left"]; 17866 var documentElement = document.documentElement; 17867 17868 var isAttached = function isAttached(elem) { 17869 return jQuery.contains(elem.ownerDocument, elem); 17870 }, 17871 composed = { 17872 composed: true 17873 }; // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only 17874 // Check attachment across shadow DOM boundaries when possible (gh-3504) 17875 // Support: iOS 10.0-10.2 only 17876 // Early iOS 10 versions support `attachShadow` but not `getRootNode`, 17877 // leading to errors. We need to check for `getRootNode`. 17878 17879 17880 if (documentElement.getRootNode) { 17881 isAttached = function isAttached(elem) { 17882 return jQuery.contains(elem.ownerDocument, elem) || elem.getRootNode(composed) === elem.ownerDocument; 17883 }; 17884 } 17885 17886 var isHiddenWithinTree = function isHiddenWithinTree(elem, el) { 17887 // isHiddenWithinTree might be called from jQuery#filter function; 17888 // in that case, element will be second argument 17889 elem = el || elem; // Inline style trumps all 17890 17891 return elem.style.display === "none" || elem.style.display === "" && // Otherwise, check computed style 17892 // Support: Firefox <=43 - 45 17893 // Disconnected elements can have computed display: none, so first confirm that elem is 17894 // in the document. 17895 isAttached(elem) && jQuery.css(elem, "display") === "none"; 17896 }; 17897 17898 function adjustCSS(elem, prop, valueParts, tween) { 17899 var adjusted, 17900 scale, 17901 maxIterations = 20, 17902 currentValue = tween ? function () { 17903 return tween.cur(); 17904 } : function () { 17905 return jQuery.css(elem, prop, ""); 17906 }, 17907 initial = currentValue(), 17908 unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? "" : "px"), 17909 // Starting value computation is required for potential unit mismatches 17910 initialInUnit = elem.nodeType && (jQuery.cssNumber[prop] || unit !== "px" && +initial) && rcssNum.exec(jQuery.css(elem, prop)); 17911 17912 if (initialInUnit && initialInUnit[3] !== unit) { 17913 // Support: Firefox <=54 17914 // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) 17915 initial = initial / 2; // Trust units reported by jQuery.css 17916 17917 unit = unit || initialInUnit[3]; // Iteratively approximate from a nonzero starting point 17918 17919 initialInUnit = +initial || 1; 17920 17921 while (maxIterations--) { 17922 // Evaluate and update our best guess (doubling guesses that zero out). 17923 // Finish if the scale equals or crosses 1 (making the old*new product non-positive). 17924 jQuery.style(elem, prop, initialInUnit + unit); 17925 17926 if ((1 - scale) * (1 - (scale = currentValue() / initial || 0.5)) <= 0) { 17927 maxIterations = 0; 17928 } 17929 17930 initialInUnit = initialInUnit / scale; 17931 } 17932 17933 initialInUnit = initialInUnit * 2; 17934 jQuery.style(elem, prop, initialInUnit + unit); // Make sure we update the tween properties later on 17935 17936 valueParts = valueParts || []; 17937 } 17938 17939 if (valueParts) { 17940 initialInUnit = +initialInUnit || +initial || 0; // Apply relative offset (+=/-=) if specified 17941 17942 adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2]; 17943 17944 if (tween) { 17945 tween.unit = unit; 17946 tween.start = initialInUnit; 17947 tween.end = adjusted; 17948 } 17949 } 17950 17951 return adjusted; 17952 } 17953 17954 var defaultDisplayMap = {}; 17955 17956 function getDefaultDisplay(elem) { 17957 var temp, 17958 doc = elem.ownerDocument, 17959 nodeName = elem.nodeName, 17960 display = defaultDisplayMap[nodeName]; 17961 17962 if (display) { 17963 return display; 17964 } 17965 17966 temp = doc.body.appendChild(doc.createElement(nodeName)); 17967 display = jQuery.css(temp, "display"); 17968 temp.parentNode.removeChild(temp); 17969 17970 if (display === "none") { 17971 display = "block"; 17972 } 17973 17974 defaultDisplayMap[nodeName] = display; 17975 return display; 17976 } 17977 17978 function showHide(elements, show) { 17979 var display, 17980 elem, 17981 values = [], 17982 index = 0, 17983 length = elements.length; // Determine new display value for elements that need to change 17984 17985 for (; index < length; index++) { 17986 elem = elements[index]; 17987 17988 if (!elem.style) { 17989 continue; 17990 } 17991 17992 display = elem.style.display; 17993 17994 if (show) {
17995 // Since we force visibility upon cascade-hidden elements, an immediate (and slow) 17996 // check is required in this first loop unless we have a nonempty display value (either 17997 // inline or about-to-be-restored) 17998 if (display === "none") { 17999 values[index] = dataPriv.get(elem, "display") || null; 18000 18001 if (!values[index]) { 18002 elem.style.display = ""; 18003 } 18004 } 18005 18006 if (elem.style.display === "" && isHiddenWithinTree(elem)) { 18007 values[index] = getDefaultDisplay(elem); 18008 } 18009 } else { 18010 if (display !== "none") { 18011 values[index] = "none"; // Remember what we're overwriting 18012 18013 dataPriv.set(elem, "display", display); 18014 } 18015 } 18016 } // Set the display of the elements in a second loop to avoid constant reflow 18017 18018 18019 for (index = 0; index < length; index++) { 18020 if (values[index] != null) { 18021 elements[index].style.display = values[index]; 18022 } 18023 } 18024 18025 return elements; 18026 } 18027 18028 jQuery.fn.extend({ 18029 show: function show() { 18030 return showHide(this, true); 18031 }, 18032 hide: function hide() { 18033 return showHide(this); 18034 }, 18035 toggle: function toggle(state) { 18036 if (typeof state === "boolean") { 18037 return state ? this.show() : this.hide(); 18038 } 18039 18040 return this.each(function () { 18041 if (isHiddenWithinTree(this)) { 18042 jQuery(this).show(); 18043 } else { 18044 jQuery(this).hide(); 18045 } 18046 }); 18047 } 18048 }); 18049 var rcheckableType = /^(?:checkbox|radio)$/i; 18050 var rtagName = /<([a-z][^\/\0>\x20\t\r\n\f]*)/i; 18051 var rscriptType = /^$|^module$|\/(?:java|ecma)script/i; 18052 18053 (function () { 18054 var fragment = document.createDocumentFragment(), 18055 div = fragment.appendChild(document.createElement("div")), 18056 input = document.createElement("input"); // Support: Android 4.0 - 4.3 only 18057 // Check state lost if the name is set (#11217) 18058 // Support: Windows Web Apps (WWA) 18059 // `name` and `type` must use .setAttribute for WWA (#14901) 18060 18061 input.setAttribute("type", "radio"); 18062 input.setAttribute("checked", "checked"); 18063 input.setAttribute("name", "t"); 18064 div.appendChild(input); // Support: Android <=4.1 only
vendor: 4,826 bytes, lines 18065-18222
18065 // Older WebKit doesn't clone checked state correctly in fragments 18066 18067 support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked; // Support: IE <=11 only 18068 // Make sure textarea (and checkbox) defaultValue is properly cloned 18069 18070 div.innerHTML = "<textarea>x</textarea>"; 18071 support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue; // Support: IE <=9 only 18072 // IE <=9 replaces <option> tags with their contents when inserted outside of 18073 // the select element. 18074 18075 div.innerHTML = "<option></option>"; 18076 support.option = !!div.lastChild; 18077 })(); // We have to close these tags to support XHTML (#13200) 18078 18079 18080 var wrapMap = { 18081 // XHTML parsers do not magically insert elements in the 18082 // same way that tag soup parsers do. So we cannot shorten 18083 // this by omitting <tbody> or other required elements. 18084 thead: [1, "<table>", "</table>"], 18085 col: [2, "<table><colgroup>", "</colgroup></table>"], 18086 tr: [2, "<table><tbody>", "</tbody></table>"], 18087 td: [3, "<table><tbody><tr>", "</tr></tbody></table>"], 18088 _default: [0, "", ""] 18089 }; 18090 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; 18091 wrapMap.th = wrapMap.td; // Support: IE <=9 only 18092 18093 if (!support.option) { 18094 wrapMap.optgroup = wrapMap.option = [1, "<select multiple='multiple'>", "</select>"]; 18095 } 18096 18097 function getAll(context, tag) { 18098 // Support: IE <=9 - 11 only 18099 // Use typeof to avoid zero-argument method invocation on host objects (#15151) 18100 var ret; 18101 18102 if (typeof context.getElementsByTagName !== "undefined") { 18103 ret = context.getElementsByTagName(tag || "*"); 18104 } else if (typeof context.querySelectorAll !== "undefined") { 18105 ret = context.querySelectorAll(tag || "*"); 18106 } else { 18107 ret = []; 18108 } 18109 18110 if (tag === undefined || tag && nodeName(context, tag)) { 18111 return jQuery.merge([context], ret); 18112 } 18113 18114 return ret; 18115 } // Mark scripts as having already been evaluated 18116 18117 18118 function setGlobalEval(elems, refElements) { 18119 var i = 0, 18120 l = elems.length; 18121 18122 for (; i < l; i++) { 18123 dataPriv.set(elems[i], "globalEval", !refElements || dataPriv.get(refElements[i], "globalEval")); 18124 } 18125 } 18126 18127 var rhtml = /<|&#?\w+;/; 18128 18129 function buildFragment(elems, context, scripts, selection, ignored) { 18130 var elem, 18131 tmp, 18132 tag, 18133 wrap, 18134 attached, 18135 j, 18136 fragment = context.createDocumentFragment(), 18137 nodes = [], 18138 i = 0, 18139 l = elems.length; 18140 18141 for (; i < l; i++) { 18142 elem = elems[i]; 18143 18144 if (elem || elem === 0) { 18145 // Add nodes directly 18146 if (toType(elem) === "object") { 18147 // Support: Android <=4.0 only, PhantomJS 1 only 18148 // push.apply(_, arraylike) throws on ancient WebKit 18149 jQuery.merge(nodes, elem.nodeType ? [elem] : elem); // Convert non-html into a text node 18150 } else if (!rhtml.test(elem)) { 18151 nodes.push(context.createTextNode(elem)); // Convert html into DOM nodes 18152 } else { 18153 tmp = tmp || fragment.appendChild(context.createElement("div")); // Deserialize a standard representation 18154 18155 tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase(); 18156 wrap = wrapMap[tag] || wrapMap._default; 18157 tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2]; // Descend through wrappers to the right content 18158 18159 j = wrap[0]; 18160 18161 while (j--) { 18162 tmp = tmp.lastChild; 18163 } // Support: Android <=4.0 only, PhantomJS 1 only 18164 // push.apply(_, arraylike) throws on ancient WebKit 18165 18166 18167 jQuery.merge(nodes, tmp.childNodes); // Remember the top-level container 18168 18169 tmp = fragment.firstChild; // Ensure the created nodes are orphaned (#12392) 18170 18171 tmp.textContent = ""; 18172 } 18173 } 18174 } // Remove wrapper from fragment 18175 18176 18177 fragment.textContent = ""; 18178 i = 0; 18179 18180 while (elem = nodes[i++]) { 18181 // Skip elements already in the context collection (trac-4087) 18182 if (selection && jQuery.inArray(elem, selection) > -1) { 18183 if (ignored) { 18184 ignored.push(elem); 18185 } 18186 18187 continue; 18188 } 18189 18190 attached = isAttached(elem); // Append to fragment 18191 18192 tmp = getAll(fragment.appendChild(elem), "script"); // Preserve script evaluation history 18193 18194 if (attached) { 18195 setGlobalEval(tmp); 18196 } // Capture executables 18197 18198 18199 if (scripts) { 18200 j = 0; 18201 18202 while (elem = tmp[j++]) { 18203 if (rscriptType.test(elem.type || "")) { 18204 scripts.push(elem); 18205 } 18206 } 18207 } 18208 } 18209 18210 return fragment; 18211 } 18212 18213 var rkeyEvent = /^key/, 18214 rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, 18215 rtypenamespace = /^([^.]*)(?:\.(.+)|)/; 18216 18217 function returnTrue() { 18218 return true; 18219 } 18220 18221 function returnFalse() { 18222 return false;
vendor: 6,625 bytes, lines 18223-18437
18223 } // Support: IE <=9 - 11+ 18224 // focus() and blur() are asynchronous, except when they are no-op. 18225 // So expect focus to be synchronous when the element is already active, 18226 // and blur to be synchronous when the element is not already active. 18227 // (focus and blur are always synchronous in other supported browsers, 18228 // this just defines when we can count on it). 18229 18230 18231 function expectSync(elem, type) { 18232 return elem === safeActiveElement() === (type === "focus"); 18233 } // Support: IE <=9 only 18234 // Accessing document.activeElement can throw unexpectedly 18235 // https://bugs.jquery.com/ticket/13393 18236 18237 18238 function safeActiveElement() { 18239 try { 18240 return document.activeElement; 18241 } catch (err) {} 18242 } 18243 18244 function _on(elem, types, selector, data, fn, one) { 18245 var origFn, type; // Types can be a map of types/handlers 18246 18247 if (_typeof(types) === "object") { 18248 // ( types-Object, selector, data ) 18249 if (typeof selector !== "string") { 18250 // ( types-Object, data ) 18251 data = data || selector; 18252 selector = undefined; 18253 } 18254 18255 for (type in types) { 18256 _on(elem, type, selector, data, types[type], one); 18257 } 18258 18259 return elem; 18260 } 18261 18262 if (data == null && fn == null) { 18263 // ( types, fn ) 18264 fn = selector; 18265 data = selector = undefined; 18266 } else if (fn == null) { 18267 if (typeof selector === "string") { 18268 // ( types, selector, fn ) 18269 fn = data; 18270 data = undefined; 18271 } else { 18272 // ( types, data, fn ) 18273 fn = data; 18274 data = selector; 18275 selector = undefined; 18276 } 18277 } 18278 18279 if (fn === false) { 18280 fn = returnFalse; 18281 } else if (!fn) { 18282 return elem; 18283 } 18284 18285 if (one === 1) { 18286 origFn = fn; 18287 18288 fn = function fn(event) { 18289 // Can use an empty set, since event contains the info 18290 jQuery().off(event); 18291 return origFn.apply(this, arguments); 18292 }; // Use same guid so caller can remove using origFn 18293 18294 18295 fn.guid = origFn.guid || (origFn.guid = jQuery.guid++); 18296 } 18297 18298 return elem.each(function () { 18299 jQuery.event.add(this, types, fn, data, selector); 18300 }); 18301 } 18302 /* 18303 * Helper functions for managing events -- not part of the public interface. 18304 * Props to Dean Edwards' addEvent library for many of the ideas. 18305 */ 18306 18307 18308 jQuery.event = { 18309 global: {}, 18310 add: function add(elem, types, handler, data, selector) { 18311 var handleObjIn, 18312 eventHandle, 18313 tmp, 18314 events, 18315 t, 18316 handleObj, 18317 special, 18318 handlers, 18319 type, 18320 namespaces, 18321 origType, 18322 elemData = dataPriv.get(elem); // Only attach events to objects that accept data 18323 18324 if (!acceptData(elem)) { 18325 return; 18326 } // Caller can pass in an object of custom data in lieu of the handler 18327 18328 18329 if (handler.handler) { 18330 handleObjIn = handler; 18331 handler = handleObjIn.handler; 18332 selector = handleObjIn.selector; 18333 } // Ensure that invalid selectors throw exceptions at attach time 18334 // Evaluate against documentElement in case elem is a non-element node (e.g., document) 18335 18336 18337 if (selector) { 18338 jQuery.find.matchesSelector(documentElement, selector); 18339 } // Make sure that the handler has a unique ID, used to find/remove it later 18340 18341 18342 if (!handler.guid) { 18343 handler.guid = jQuery.guid++; 18344 } // Init the element's event structure and main handler, if this is the first 18345 18346 18347 if (!(events = elemData.events)) { 18348 events = elemData.events = Object.create(null); 18349 } 18350 18351 if (!(eventHandle = elemData.handle)) { 18352 eventHandle = elemData.handle = function (e) { 18353 // Discard the second event of a jQuery.event.trigger() and 18354 // when an event is called after a page has unloaded 18355 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : undefined; 18356 }; 18357 } // Handle multiple events separated by a space 18358 18359 18360 types = (types || "").match(rnothtmlwhite) || [""]; 18361 t = types.length; 18362 18363 while (t--) { 18364 tmp = rtypenamespace.exec(types[t]) || []; 18365 type = origType = tmp[1]; 18366 namespaces = (tmp[2] || "").split(".").sort(); // There *must* be a type, no attaching namespace-only handlers 18367 18368 if (!type) { 18369 continue; 18370 } // If event changes its type, use the special event handlers for the changed type 18371 18372 18373 special = jQuery.event.special[type] || {}; // If selector defined, determine special event api type, otherwise given type 18374 18375 type = (selector ? special.delegateType : special.bindType) || type; // Update special based on newly reset type 18376 18377 special = jQuery.event.special[type] || {}; // handleObj is passed to all event handlers 18378 18379 handleObj = jQuery.extend({ 18380 type: type, 18381 origType: origType, 18382 data: data, 18383 handler: handler, 18384 guid: handler.guid, 18385 selector: selector, 18386 needsContext: selector && jQuery.expr.match.needsContext.test(selector), 18387 namespace: namespaces.join(".") 18388 }, handleObjIn); // Init the event handler queue if we're the first 18389 18390 if (!(handlers = events[type])) { 18391 handlers = events[type] = []; 18392 handlers.delegateCount = 0; // Only use addEventListener if the special events handler returns false 18393 18394 if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) { 18395 if (elem.addEventListener) { 18396 elem.addEventListener(type, eventHandle); 18397 } 18398 } 18399 } 18400 18401 if (special.add) { 18402 special.add.call(elem, handleObj); 18403 18404 if (!handleObj.handler.guid) { 18405 handleObj.handler.guid = handler.guid; 18406 } 18407 } // Add to the element's handler list, delegates in front 18408 18409 18410 if (selector) { 18411 handlers.splice(handlers.delegateCount++, 0, handleObj); 18412 } else { 18413 handlers.push(handleObj); 18414 } // Keep track of which events have ever been used, for event optimization 18415 18416 18417 jQuery.event.global[type] = true; 18418 } 18419 }, 18420 // Detach an event or set of events from an element 18421 remove: function remove(elem, types, handler, selector, mappedTypes) { 18422 var j, 18423 origCount, 18424 tmp, 18425 events, 18426 t, 18427 handleObj, 18428 special, 18429 handlers, 18430 type, 18431 namespaces, 18432 origType, 18433 elemData = dataPriv.hasData(elem) && dataPriv.get(elem); 18434 18435 if (!elemData || !(events = elemData.events)) { 18436 return; 18437 }
vendor: 4,537 bytes, lines 18437-18563
18437 // Once for each type.namespace in types; type may be omitted 18438 18439 18440 types = (types || "").match(rnothtmlwhite) || [""]; 18441 t = types.length; 18442 18443 while (t--) { 18444 tmp = rtypenamespace.exec(types[t]) || []; 18445 type = origType = tmp[1]; 18446 namespaces = (tmp[2] || "").split(".").sort(); // Unbind all events (on this namespace, if provided) for the element 18447 18448 if (!type) { 18449 for (type in events) { 18450 jQuery.event.remove(elem, type + types[t], handler, selector, true); 18451 } 18452 18453 continue; 18454 } 18455 18456 special = jQuery.event.special[type] || {}; 18457 type = (selector ? special.delegateType : special.bindType) || type; 18458 handlers = events[type] || []; 18459 tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)"); // Remove matching events 18460 18461 origCount = j = handlers.length; 18462 18463 while (j--) { 18464 handleObj = handlers[j]; 18465 18466 if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === "**" && handleObj.selector)) { 18467 handlers.splice(j, 1); 18468 18469 if (handleObj.selector) { 18470 handlers.delegateCount--; 18471 } 18472 18473 if (special.remove) { 18474 special.remove.call(elem, handleObj); 18475 } 18476 } 18477 } // Remove generic event handler if we removed something and no more handlers exist 18478 // (avoids potential for endless recursion during removal of special event handlers) 18479 18480 18481 if (origCount && !handlers.length) { 18482 if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) { 18483 jQuery.removeEvent(elem, type, elemData.handle); 18484 } 18485 18486 delete events[type]; 18487 } 18488 } // Remove data and the expando if it's no longer used 18489 18490 18491 if (jQuery.isEmptyObject(events)) { 18492 dataPriv.remove(elem, "handle events"); 18493 } 18494 }, 18495 dispatch: function dispatch(nativeEvent) { 18496 var i, 18497 j, 18498 ret, 18499 matched, 18500 handleObj, 18501 handlerQueue, 18502 args = new Array(arguments.length), 18503 // Make a writable jQuery.Event from the native event object 18504 event = jQuery.event.fix(nativeEvent), 18505 handlers = (dataPriv.get(this, "events") || Object.create(null))[event.type] || [], 18506 special = jQuery.event.special[event.type] || {}; // Use the fix-ed jQuery.Event rather than the (read-only) native event 18507 18508 args[0] = event; 18509 18510 for (i = 1; i < arguments.length; i++) { 18511 args[i] = arguments[i]; 18512 } 18513 18514 event.delegateTarget = this; // Call the preDispatch hook for the mapped type, and let it bail if desired 18515 18516 if (special.preDispatch && special.preDispatch.call(this, event) === false) { 18517 return; 18518 } // Determine handlers 18519 18520 18521 handlerQueue = jQuery.event.handlers.call(this, event, handlers); // Run delegates first; they may want to stop propagation beneath us 18522 18523 i = 0; 18524 18525 while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) { 18526 event.currentTarget = matched.elem; 18527 j = 0; 18528 18529 while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) { 18530 // If the event is namespaced, then each handler is only invoked if it is 18531 // specially universal or its namespaces are a superset of the event's. 18532 if (!event.rnamespace || handleObj.namespace === false || event.rnamespace.test(handleObj.namespace)) { 18533 event.handleObj = handleObj; 18534 event.data = handleObj.data; 18535 ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args); 18536 18537 if (ret !== undefined) { 18538 if ((event.result = ret) === false) { 18539 event.preventDefault(); 18540 event.stopPropagation(); 18541 } 18542 } 18543 } 18544 } 18545 } // Call the postDispatch hook for the mapped type 18546 18547 18548 if (special.postDispatch) { 18549 special.postDispatch.call(this, event); 18550 } 18551 18552 return event.result; 18553 }, 18554 handlers: function handlers(event, _handlers) { 18555 var i, 18556 handleObj, 18557 sel, 18558 matchedHandlers, 18559 matchedSelectors, 18560 handlerQueue = [], 18561 delegateCount = _handlers.delegateCount, 18562 cur = event.target; // Find delegate handlers 18563
vendor: 8,877 bytes, lines 18564-18787
18564 if (delegateCount && // Support: IE <=9 18565 // Black-hole SVG <use> instance trees (trac-13180) 18566 cur.nodeType && // Support: Firefox <=42 18567 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) 18568 // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click 18569 // Support: IE 11 only 18570 // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) 18571 !(event.type === "click" && event.button >= 1)) { 18572 for (; cur !== this; cur = cur.parentNode || this) { 18573 // Don't check non-elements (#13208) 18574 // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) 18575 if (cur.nodeType === 1 && !(event.type === "click" && cur.disabled === true)) { 18576 matchedHandlers = []; 18577 matchedSelectors = {}; 18578 18579 for (i = 0; i < delegateCount; i++) { 18580 handleObj = _handlers[i]; // Don't conflict with Object.prototype properties (#13203) 18581 18582 sel = handleObj.selector + " "; 18583 18584 if (matchedSelectors[sel] === undefined) { 18585 matchedSelectors[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 : jQuery.find(sel, this, null, [cur]).length; 18586 } 18587 18588 if (matchedSelectors[sel]) { 18589 matchedHandlers.push(handleObj); 18590 } 18591 } 18592 18593 if (matchedHandlers.length) { 18594 handlerQueue.push({ 18595 elem: cur, 18596 handlers: matchedHandlers 18597 }); 18598 } 18599 } 18600 } 18601 } // Add the remaining (directly-bound) handlers 18602 18603 18604 cur = this; 18605 18606 if (delegateCount < _handlers.length) { 18607 handlerQueue.push({ 18608 elem: cur, 18609 handlers: _handlers.slice(delegateCount) 18610 }); 18611 } 18612 18613 return handlerQueue; 18614 }, 18615 addProp: function addProp(name, hook) { 18616 Object.defineProperty(jQuery.Event.prototype, name, { 18617 enumerable: true, 18618 configurable: true, 18619 get: isFunction(hook) ? function () { 18620 if (this.originalEvent) { 18621 return hook(this.originalEvent); 18622 } 18623 } : function () { 18624 if (this.originalEvent) { 18625 return this.originalEvent[name]; 18626 } 18627 }, 18628 set: function set(value) { 18629 Object.defineProperty(this, name, { 18630 enumerable: true, 18631 configurable: true, 18632 writable: true, 18633 value: value 18634 }); 18635 } 18636 }); 18637 }, 18638 fix: function fix(originalEvent) { 18639 return originalEvent[jQuery.expando] ? originalEvent : new jQuery.Event(originalEvent); 18640 }, 18641 special: { 18642 load: { 18643 // Prevent triggered image.load events from bubbling to window.load 18644 noBubble: true 18645 }, 18646 click: { 18647 // Utilize native event to ensure correct state for checkable inputs 18648 setup: function setup(data) { 18649 // For mutual compressibility with _default, replace `this` access with a local var. 18650 // `|| data` is dead code meant only to preserve the variable through minification. 18651 var el = this || data; // Claim the first handler 18652 18653 if (rcheckableType.test(el.type) && el.click && nodeName(el, "input")) { 18654 // dataPriv.set( el, "click", ... ) 18655 leverageNative(el, "click", returnTrue); 18656 } // Return false to allow normal processing in the caller 18657 18658 18659 return false; 18660 }, 18661 trigger: function trigger(data) { 18662 // For mutual compressibility with _default, replace `this` access with a local var. 18663 // `|| data` is dead code meant only to preserve the variable through minification. 18664 var el = this || data; // Force setup before triggering a click 18665 18666 if (rcheckableType.test(el.type) && el.click && nodeName(el, "input")) { 18667 leverageNative(el, "click"); 18668 } // Return non-false to allow normal event-path propagation 18669 18670 18671 return true; 18672 }, 18673 // For cross-browser consistency, suppress native .click() on links 18674 // Also prevent it if we're currently inside a leveraged native-event stack 18675 _default: function _default(event) { 18676 var target = event.target; 18677 return rcheckableType.test(target.type) && target.click && nodeName(target, "input") && dataPriv.get(target, "click") || nodeName(target, "a"); 18678 } 18679 }, 18680 beforeunload: { 18681 postDispatch: function postDispatch(event) { 18682 // Support: Firefox 20+ 18683 // Firefox doesn't alert if the returnValue field is not set. 18684 if (event.result !== undefined && event.originalEvent) { 18685 event.originalEvent.returnValue = event.result; 18686 } 18687 } 18688 } 18689 } 18690 }; // Ensure the presence of an event listener that handles manually-triggered 18691 // synthetic events by interrupting progress until reinvoked in response to 18692 // *native* events that it fires directly, ensuring that state changes have 18693 // already occurred before other listeners are invoked. 18694 18695 function leverageNative(el, type, expectSync) { 18696 // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add 18697 if (!expectSync) { 18698 if (dataPriv.get(el, type) === undefined) { 18699 jQuery.event.add(el, type, returnTrue); 18700 } 18701 18702 return; 18703 } // Register the controller as a special universal handler for all event namespaces 18704 18705 18706 dataPriv.set(el, type, false); 18707 jQuery.event.add(el, type, { 18708 namespace: false, 18709 handler: function handler(event) { 18710 var notAsync, 18711 result, 18712 saved = dataPriv.get(this, type); 18713 18714 if (event.isTrigger & 1 && this[type]) { 18715 // Interrupt processing of the outer synthetic .trigger()ed event 18716 // Saved data should be false in such cases, but might be a leftover capture object 18717 // from an async native handler (gh-4350) 18718 if (!saved.length) { 18719 // Store arguments for use when handling the inner native event 18720 // There will always be at least one argument (an event object), so this array 18721 // will not be confused with a leftover capture object. 18722 saved = _slice.call(arguments); 18723 dataPriv.set(this, type, saved); // Trigger the native event and capture its result 18724 // Support: IE <=9 - 11+ 18725 // focus() and blur() are asynchronous 18726 18727 notAsync = expectSync(this, type); 18728 this[type](); 18729 result = dataPriv.get(this, type); 18730 18731 if (saved !== result || notAsync) { 18732 dataPriv.set(this, type, false); 18733 } else { 18734 result = {}; 18735 } 18736 18737 if (saved !== result) { 18738 // Cancel the outer synthetic event 18739 event.stopImmediatePropagation(); 18740 event.preventDefault(); 18741 return result.value; 18742 } // If this is an inner synthetic event for an event with a bubbling surrogate 18743 // (focus or blur), assume that the surrogate already propagated from triggering the 18744 // native event and prevent that from happening again here. 18745 // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the 18746 // bubbling surrogate propagates *after* the non-bubbling base), but that seems 18747 // less bad than duplication. 18748 18749 } else if ((jQuery.event.special[type] || {}).delegateType) { 18750 event.stopPropagation(); 18751 } // If this is a native event triggered above, everything is now in order 18752 // Fire an inner synthetic event with the original arguments 18753 18754 } else if (saved.length) { 18755 // ...and capture the result 18756 dataPriv.set(this, type, { 18757 value: jQuery.event.trigger( // Support: IE <=9 - 11+ 18758 // Extend with the prototype to reset the above stopImmediatePropagation() 18759 jQuery.extend(saved[0], jQuery.Event.prototype), saved.slice(1), this) 18760 }); // Abort handling of the native event 18761 18762 event.stopImmediatePropagation(); 18763 } 18764 } 18765 }); 18766 } 18767 18768 jQuery.removeEvent = function (elem, type, handle) { 18769 // This "if" is needed for plain objects 18770 if (elem.removeEventListener) { 18771 elem.removeEventListener(type, handle); 18772 } 18773 }; 18774 18775 jQuery.Event = function (src, props) { 18776 // Allow instantiation without the 'new' keyword 18777 if (!(this instanceof jQuery.Event)) { 18778 return new jQuery.Event(src, props); 18779 } // Event object 18780 18781 18782 if (src && src.type) { 18783 this.originalEvent = src; 18784 this.type = src.type; // Events bubbling up the document may have been marked as prevented 18785 // by a handler lower down the tree; reflect the correct value. 18786 18787 this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && // Supp
18787ort: Android <=2.3 only 18788 src.returnValue === false ? returnTrue : returnFalse; // Create target properties 18789 // Support: Safari <=6 - 7 only 18790 // Target should not be a text node (#504, #13143) 18791 18792 this.target = src.target && src.target.nodeType === 3 ? src.target.parentNode : src.target; 18793 this.currentTarget = src.currentTarget; 18794 this.relatedTarget = src.relatedTarget; // Event type 18795 } else { 18796 this.type = src; 18797 } // Put explicitly provided properties onto the event object 18798 18799 18800 if (props) { 18801 jQuery.extend(this, props); 18802 } // Create a timestamp if incoming event doesn't have one 18803 18804 18805 this.timeStamp = src && src.timeStamp || Date.now(); // Mark it as fixed 18806 18807 this[jQuery.expando] = true; 18808 }; // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding 18809 // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html 18810 18811 18812 jQuery.Event.prototype = { 18813 constructor: jQuery.Event, 18814 isDefaultPrevented: returnFalse, 18815 isPropagationStopped: returnFalse, 18816 isImmediatePropagationStopped: returnFalse, 18817 isSimulated: false, 18818 preventDefault: function preventDefault() { 18819 var e = this.originalEvent; 18820 this.isDefaultPrevented = returnTrue; 18821 18822 if (e && !this.isSimulated) { 18823 e.preventDefault(); 18824 } 18825 }, 18826 stopPropagation: function stopPropagation() { 18827 var e = this.originalEvent; 18828 this.isPropagationStopped = returnTrue; 18829 18830 if (e && !this.isSimulated) { 18831 e.stopPropagation(); 18832 } 18833 }, 18834 stopImmediatePropagation: function stopImmediatePropagation() { 18835 var e = this.originalEvent; 18836 this.isImmediatePropagationStopped = returnTrue; 18837 18838 if (e && !this.isSimulated) { 18839 e.stopImmediatePropagation(); 18840 } 18841 18842 this.stopPropagation(); 18843 } 18844 }; // Includes all common event props including KeyEvent and MouseEvent specific props 18845 18846 jQuery.each({ 18847 altKey: true, 18848 bubbles: true, 18849 cancelable: true, 18850 changedTouches: true, 18851 ctrlKey: true, 18852 detail: true, 18853 eventPhase: true, 18854 metaKey: true, 18855 pageX: true, 18856 pageY: true, 18857 shiftKey: true, 18858 view: true, 18859 "char": true, 18860 code: true, 18861 charCode: true, 18862 key: true, 18863 keyCode: true, 18864 button: true, 18865 buttons: true, 18866 clientX: true, 18867 clientY: true, 18868 offsetX: true, 18869 offsetY: true, 18870 pointerId: true, 18871 pointerType: true, 18872 screenX: true, 18873 screenY: true, 18874 targetTouches: true, 18875 toElement: true, 18876 touches: true, 18877 which: function which(event) { 18878 var button = event.button; // Add which for key events 18879 18880 if (event.which == null && rkeyEvent.test(event.type)) { 18881 return event.charCode != null ? event.charCode : event.keyCode; 18882 } // Add which for click: 1 === left; 2 === middle; 3 === right 18883 18884 18885 if (!event.which && button !== undefined && rmouseEvent.test(event.type)) { 18886 if (button & 1) { 18887 return 1; 18888 } 18889 18890 if (button & 2) { 18891 return 3; 18892 } 18893 18894 if (button & 4) { 18895 return 2; 18896 } 18897 18898 return 0; 18899 } 18900 18901 return event.which; 18902 } 18903 }, jQuery.event.addProp); 18904 jQuery.each({ 18905 focus: "focusin", 18906 blur: "focusout" 18907 }, function (type, delegateType) { 18908 jQuery.event.special[type] = { 18909 // Utilize native event if possible so blur/focus sequence is correct 18910 setup: function setup() { 18911 // Claim the first handler 18912 // dataPriv.set( this, "focus", ... ) 18913 // dataPriv.set( this, "blur", ... ) 18914 leverageNative(this, type, expectSync); // Return false to allow normal processing in the caller 18915 18916 return false; 18917 }, 18918 trigger: function trigger() { 18919 // Force setup before trigger 18920 leverageNative(this, type); // Return non-false to allow normal event-path propagation 18921 18922 return true; 18923 }, 18924 delegateType: delegateType 18925 }; 18926 }); // Create mouseenter/leave events using mouseover/out and event-time checks 18927 // so that event delegation works in jQuery. 18928 // Do the same for pointerenter/pointerleave and pointerover/pointerout 18929 //
vendor: 4,124 bytes, lines 18930-19065
18930 // Support: Safari 7 only 18931 // Safari sends mouseenter too often; see: 18932 // https://bugs.chromium.org/p/chromium/issues/detail?id=470258 18933 // for the description of the bug (it existed in older Chrome versions as well). 18934 18935 jQuery.each({ 18936 mouseenter: "mouseover", 18937 mouseleave: "mouseout", 18938 pointerenter: "pointerover", 18939 pointerleave: "pointerout" 18940 }, function (orig, fix) { 18941 jQuery.event.special[orig] = { 18942 delegateType: fix, 18943 bindType: fix, 18944 handle: function handle(event) { 18945 var ret, 18946 target = this, 18947 related = event.relatedTarget, 18948 handleObj = event.handleObj; // For mouseenter/leave call the handler if related is outside the target. 18949 // NB: No relatedTarget if the mouse left/entered the browser window 18950 18951 if (!related || related !== target && !jQuery.contains(target, related)) { 18952 event.type = handleObj.origType; 18953 ret = handleObj.handler.apply(this, arguments); 18954 event.type = fix; 18955 } 18956 18957 return ret; 18958 } 18959 }; 18960 }); 18961 jQuery.fn.extend({ 18962 on: function on(types, selector, data, fn) { 18963 return _on(this, types, selector, data, fn); 18964 }, 18965 one: function one(types, selector, data, fn) { 18966 return _on(this, types, selector, data, fn, 1); 18967 }, 18968 off: function off(types, selector, fn) { 18969 var handleObj, type; 18970 18971 if (types && types.preventDefault && types.handleObj) { 18972 // ( event ) dispatched jQuery.Event 18973 handleObj = types.handleObj; 18974 jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler); 18975 return this; 18976 } 18977 18978 if (_typeof(types) === "object") { 18979 // ( types-object [, selector] ) 18980 for (type in types) { 18981 this.off(type, selector, types[type]); 18982 } 18983 18984 return this; 18985 } 18986 18987 if (selector === false || typeof selector === "function") { 18988 // ( types [, fn] ) 18989 fn = selector; 18990 selector = undefined; 18991 } 18992 18993 if (fn === false) { 18994 fn = returnFalse; 18995 } 18996 18997 return this.each(function () { 18998 jQuery.event.remove(this, types, fn, selector); 18999 }); 19000 } 19001 }); 19002 var // Support: IE <=10 - 11, Edge 12 - 13 only 19003 // In IE/Edge using regex groups here causes severe slowdowns. 19004 // See https://connect.microsoft.com/IE/feedback/details/1736512/ 19005 rnoInnerhtml = /<script|<style|<link/i, 19006 // checked="checked" or checked 19007 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, 19008 rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g; // Prefer a tbody over its parent table for containing new rows 19009 19010 function manipulationTarget(elem, content) { 19011 if (nodeName(elem, "table") && nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr")) { 19012 return jQuery(elem).children("tbody")[0] || elem; 19013 } 19014 19015 return elem; 19016 } // Replace/restore the type attribute of script elements for safe DOM manipulation 19017 19018 19019 function disableScript(elem) { 19020 elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type; 19021 return elem; 19022 } 19023 19024 function restoreScript(elem) { 19025 if ((elem.type || "").slice(0, 5) === "true/") { 19026 elem.type = elem.type.slice(5); 19027 } else { 19028 elem.removeAttribute("type"); 19029 } 19030 19031 return elem; 19032 } 19033 19034 function cloneCopyEvent(src, dest) { 19035 var i, l, type, pdataOld, udataOld, udataCur, events; 19036 19037 if (dest.nodeType !== 1) { 19038 return; 19039 } // 1. Copy private data: events, handlers, etc. 19040 19041 19042 if (dataPriv.hasData(src)) { 19043 pdataOld = dataPriv.get(src); 19044 events = pdataOld.events; 19045 19046 if (events) { 19047 dataPriv.remove(dest, "handle events"); 19048 19049 for (type in events) { 19050 for (i = 0, l = events[type].length; i < l; i++) { 19051 jQuery.event.add(dest, type, events[type][i]); 19052 } 19053 } 19054 } 19055 } // 2. Copy user data 19056 19057 19058 if (dataUser.hasData(src)) { 19059 udataOld = dataUser.access(src); 19060 udataCur = jQuery.extend({}, udataOld); 19061 dataUser.set(dest, udataCur); 19062 } 19063 } // Fix IE bugs, see support tests 19064 19065
vendor: 13,107 bytes, lines 19066-19465
19066 function fixInput(src, dest) { 19067 var nodeName = dest.nodeName.toLowerCase(); // Fails to persist the checked state of a cloned checkbox or radio button. 19068 19069 if (nodeName === "input" && rcheckableType.test(src.type)) { 19070 dest.checked = src.checked; // Fails to return the selected option to the default selected state when cloning options 19071 } else if (nodeName === "input" || nodeName === "textarea") { 19072 dest.defaultValue = src.defaultValue; 19073 } 19074 } 19075 19076 function domManip(collection, args, callback, ignored) { 19077 // Flatten any nested arrays 19078 args = flat(args); 19079 var fragment, 19080 first, 19081 scripts, 19082 hasScripts, 19083 node, 19084 doc, 19085 i = 0, 19086 l = collection.length, 19087 iNoClone = l - 1, 19088 value = args[0], 19089 valueIsFunction = isFunction(value); // We can't cloneNode fragments that contain checked, in WebKit 19090 19091 if (valueIsFunction || l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value)) { 19092 return collection.each(function (index) { 19093 var self = collection.eq(index); 19094 19095 if (valueIsFunction) { 19096 args[0] = value.call(this, index, self.html()); 19097 } 19098 19099 domManip(self, args, callback, ignored); 19100 }); 19101 } 19102 19103 if (l) { 19104 fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored); 19105 first = fragment.firstChild; 19106 19107 if (fragment.childNodes.length === 1) { 19108 fragment = first; 19109 } // Require either new content or an interest in ignored elements to invoke the callback 19110 19111 19112 if (first || ignored) { 19113 scripts = jQuery.map(getAll(fragment, "script"), disableScript); 19114 hasScripts = scripts.length; // Use the original fragment for the last item 19115 // instead of the first because it can end up 19116 // being emptied incorrectly in certain situations (#8070). 19117 19118 for (; i < l; i++) { 19119 node = fragment; 19120 19121 if (i !== iNoClone) { 19122 node = jQuery.clone(node, true, true); // Keep references to cloned scripts for later restoration 19123 19124 if (hasScripts) { 19125 // Support: Android <=4.0 only, PhantomJS 1 only 19126 // push.apply(_, arraylike) throws on ancient WebKit 19127 jQuery.merge(scripts, getAll(node, "script")); 19128 } 19129 } 19130 19131 callback.call(collection[i], node, i); 19132 } 19133 19134 if (hasScripts) { 19135 doc = scripts[scripts.length - 1].ownerDocument; // Reenable scripts 19136 19137 jQuery.map(scripts, restoreScript); // Evaluate executable scripts on first document insertion 19138 19139 for (i = 0; i < hasScripts; i++) { 19140 node = scripts[i]; 19141 19142 if (rscriptType.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery.contains(doc, node)) { 19143 if (node.src && (node.type || "").toLowerCase() !== "module") { 19144 // Optional AJAX dependency, but won't run scripts if not present 19145 if (jQuery._evalUrl && !node.noModule) { 19146 jQuery._evalUrl(node.src, { 19147 nonce: node.nonce || node.getAttribute("nonce") 19148 }, doc); 19149 } 19150 } else { 19151 DOMEval(node.textContent.replace(rcleanScript, ""), node, doc); 19152 } 19153 } 19154 } 19155 } 19156 } 19157 } 19158 19159 return collection; 19160 } 19161 19162 function _remove(elem, selector, keepData) { 19163 var node, 19164 nodes = selector ? jQuery.filter(selector, elem) : elem, 19165 i = 0; 19166 19167 for (; (node = nodes[i]) != null; i++) { 19168 if (!keepData && node.nodeType === 1) { 19169 jQuery.cleanData(getAll(node)); 19170 } 19171 19172 if (node.parentNode) { 19173 if (keepData && isAttached(node)) { 19174 setGlobalEval(getAll(node, "script")); 19175 } 19176 19177 node.parentNode.removeChild(node); 19178 } 19179 } 19180 19181 return elem; 19182 } 19183 19184 jQuery.extend({ 19185 htmlPrefilter: function htmlPrefilter(html) { 19186 return html; 19187 }, 19188 clone: function clone(elem, dataAndEvents, deepDataAndEvents) { 19189 var i, 19190 l, 19191 srcElements, 19192 destElements, 19193 clone = elem.cloneNode(true), 19194 inPage = isAttached(elem); // Fix IE cloning issues 19195 19196 if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) { 19197 // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 19198 destElements = getAll(clone); 19199 srcElements = getAll(elem); 19200 19201 for (i = 0, l = srcElements.length; i < l; i++) { 19202 fixInput(srcElements[i], destElements[i]); 19203 } 19204 } // Copy the events from the original to the clone 19205 19206 19207 if (dataAndEvents) { 19208 if (deepDataAndEvents) { 19209 srcElements = srcElements || getAll(elem); 19210 destElements = destElements || getAll(clone); 19211 19212 for (i = 0, l = srcElements.length; i < l; i++) { 19213 cloneCopyEvent(srcElements[i], destElements[i]); 19214 } 19215 } else { 19216 cloneCopyEvent(elem, clone); 19217 } 19218 } // Preserve script evaluation history 19219 19220 19221 destElements = getAll(clone, "script"); 19222 19223 if (destElements.length > 0) { 19224 setGlobalEval(destElements, !inPage && getAll(elem, "script")); 19225 } // Return the cloned set 19226 19227 19228 return clone; 19229 }, 19230 cleanData: function cleanData(elems) { 19231 var data, 19232 elem, 19233 type, 19234 special = jQuery.event.special, 19235 i = 0; 19236 19237 for (; (elem = elems[i]) !== undefined; i++) { 19238 if (acceptData(elem)) { 19239 if (data = elem[dataPriv.expando]) { 19240 if (data.events) { 19241 for (type in data.events) { 19242 if (special[type]) { 19243 jQuery.event.remove(elem, type); // This is a shortcut to avoid jQuery.event.remove's overhead 19244 } else { 19245 jQuery.removeEvent(elem, type, data.handle); 19246 } 19247 } 19248 } // Support: Chrome <=35 - 45+ 19249 // Assign undefined instead of using delete, see Data#remove 19250 19251 19252 elem[dataPriv.expando] = undefined; 19253 } 19254 19255 if (elem[dataUser.expando]) { 19256 // Support: Chrome <=35 - 45+ 19257 // Assign undefined instead of using delete, see Data#remove 19258 elem[dataUser.expando] = undefined; 19259 } 19260 } 19261 } 19262 } 19263 }); 19264 jQuery.fn.extend({ 19265 detach: function detach(selector) { 19266 return _remove(this, selector, true); 19267 }, 19268 remove: function remove(selector) { 19269 return _remove(this, selector); 19270 }, 19271 text: function text(value) { 19272 return access(this, function (value) { 19273 return value === undefined ? jQuery.text(this) : this.empty().each(function () { 19274 if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { 19275 this.textContent = value; 19276 } 19277 }); 19278 }, null, value, arguments.length); 19279 }, 19280 append: function append() { 19281 return domManip(this, arguments, function (elem) { 19282 if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { 19283 var target = manipulationTarget(this, elem); 19284 target.appendChild(elem); 19285 } 19286 }); 19287 }, 19288 prepend: function prepend() { 19289 return domManip(this, arguments, function (elem) { 19290 if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { 19291 var target = manipulationTarget(this, elem); 19292 target.insertBefore(elem, target.firstChild); 19293 } 19294 }); 19295 }, 19296 before: function before() { 19297 return domManip(this, arguments, function (elem) { 19298 if (this.parentNode) { 19299 this.parentNode.insertBefore(elem, this); 19300 } 19301 }); 19302 }, 19303 after: function after() { 19304 return domManip(this, arguments, function (elem) { 19305 if (this.parentNode) { 19306 this.parentNode.insertBefore(elem, this.nextSibling); 19307 } 19308 }); 19309 }, 19310 empty: function empty() { 19311 var elem, 19312 i = 0; 19313 19314 for (; (elem = this[i]) != null; i++) { 19315 if (elem.nodeType === 1) { 19316 // Prevent memory leaks 19317 jQuery.cleanData(getAll(elem, false)); // Remove any remaining nodes 19318 19319 elem.textContent = ""; 19320 } 19321 } 19322 19323 return this; 19324 }, 19325 clone: function clone(dataAndEvents, deepDataAndEvents) { 19326 dataAndEvents = dataAndEvents == null ? false : dataAndEvents; 19327 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; 19328 return this.map(function () { 19329 return jQuery.clone(this, dataAndEvents, deepDataAndEvents); 19330 }); 19331 }, 19332 html: function html(value) { 19333 return access(this, function (value) { 19334 var elem = this[0] || {}, 19335 i = 0, 19336 l = this.length; 19337 19338 if (value === undefined && elem.nodeType === 1) { 19339 return elem.innerHTML; 19340 } // See if we can take a shortcut and just use innerHTML 19341 19342 19343 if (typeof value === "string" && !rnoInnerhtml.test(value) && !wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()]) { 19344 value = jQuery.htmlPrefilter(value); 19345 19346 try { 19347 for (; i < l; i++) { 19348 elem = this[i] || {}; // Remove element nodes and prevent memory leaks 19349 19350 if (elem.nodeType === 1) { 19351 jQuery.cleanData(getAll(elem, false)); 19352 elem.innerHTML = value; 19353 } 19354 } 19355 19356 elem = 0; // If using innerHTML throws an exception, use the fallback method 19357 } catch (e) {} 19358 } 19359 19360 if (elem) { 19361 this.empty().append(value); 19362 } 19363 }, null, value, arguments.length); 19364 }, 19365 replaceWith: function replaceWith() { 19366 var ignored = []; // Make the changes, replacing each non-ignored context element with the new content 19367 19368 return domManip(this, arguments, function (elem) { 19369 var parent = this.parentNode; 19370 19371 if (jQuery.inArray(this, ignored) < 0) { 19372 jQuery.cleanData(getAll(this)); 19373 19374 if (parent) { 19375 parent.replaceChild(elem, this); 19376 } 19377 } // Force callback invocation 19378 19379 }, ignored); 19380 } 19381 }); 19382 jQuery.each({ 19383 appendTo: "append", 19384 prependTo: "prepend", 19385 insertBefore: "before", 19386 insertAfter: "after", 19387 replaceAll: "replaceWith" 19388 }, function (name, original) { 19389 jQuery.fn[name] = function (selector) { 19390 var elems, 19391 ret = [], 19392 insert = jQuery(selector), 19393 last = insert.length - 1, 19394 i = 0; 19395 19396 for (; i <= last; i++) { 19397 elems = i === last ? this : this.clone(true); 19398 jQuery(insert[i])[original](elems); // Support: Android <=4.0 only, PhantomJS 1 only 19399 // .get() because push.apply(_, arraylike) throws on ancient WebKit 19400 19401 push.apply(ret, elems.get()); 19402 } 19403 19404 return this.pushStack(ret); 19405 }; 19406 }); 19407 var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i"); 19408 19409 var getStyles = function getStyles(elem) { 19410 // Support: IE <=11 only, Firefox <=30 (#15098, #14150) 19411 // IE throws on elements created in popups 19412 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" 19413 var view = elem.ownerDocument.defaultView; 19414 19415 if (!view || !view.opener) { 19416 view = window; 19417 } 19418 19419 return view.getComputedStyle(elem); 19420 }; 19421 19422 var swap = function swap(elem, options, callback) { 19423 var ret, 19424 name, 19425 old = {}; // Remember the old values, and insert the new ones 19426 19427 for (name in options) { 19428 old[name] = elem.style[name]; 19429 elem.style[name] = options[name]; 19430 } 19431 19432 ret = callback.call(elem); // Revert the old values 19433 19434 for (name in options) { 19435 elem.style[name] = old[name]; 19436 } 19437 19438 return ret; 19439 }; 19440 19441 var rboxStyle = new RegExp(cssExpand.join("|"), "i"); 19442 19443 (function () { 19444 // Executing both pixelPosition & boxSizingReliable tests require only one layout 19445 // so they're executed at the same time to save the second computation. 19446 function computeStyleTests() { 19447 // This is a singleton, we need to execute it only once 19448 if (!div) { 19449 return; 19450 } 19451 19452 container.style.cssText = "position:absolute;left:-11111px;width:60px;" + "margin-top:1px;padding:0;border:0"; 19453 div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + "margin:auto;border:1px;padding:1px;" + "width:60%;top:1%"; 19454 documentElement.appendChild(container).appendChild(div); 19455 var divStyle = window.getComputedStyle(div); 19456 pixelPositionVal = divStyle.top !== "1%"; // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 19457 19458 reliableMarginLeftVal = roundPixelMeasures(divStyle.marginLeft) === 12; // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 19459 // Some styles come back with percentage values, even though they shouldn't 19460 19461 div.style.right = "60%"; 19462 pixelBoxStylesVal = roundPixelMeasures(divStyle.right) === 36; // Support: IE 9 - 11 only 19463 // Detect misreporting of content dimensions for box-sizing:border-box elements 19464 19465 boxSizingReliableVal = roundPixelMeasures(divStyle.width) === 36;
19465 // Support: IE 9 only 19466 // Detect overflow:scroll screwiness (gh-3699) 19467 // Support: Chrome <=64 19468 // Don't get tricked when zoom affects offsetWidth (gh-4029) 19469 19470 div.style.position = "absolute"; 19471 scrollboxSizeVal = roundPixelMeasures(div.offsetWidth / 3) === 12; 19472 documentElement.removeChild(container); // Nullify the div so it wouldn't be stored in the memory and 19473 // it will also be a sign that checks already performed 19474 19475 div = null; 19476 } 19477 19478 function roundPixelMeasures(measure) { 19479 return Math.round(parseFloat(measure)); 19480 } 19481 19482 var pixelPositionVal, 19483 boxSizingReliableVal, 19484 scrollboxSizeVal, 19485 pixelBoxStylesVal, 19486 reliableTrDimensionsVal, 19487 reliableMarginLeftVal, 19488 container = document.createElement("div"), 19489 div = document.createElement("div"); // Finish early in limited (non-browser) environments 19490 19491 if (!div.style) { 19492 return; 19493 } // Support: IE <=9 - 11 only 19494 // Style of cloned element affects source element cloned (#8908) 19495 19496 19497 div.style.backgroundClip = "content-box"; 19498 div.cloneNode(true).style.backgroundClip = ""; 19499 support.clearCloneStyle = div.style.backgroundClip === "content-box"; 19500 jQuery.extend(support, { 19501 boxSizingReliable: function boxSizingReliable() { 19502 computeStyleTests(); 19503 return boxSizingReliableVal; 19504 }, 19505 pixelBoxStyles: function pixelBoxStyles() { 19506 computeStyleTests(); 19507 return pixelBoxStylesVal; 19508 }, 19509 pixelPosition: function pixelPosition() { 19510 computeStyleTests(); 19511 return pixelPositionVal; 19512 }, 19513 reliableMarginLeft: function reliableMarginLeft() { 19514 computeStyleTests(); 19515 return reliableMarginLeftVal; 19516 }, 19517 scrollboxSize: function scrollboxSize() { 19518 computeStyleTests(); 19519 return scrollboxSizeVal; 19520 }, 19521 // Support: IE 9 - 11+, Edge 15 - 18+ 19522 // IE/Edge misreport `getComputedStyle` of table rows with width/height 19523 // set in CSS while `offset*` properties report correct values. 19524 // Behavior in IE 9 is more subtle than in newer versions & it passes 19525 // some versions of this test; make sure not to make it pass there! 19526 reliableTrDimensions: function reliableTrDimensions() { 19527 var table, tr, trChild, trStyle; 19528 19529 if (reliableTrDimensionsVal == null) { 19530 table = document.createElement("table"); 19531 tr = document.createElement("tr"); 19532 trChild = document.createElement("div"); 19533 table.style.cssText = "position:absolute;left:-11111px"; 19534 tr.style.height = "1px"; 19535 trChild.style.height = "9px"; 19536 documentElement.appendChild(table).appendChild(tr).appendChild(trChild); 19537 trStyle = window.getComputedStyle(tr); 19538 reliableTrDimensionsVal = parseInt(trStyle.height) > 3; 19539 documentElement.removeChild(table); 19540 } 19541 19542 return reliableTrDimensionsVal; 19543 } 19544 }); 19545 })(); 19546 19547 function curCSS(elem, name, computed) { 19548 var width, 19549 minWidth, 19550 maxWidth, 19551 ret, 19552 // Support: Firefox 51+ 19553 // Retrieving style before computed somehow 19554 // fixes an issue with getting wrong values 19555 // on detached elements 19556 style = elem.style; 19557 computed = computed || getStyles(elem); // getPropertyValue is needed for: 19558 // .css('filter') (IE 9 only, #12537) 19559 // .css('--customProperty) (#3144) 19560 19561 if (computed) { 19562 ret = computed.getPropertyValue(name) || computed[name]; 19563 19564 if (ret === "" && !isAttached(elem)) { 19565 ret = jQuery.style(elem, name); 19566 } // A tribute to the "awesome hack by Dean Edwards" 19567 // Android Browser returns percentage for some values, 19568 // but width seems to be reliably pixels. 19569 // This is against the CSSOM draft spec: 19570 // https://drafts.csswg.org/cssom/#resolved-values 19571 19572 19573 if (!support.pixelBoxStyles() && rnumnonpx.test(ret) && rboxStyle.test(name)) { 19574 // Remember the original values 19575 width = style.width; 19576 minWidth = style.minWidth; 19577 maxWidth = style.maxWidth; // Put in the new values to get a computed value out 19578 19579 style.minWidth = style.maxWidth = style.width = ret; 19580 ret = computed.width; // Revert the changed values 19581 19582 style.width = width; 19583 style.minWidth = minWidth; 19584 style.maxWidth = maxWidth; 19585 } 19586 } 19587
vendor: 4,986 bytes, lines 19588-19727
19588 return ret !== undefined ? // Support: IE <=9 - 11 only 19589 // IE returns zIndex value as an integer. 19590 ret + "" : ret; 19591 } 19592 19593 function addGetHookIf(conditionFn, hookFn) { 19594 // Define the hook, we'll check on the first run if it's really needed. 19595 return { 19596 get: function get() { 19597 if (conditionFn()) { 19598 // Hook not needed (or it's not possible to use it due 19599 // to missing dependency), remove it. 19600 delete this.get; 19601 return; 19602 } // Hook needed; redefine it so that the support test is not executed again. 19603 19604 19605 return (this.get = hookFn).apply(this, arguments); 19606 } 19607 }; 19608 } 19609 19610 var cssPrefixes = ["Webkit", "Moz", "ms"], 19611 emptyStyle = document.createElement("div").style, 19612 vendorProps = {}; // Return a vendor-prefixed property or undefined 19613 19614 function vendorPropName(name) { 19615 // Check for vendor prefixed names 19616 var capName = name[0].toUpperCase() + name.slice(1), 19617 i = cssPrefixes.length; 19618 19619 while (i--) { 19620 name = cssPrefixes[i] + capName; 19621 19622 if (name in emptyStyle) { 19623 return name; 19624 } 19625 } 19626 } // Return a potentially-mapped jQuery.cssProps or vendor prefixed property 19627 19628 19629 function finalPropName(name) { 19630 var _final = jQuery.cssProps[name] || vendorProps[name]; 19631 19632 if (_final) { 19633 return _final; 19634 } 19635 19636 if (name in emptyStyle) { 19637 return name; 19638 } 19639 19640 return vendorProps[name] = vendorPropName(name) || name; 19641 } 19642 19643 var // Swappable if display is none or starts with table 19644 // except "table", "table-cell", or "table-caption" 19645 // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display 19646 rdisplayswap = /^(none|table(?!-c[ea]).+)/, 19647 rcustomProp = /^--/, 19648 cssShow = { 19649 position: "absolute", 19650 visibility: "hidden", 19651 display: "block" 19652 }, 19653 cssNormalTransform = { 19654 letterSpacing: "0", 19655 fontWeight: "400" 19656 }; 19657 19658 function setPositiveNumber(_elem, value, subtract) { 19659 // Any relative (+/-) values have already been 19660 // normalized at this point 19661 var matches = rcssNum.exec(value); 19662 return matches ? // Guard against undefined "subtract", e.g., when used as in cssHooks 19663 Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || "px") : value; 19664 } 19665 19666 function boxModelAdjustment(elem, dimension, box, isBorderBox, styles, computedVal) { 19667 var i = dimension === "width" ? 1 : 0, 19668 extra = 0, 19669 delta = 0; // Adjustment may not be necessary 19670 19671 if (box === (isBorderBox ? "border" : "content")) { 19672 return 0; 19673 } 19674 19675 for (; i < 4; i += 2) { 19676 // Both box models exclude margin 19677 if (box === "margin") { 19678 delta += jQuery.css(elem, box + cssExpand[i], true, styles); 19679 } // If we get here with a content-box, we're seeking "padding" or "border" or "margin" 19680 19681 19682 if (!isBorderBox) { 19683 // Add padding 19684 delta += jQuery.css(elem, "padding" + cssExpand[i], true, styles); // For "border" or "margin", add border 19685 19686 if (box !== "padding") { 19687 delta += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles); // But still keep track of it otherwise 19688 } else { 19689 extra += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles); 19690 } // If we get here with a border-box (content + padding + border), we're seeking "content" or 19691 // "padding" or "margin" 19692 19693 } else { 19694 // For "content", subtract padding 19695 if (box === "content") { 19696 delta -= jQuery.css(elem, "padding" + cssExpand[i], true, styles); 19697 } // For "content" or "padding", subtract border 19698 19699 19700 if (box !== "margin") { 19701 delta -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles); 19702 } 19703 } 19704 } // Account for positive content-box scroll gutter when requested by providing computedVal 19705 19706 19707 if (!isBorderBox && computedVal >= 0) { 19708 // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border 19709 // Assuming integer scroll gutter, subtract the rest and round down 19710 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 19711 // Use an explicit zero to avoid NaN (gh-3964) 19712 )) || 0; 19713 } 19714 19715 return delta; 19716 } 19717 19718 function getWidthOrHeight(elem, dimension, extra) { 19719 // Start with computed style 19720 var styles = getStyles(elem), 19721 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). 19722 // Fake content-box until we know it's needed to know the true value. 19723 boxSizingNeeded = !support.boxSizingReliable() || extra, 19724 isBorderBox = boxSizingNeeded && jQuery.css(elem, "boxSizing", false, styles) === "border-box", 19725 valueIsBorderBox = isBorderBox, 19726 val = curCSS(elem, dimension, styles), 19727 offsetProp = "offset" + dimension[0].toUpperCase() + dimension.slice(1);
vendor: 7,190 bytes, lines 19727-19921
19727 // Support: Firefox <=54 19728 // Return a confounding non-pixel value or feign ignorance, as appropriate. 19729 19730 if (rnumnonpx.test(val)) { 19731 if (!extra) { 19732 return val; 19733 } 19734 19735 val = "auto"; 19736 } // Support: IE 9 - 11 only 19737 // Use offsetWidth/offsetHeight for when box sizing is unreliable. 19738 // In those cases, the computed value can be trusted to be border-box. 19739 19740 19741 if ((!support.boxSizingReliable() && isBorderBox || // Support: IE 10 - 11+, Edge 15 - 18+ 19742 // IE/Edge misreport `getComputedStyle` of table rows with width/height 19743 // set in CSS while `offset*` properties report correct values. 19744 // Interestingly, in some cases IE 9 doesn't suffer from this issue. 19745 !support.reliableTrDimensions() && nodeName(elem, "tr") || // Fall back to offsetWidth/offsetHeight when value is "auto" 19746 // This happens for inline elements with no explicit setting (gh-3571) 19747 val === "auto" || // Support: Android <=4.1 - 4.3 only 19748 // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) 19749 !parseFloat(val) && jQuery.css(elem, "display", false, styles) === "inline") && // Make sure the element is visible & connected 19750 elem.getClientRects().length) { 19751 isBorderBox = jQuery.css(elem, "boxSizing", false, styles) === "border-box"; // Where available, offsetWidth/offsetHeight approximate border box dimensions. 19752 // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the 19753 // retrieved value as a content box dimension. 19754 19755 valueIsBorderBox = offsetProp in elem; 19756 19757 if (valueIsBorderBox) { 19758 val = elem[offsetProp]; 19759 } 19760 } // Normalize "" and auto 19761 19762 19763 val = parseFloat(val) || 0; // Adjust for the element's box model 19764 19765 return val + boxModelAdjustment(elem, dimension, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles, // Provide the current computed size to request scroll gutter calculation (gh-3589) 19766 val) + "px"; 19767 } 19768 19769 jQuery.extend({ 19770 // Add in style property hooks for overriding the default 19771 // behavior of getting and setting a style property 19772 cssHooks: { 19773 opacity: { 19774 get: function get(elem, computed) { 19775 if (computed) { 19776 // We should always get a number back from opacity 19777 var ret = curCSS(elem, "opacity"); 19778 return ret === "" ? "1" : ret; 19779 } 19780 } 19781 } 19782 }, 19783 // Don't automatically add "px" to these possibly-unitless properties 19784 cssNumber: { 19785 "animationIterationCount": true, 19786 "columnCount": true, 19787 "fillOpacity": true, 19788 "flexGrow": true, 19789 "flexShrink": true, 19790 "fontWeight": true, 19791 "gridArea": true, 19792 "gridColumn": true, 19793 "gridColumnEnd": true, 19794 "gridColumnStart": true, 19795 "gridRow": true, 19796 "gridRowEnd": true, 19797 "gridRowStart": true, 19798 "lineHeight": true, 19799 "opacity": true, 19800 "order": true, 19801 "orphans": true, 19802 "widows": true, 19803 "zIndex": true, 19804 "zoom": true 19805 }, 19806 // Add in properties whose names you wish to fix before 19807 // setting or getting the value 19808 cssProps: {}, 19809 // Get and set the style property on a DOM Node 19810 style: function style(elem, name, value, extra) { 19811 // Don't set styles on text and comment nodes 19812 if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) { 19813 return; 19814 } // Make sure that we're working with the right name 19815 19816 19817 var ret, 19818 type, 19819 hooks, 19820 origName = camelCase(name), 19821 isCustomProp = rcustomProp.test(name), 19822 style = elem.style; // Make sure that we're working with the right name. We don't 19823 // want to query the value if it is a CSS custom property 19824 // since they are user-defined. 19825 19826 if (!isCustomProp) { 19827 name = finalPropName(origName); 19828 } // Gets hook for the prefixed version, then unprefixed version 19829 19830 19831 hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; // Check if we're setting a value 19832 19833 if (value !== undefined) { 19834 type = _typeof(value); // Convert "+=" or "-=" to relative numbers (#7345) 19835 19836 if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) { 19837 value = adjustCSS(elem, name, ret); // Fixes bug #9237 19838 19839 type = "number"; 19840 } // Make sure that null and NaN values aren't set (#7116) 19841 19842 19843 if (value == null || value !== value) { 19844 return; 19845 } // If a number was passed in, add the unit (except for certain CSS properties) 19846 // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append 19847 // "px" to a few hardcoded values. 19848 19849 19850 if (type === "number" && !isCustomProp) { 19851 value += ret && ret[3] || (jQuery.cssNumber[origName] ? "" : "px"); 19852 } // background-* props affect original clone's values 19853 19854 19855 if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) { 19856 style[name] = "inherit"; 19857 } // If a hook was provided, use that value, otherwise just set the specified value 19858 19859 19860 if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) { 19861 if (isCustomProp) { 19862 style.setProperty(name, value); 19863 } else { 19864 style[name] = value; 19865 } 19866 } 19867 } else { 19868 // If a hook was provided get the non-computed value from there 19869 if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) { 19870 return ret; 19871 } // Otherwise just get the value from the style object 19872 19873 19874 return style[name]; 19875 } 19876 }, 19877 css: function css(elem, name, extra, styles) { 19878 var val, 19879 num, 19880 hooks, 19881 origName = camelCase(name), 19882 isCustomProp = rcustomProp.test(name); // Make sure that we're working with the right name. We don't 19883 // want to modify the value if it is a CSS custom property 19884 // since they are user-defined. 19885 19886 if (!isCustomProp) { 19887 name = finalPropName(origName); 19888 } // Try prefixed name followed by the unprefixed name 19889 19890 19891 hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; // If a hook was provided get the computed value from there 19892 19893 if (hooks && "get" in hooks) { 19894 val = hooks.get(elem, true, extra); 19895 } // Otherwise, if a way to get the computed value exists, use that 19896 19897 19898 if (val === undefined) { 19899 val = curCSS(elem, name, styles); 19900 } // Convert "normal" to computed value 19901 19902 19903 if (val === "normal" && name in cssNormalTransform) { 19904 val = cssNormalTransform[name]; 19905 } // Make numeric if forced or a qualifier was provided and val looks numeric 19906 19907 19908 if (extra === "" || extra) { 19909 num = parseFloat(val); 19910 return extra === true || isFinite(num) ? num || 0 : val; 19911 } 19912 19913 return val; 19914 } 19915 }); 19916 jQuery.each(["height", "width"], function (_i, dimension) { 19917 jQuery.cssHooks[dimension] = { 19918 get: function get(elem, computed, extra) { 19919 if (computed) { 19920 // Certain elements can have dimension info if we invisibly show them 19921 // but it must have a current display style that would benefit
vendor: 10,646 bytes, lines 19922-20251
19922 return rdisplayswap.test(jQuery.css(elem, "display")) && ( // Support: Safari 8+ 19923 // Table columns in Safari have non-zero offsetWidth & zero 19924 // getBoundingClientRect().width unless display is changed. 19925 // Support: IE <=11 only 19926 // Running getBoundingClientRect on a disconnected node 19927 // in IE throws an error. 19928 !elem.getClientRects().length || !elem.getBoundingClientRect().width) ? swap(elem, cssShow, function () { 19929 return getWidthOrHeight(elem, dimension, extra); 19930 }) : getWidthOrHeight(elem, dimension, extra); 19931 } 19932 }, 19933 set: function set(elem, value, extra) { 19934 var matches, 19935 styles = getStyles(elem), 19936 // Only read styles.position if the test has a chance to fail 19937 // to avoid forcing a reflow. 19938 scrollboxSizeBuggy = !support.scrollboxSize() && styles.position === "absolute", 19939 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) 19940 boxSizingNeeded = scrollboxSizeBuggy || extra, 19941 isBorderBox = boxSizingNeeded && jQuery.css(elem, "boxSizing", false, styles) === "border-box", 19942 subtract = extra ? boxModelAdjustment(elem, dimension, extra, isBorderBox, styles) : 0; // Account for unreliable border-box dimensions by comparing offset* to computed and 19943 // faking a content-box to get border and padding (gh-3699) 19944 19945 if (isBorderBox && scrollboxSizeBuggy) { 19946 subtract -= Math.ceil(elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - parseFloat(styles[dimension]) - boxModelAdjustment(elem, dimension, "border", false, styles) - 0.5); 19947 } // Convert to pixels if value adjustment is needed 19948 19949 19950 if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || "px") !== "px") { 19951 elem.style[dimension] = value; 19952 value = jQuery.css(elem, dimension); 19953 } 19954 19955 return setPositiveNumber(elem, value, subtract); 19956 } 19957 }; 19958 }); 19959 jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function (elem, computed) { 19960 if (computed) { 19961 return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, { 19962 marginLeft: 0 19963 }, function () { 19964 return elem.getBoundingClientRect().left; 19965 })) + "px"; 19966 } 19967 }); // These hooks are used by animate to expand properties 19968 19969 jQuery.each({ 19970 margin: "", 19971 padding: "", 19972 border: "Width" 19973 }, function (prefix, suffix) { 19974 jQuery.cssHooks[prefix + suffix] = { 19975 expand: function expand(value) { 19976 var i = 0, 19977 expanded = {}, 19978 // Assumes a single number if not a string 19979 parts = typeof value === "string" ? value.split(" ") : [value]; 19980 19981 for (; i < 4; i++) { 19982 expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0]; 19983 } 19984 19985 return expanded; 19986 } 19987 }; 19988 19989 if (prefix !== "margin") { 19990 jQuery.cssHooks[prefix + suffix].set = setPositiveNumber; 19991 } 19992 }); 19993 jQuery.fn.extend({ 19994 css: function css(name, value) { 19995 return access(this, function (elem, name, value) { 19996 var styles, 19997 len, 19998 map = {}, 19999 i = 0; 20000 20001 if (Array.isArray(name)) { 20002 styles = getStyles(elem); 20003 len = name.length; 20004 20005 for (; i < len; i++) { 20006 map[name[i]] = jQuery.css(elem, name[i], false, styles); 20007 } 20008 20009 return map; 20010 } 20011 20012 return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name); 20013 }, name, value, arguments.length > 1); 20014 } 20015 }); 20016 20017 function Tween(elem, options, prop, end, easing) { 20018 return new Tween.prototype.init(elem, options, prop, end, easing); 20019 } 20020 20021 jQuery.Tween = Tween; 20022 Tween.prototype = { 20023 constructor: Tween, 20024 init: function init(elem, options, prop, end, easing, unit) { 20025 this.elem = elem; 20026 this.prop = prop; 20027 this.easing = easing || jQuery.easing._default; 20028 this.options = options; 20029 this.start = this.now = this.cur(); 20030 this.end = end; 20031 this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px"); 20032 }, 20033 cur: function cur() { 20034 var hooks = Tween.propHooks[this.prop]; 20035 return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this); 20036 }, 20037 run: function run(percent) { 20038 var eased, 20039 hooks = Tween.propHooks[this.prop]; 20040 20041 if (this.options.duration) { 20042 this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration); 20043 } else { 20044 this.pos = eased = percent; 20045 } 20046 20047 this.now = (this.end - this.start) * eased + this.start; 20048 20049 if (this.options.step) { 20050 this.options.step.call(this.elem, this.now, this); 20051 } 20052 20053 if (hooks && hooks.set) { 20054 hooks.set(this); 20055 } else { 20056 Tween.propHooks._default.set(this); 20057 } 20058 20059 return this; 20060 } 20061 }; 20062 Tween.prototype.init.prototype = Tween.prototype; 20063 Tween.propHooks = { 20064 _default: { 20065 get: function get(tween) { 20066 var result; // Use a property on the element directly when it is not a DOM element, 20067 // or when there is no matching style property that exists. 20068 20069 if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) { 20070 return tween.elem[tween.prop]; 20071 } // Passing an empty string as a 3rd parameter to .css will automatically 20072 // attempt a parseFloat and fallback to a string if the parse fails. 20073 // Simple values such as "10px" are parsed to Float; 20074 // complex values such as "rotate(1rad)" are returned as-is. 20075 20076 20077 result = jQuery.css(tween.elem, tween.prop, ""); // Empty strings, null, undefined and "auto" are converted to 0. 20078 20079 return !result || result === "auto" ? 0 : result; 20080 }, 20081 set: function set(tween) { 20082 // Use step hook for back compat. 20083 // Use cssHook if its there. 20084 // Use .style if available and use plain properties where available. 20085 if (jQuery.fx.step[tween.prop]) { 20086 jQuery.fx.step[tween.prop](tween); 20087 } else if (tween.elem.nodeType === 1 && (jQuery.cssHooks[tween.prop] || tween.elem.style[finalPropName(tween.prop)] != null)) { 20088 jQuery.style(tween.elem, tween.prop, tween.now + tween.unit); 20089 } else { 20090 tween.elem[tween.prop] = tween.now; 20091 } 20092 } 20093 } 20094 }; // Support: IE <=9 only 20095 // Panic based approach to setting things on disconnected nodes 20096 20097 Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { 20098 set: function set(tween) { 20099 if (tween.elem.nodeType && tween.elem.parentNode) { 20100 tween.elem[tween.prop] = tween.now; 20101 } 20102 } 20103 }; 20104 jQuery.easing = { 20105 linear: function linear(p) { 20106 return p; 20107 }, 20108 swing: function swing(p) { 20109 return 0.5 - Math.cos(p * Math.PI) / 2; 20110 }, 20111 _default: "swing" 20112 }; 20113 jQuery.fx = Tween.prototype.init; // Back compat <1.8 extension point 20114 20115 jQuery.fx.step = {}; 20116 var fxNow, 20117 inProgress, 20118 rfxtypes = /^(?:toggle|show|hide)$/, 20119 rrun = /queueHooks$/; 20120 20121 function schedule() { 20122 if (inProgress) { 20123 if (document.hidden === false && window.requestAnimationFrame) { 20124 window.requestAnimationFrame(schedule); 20125 } else { 20126 window.setTimeout(schedule, jQuery.fx.interval); 20127 } 20128 20129 jQuery.fx.tick(); 20130 } 20131 } // Animations created synchronously will run synchronously 20132 20133 20134 function createFxNow() { 20135 window.setTimeout(function () { 20136 fxNow = undefined; 20137 }); 20138 return fxNow = Date.now(); 20139 } // Generate parameters to create a standard animation 20140 20141 20142 function genFx(type, includeWidth) { 20143 var which, 20144 i = 0, 20145 attrs = { 20146 height: type 20147 }; // If we include width, step value is 1 to do all cssExpand values, 20148 // otherwise step value is 2 to skip over Left and Right 20149 20150 includeWidth = includeWidth ? 1 : 0; 20151 20152 for (; i < 4; i += 2 - includeWidth) { 20153 which = cssExpand[i]; 20154 attrs["margin" + which] = attrs["padding" + which] = type; 20155 } 20156 20157 if (includeWidth) { 20158 attrs.opacity = attrs.width = type; 20159 } 20160 20161 return attrs; 20162 } 20163 20164 function createTween(value, prop, animation) { 20165 var tween, 20166 collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]), 20167 index = 0, 20168 length = collection.length; 20169 20170 for (; index < length; index++) { 20171 if (tween = collection[index].call(animation, prop, value)) { 20172 // We're done with this property 20173 return tween; 20174 } 20175 } 20176 } 20177 20178 function defaultPrefilter(elem, props, opts) { 20179 var prop, 20180 value, 20181 toggle, 20182 hooks, 20183 oldfire, 20184 propTween, 20185 restoreDisplay, 20186 display, 20187 isBox = "width" in props || "height" in props, 20188 anim = this, 20189 orig = {}, 20190 style = elem.style, 20191 hidden = elem.nodeType && isHiddenWithinTree(elem), 20192 dataShow = dataPriv.get(elem, "fxshow"); // Queue-skipping animations hijack the fx hooks 20193 20194 if (!opts.queue) { 20195 hooks = jQuery._queueHooks(elem, "fx"); 20196 20197 if (hooks.unqueued == null) { 20198 hooks.unqueued = 0; 20199 oldfire = hooks.empty.fire; 20200 20201 hooks.empty.fire = function () { 20202 if (!hooks.unqueued) { 20203 oldfire(); 20204 } 20205 }; 20206 } 20207 20208 hooks.unqueued++; 20209 anim.always(function () { 20210 // Ensure the complete handler is called before this completes 20211 anim.always(function () { 20212 hooks.unqueued--; 20213 20214 if (!jQuery.queue(elem, "fx").length) { 20215 hooks.empty.fire(); 20216 } 20217 }); 20218 }); 20219 } // Detect show/hide animations 20220 20221 20222 for (prop in props) { 20223 value = props[prop]; 20224 20225 if (rfxtypes.test(value)) { 20226 delete props[prop]; 20227 toggle = toggle || value === "toggle"; 20228 20229 if (value === (hidden ? "hide" : "show")) { 20230 // Pretend to be hidden if this is a "show" and 20231 // there is still data from a stopped show/hide 20232 if (value === "show" && dataShow && dataShow[prop] !== undefined) { 20233 hidden = true; // Ignore all other no-op show/hide data 20234 } else { 20235 continue; 20236 } 20237 } 20238 20239 orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop); 20240 } 20241 } // Bail out if this is a no-op like .hide().hide() 20242 20243 20244 propTween = !jQuery.isEmptyObject(props); 20245 20246 if (!propTween && jQuery.isEmptyObject(orig)) { 20247 return; 20248 } // Restrict "overflow" and "display" styles during box animations 20249 20250 20251 if (isBox && elem.nodeType === 1) {
vendor: 3,436 bytes, lines 20252-20368
20252 // Support: IE <=9 - 11, Edge 12 - 15 20253 // Record all 3 overflow attributes because IE does not infer the shorthand 20254 // from identically-valued overflowX and overflowY and Edge just mirrors 20255 // the overflowX value there. 20256 opts.overflow = [style.overflow, style.overflowX, style.overflowY]; // Identify a display type, preferring old show/hide data over the CSS cascade 20257 20258 restoreDisplay = dataShow && dataShow.display; 20259 20260 if (restoreDisplay == null) { 20261 restoreDisplay = dataPriv.get(elem, "display"); 20262 } 20263 20264 display = jQuery.css(elem, "display"); 20265 20266 if (display === "none") { 20267 if (restoreDisplay) { 20268 display = restoreDisplay; 20269 } else { 20270 // Get nonempty value(s) by temporarily forcing visibility 20271 showHide([elem], true); 20272 restoreDisplay = elem.style.display || restoreDisplay; 20273 display = jQuery.css(elem, "display"); 20274 showHide([elem]); 20275 } 20276 } // Animate inline elements as inline-block 20277 20278 20279 if (display === "inline" || display === "inline-block" && restoreDisplay != null) { 20280 if (jQuery.css(elem, "float") === "none") { 20281 // Restore the original display value at the end of pure show/hide animations 20282 if (!propTween) { 20283 anim.done(function () { 20284 style.display = restoreDisplay; 20285 }); 20286 20287 if (restoreDisplay == null) { 20288 display = style.display; 20289 restoreDisplay = display === "none" ? "" : display; 20290 } 20291 } 20292 20293 style.display = "inline-block"; 20294 } 20295 } 20296 } 20297 20298 if (opts.overflow) { 20299 style.overflow = "hidden"; 20300 anim.always(function () { 20301 style.overflow = opts.overflow[0]; 20302 style.overflowX = opts.overflow[1]; 20303 style.overflowY = opts.overflow[2]; 20304 }); 20305 } // Implement show/hide animations 20306 20307 20308 propTween = false; 20309 20310 for (prop in orig) { 20311 // General show/hide setup for this element animation 20312 if (!propTween) { 20313 if (dataShow) { 20314 if ("hidden" in dataShow) { 20315 hidden = dataShow.hidden; 20316 } 20317 } else { 20318 dataShow = dataPriv.access(elem, "fxshow", { 20319 display: restoreDisplay 20320 }); 20321 } // Store hidden/visible for toggle so `.stop().toggle()` "reverses" 20322 20323 20324 if (toggle) { 20325 dataShow.hidden = !hidden; 20326 } // Show elements before animating them 20327 20328 20329 if (hidden) { 20330 showHide([elem], true); 20331 } 20332 /* eslint-disable no-loop-func */ 20333 20334 20335 anim.done(function () { 20336 /* eslint-enable no-loop-func */ 20337 // The final step of a "hide" animation is actually hiding the element 20338 if (!hidden) { 20339 showHide([elem]); 20340 } 20341 20342 dataPriv.remove(elem, "fxshow"); 20343 20344 for (prop in orig) { 20345 jQuery.style(elem, prop, orig[prop]); 20346 } 20347 }); 20348 } // Per-property setup 20349 20350 20351 propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim); 20352 20353 if (!(prop in dataShow)) { 20354 dataShow[prop] = propTween.start; 20355 20356 if (hidden) { 20357 propTween.end = propTween.start; 20358 propTween.start = 0; 20359 } 20360 } 20361 } 20362 } 20363 20364 function propFilter(props, specialEasing) { 20365 var index, name, easing, value, hooks; // camelCase, specialEasing and expand cssHook pass 20366 20367 for (index in props) { 20368 name = camelCase(index);
vendor: 7,049 bytes, lines 20369-20608
20369 easing = specialEasing[name]; 20370 value = props[index]; 20371 20372 if (Array.isArray(value)) { 20373 easing = value[1]; 20374 value = props[index] = value[0]; 20375 } 20376 20377 if (index !== name) { 20378 props[name] = value; 20379 delete props[index]; 20380 } 20381 20382 hooks = jQuery.cssHooks[name]; 20383 20384 if (hooks && "expand" in hooks) { 20385 value = hooks.expand(value); 20386 delete props[name]; // Not quite $.extend, this won't overwrite existing keys. 20387 // Reusing 'index' because we have the correct "name" 20388 20389 for (index in value) { 20390 if (!(index in props)) { 20391 props[index] = value[index]; 20392 specialEasing[index] = easing; 20393 } 20394 } 20395 } else { 20396 specialEasing[name] = easing; 20397 } 20398 } 20399 } 20400 20401 function Animation(elem, properties, options) { 20402 var result, 20403 stopped, 20404 index = 0, 20405 length = Animation.prefilters.length, 20406 deferred = jQuery.Deferred().always(function () { 20407 // Don't match elem in the :animated selector 20408 delete tick.elem; 20409 }), 20410 tick = function tick() { 20411 if (stopped) { 20412 return false; 20413 } 20414 20415 var currentTime = fxNow || createFxNow(), 20416 remaining = Math.max(0, animation.startTime + animation.duration - currentTime), 20417 // Support: Android 2.3 only 20418 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) 20419 temp = remaining / animation.duration || 0, 20420 percent = 1 - temp, 20421 index = 0, 20422 length = animation.tweens.length; 20423 20424 for (; index < length; index++) { 20425 animation.tweens[index].run(percent); 20426 } 20427 20428 deferred.notifyWith(elem, [animation, percent, remaining]); // If there's more to do, yield 20429 20430 if (percent < 1 && length) { 20431 return remaining; 20432 } // If this was an empty animation, synthesize a final progress notification 20433 20434 20435 if (!length) { 20436 deferred.notifyWith(elem, [animation, 1, 0]); 20437 } // Resolve the animation and report its conclusion 20438 20439 20440 deferred.resolveWith(elem, [animation]); 20441 return false; 20442 }, 20443 animation = deferred.promise({ 20444 elem: elem, 20445 props: jQuery.extend({}, properties), 20446 opts: jQuery.extend(true, { 20447 specialEasing: {}, 20448 easing: jQuery.easing._default 20449 }, options), 20450 originalProperties: properties, 20451 originalOptions: options, 20452 startTime: fxNow || createFxNow(), 20453 duration: options.duration, 20454 tweens: [], 20455 createTween: function createTween(prop, end) { 20456 var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing); 20457 animation.tweens.push(tween); 20458 return tween; 20459 }, 20460 stop: function stop(gotoEnd) { 20461 var index = 0, 20462 // If we are going to the end, we want to run all the tweens 20463 // otherwise we skip this part 20464 length = gotoEnd ? animation.tweens.length : 0; 20465 20466 if (stopped) { 20467 return this; 20468 } 20469 20470 stopped = true; 20471 20472 for (; index < length; index++) { 20473 animation.tweens[index].run(1); 20474 } // Resolve when we played the last frame; otherwise, reject 20475 20476 20477 if (gotoEnd) { 20478 deferred.notifyWith(elem, [animation, 1, 0]); 20479 deferred.resolveWith(elem, [animation, gotoEnd]); 20480 } else { 20481 deferred.rejectWith(elem, [animation, gotoEnd]); 20482 } 20483 20484 return this; 20485 } 20486 }), 20487 props = animation.props; 20488 20489 propFilter(props, animation.opts.specialEasing); 20490 20491 for (; index < length; index++) { 20492 result = Animation.prefilters[index].call(animation, elem, props, animation.opts); 20493 20494 if (result) { 20495 if (isFunction(result.stop)) { 20496 jQuery._queueHooks(animation.elem, animation.opts.queue).stop = result.stop.bind(result); 20497 } 20498 20499 return result; 20500 } 20501 } 20502 20503 jQuery.map(props, createTween, animation); 20504 20505 if (isFunction(animation.opts.start)) { 20506 animation.opts.start.call(elem, animation); 20507 } // Attach callbacks from options 20508 20509 20510 animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always); 20511 jQuery.fx.timer(jQuery.extend(tick, { 20512 elem: elem, 20513 anim: animation, 20514 queue: animation.opts.queue 20515 })); 20516 return animation; 20517 } 20518 20519 jQuery.Animation = jQuery.extend(Animation, { 20520 tweeners: { 20521 "*": [function (prop, value) { 20522 var tween = this.createTween(prop, value); 20523 adjustCSS(tween.elem, prop, rcssNum.exec(value), tween); 20524 return tween; 20525 }] 20526 }, 20527 tweener: function tweener(props, callback) { 20528 if (isFunction(props)) { 20529 callback = props; 20530 props = ["*"]; 20531 } else { 20532 props = props.match(rnothtmlwhite); 20533 } 20534 20535 var prop, 20536 index = 0, 20537 length = props.length; 20538 20539 for (; index < length; index++) { 20540 prop = props[index]; 20541 Animation.tweeners[prop] = Animation.tweeners[prop] || []; 20542 Animation.tweeners[prop].unshift(callback); 20543 } 20544 }, 20545 prefilters: [defaultPrefilter], 20546 prefilter: function prefilter(callback, prepend) { 20547 if (prepend) { 20548 Animation.prefilters.unshift(callback); 20549 } else { 20550 Animation.prefilters.push(callback); 20551 } 20552 } 20553 }); 20554 20555 jQuery.speed = function (speed, easing, fn) { 20556 var opt = speed && _typeof(speed) === "object" ? jQuery.extend({}, speed) : { 20557 complete: fn || !fn && easing || isFunction(speed) && speed, 20558 duration: speed, 20559 easing: fn && easing || easing && !isFunction(easing) && easing 20560 }; // Go to the end state if fx are off 20561 20562 if (jQuery.fx.off) { 20563 opt.duration = 0; 20564 } else { 20565 if (typeof opt.duration !== "number") { 20566 if (opt.duration in jQuery.fx.speeds) { 20567 opt.duration = jQuery.fx.speeds[opt.duration]; 20568 } else { 20569 opt.duration = jQuery.fx.speeds._default; 20570 } 20571 } 20572 } // Normalize opt.queue - true/undefined/null -> "fx" 20573 20574 20575 if (opt.queue == null || opt.queue === true) { 20576 opt.queue = "fx"; 20577 } // Queueing 20578 20579 20580 opt.old = opt.complete; 20581 20582 opt.complete = function () { 20583 if (isFunction(opt.old)) { 20584 opt.old.call(this); 20585 } 20586 20587 if (opt.queue) { 20588 jQuery.dequeue(this, opt.queue); 20589 } 20590 }; 20591 20592 return opt; 20593 }; 20594 20595 jQuery.fn.extend({ 20596 fadeTo: function fadeTo(speed, to, easing, callback) { 20597 // Show any hidden elements after setting opacity to 0 20598 return this.filter(isHiddenWithinTree).css("opacity", 0).show() // Animate to the value specified 20599 .end().animate({ 20600 opacity: to 20601 }, speed, easing, callback); 20602 }, 20603 animate: function animate(prop, speed, easing, callback) { 20604 var empty = jQuery.isEmptyObject(prop), 20605 optall = jQuery.speed(speed, easing, callback), 20606 doAnimation = function doAnimation() { 20607 // Operate on a copy of prop so per-property easing won't be lost 20608 var anim = Animation(this, jQuery.extend({}
vendor: 4,789 bytes, lines 20608-20786
20608, prop), optall); // Empty animations, or finishing resolves immediately 20609 20610 if (empty || dataPriv.get(this, "finish")) { 20611 anim.stop(true); 20612 } 20613 }; 20614 20615 doAnimation.finish = doAnimation; 20616 return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation); 20617 }, 20618 stop: function stop(type, clearQueue, gotoEnd) { 20619 var stopQueue = function stopQueue(hooks) { 20620 var stop = hooks.stop; 20621 delete hooks.stop; 20622 stop(gotoEnd); 20623 }; 20624 20625 if (typeof type !== "string") { 20626 gotoEnd = clearQueue; 20627 clearQueue = type; 20628 type = undefined; 20629 } 20630 20631 if (clearQueue) { 20632 this.queue(type || "fx", []); 20633 } 20634 20635 return this.each(function () { 20636 var dequeue = true, 20637 index = type != null && type + "queueHooks", 20638 timers = jQuery.timers, 20639 data = dataPriv.get(this); 20640 20641 if (index) { 20642 if (data[index] && data[index].stop) { 20643 stopQueue(data[index]); 20644 } 20645 } else { 20646 for (index in data) { 20647 if (data[index] && data[index].stop && rrun.test(index)) { 20648 stopQueue(data[index]); 20649 } 20650 } 20651 } 20652 20653 for (index = timers.length; index--;) { 20654 if (timers[index].elem === this && (type == null || timers[index].queue === type)) { 20655 timers[index].anim.stop(gotoEnd); 20656 dequeue = false; 20657 timers.splice(index, 1); 20658 } 20659 } // Start the next in the queue if the last step wasn't forced. 20660 // Timers currently will call their complete callbacks, which 20661 // will dequeue but only if they were gotoEnd. 20662 20663 20664 if (dequeue || !gotoEnd) { 20665 jQuery.dequeue(this, type); 20666 } 20667 }); 20668 }, 20669 finish: function finish(type) { 20670 if (type !== false) { 20671 type = type || "fx"; 20672 } 20673 20674 return this.each(function () { 20675 var index, 20676 data = dataPriv.get(this), 20677 queue = data[type + "queue"], 20678 hooks = data[type + "queueHooks"], 20679 timers = jQuery.timers, 20680 length = queue ? queue.length : 0; // Enable finishing flag on private data 20681 20682 data.finish = true; // Empty the queue first 20683 20684 jQuery.queue(this, type, []); 20685 20686 if (hooks && hooks.stop) { 20687 hooks.stop.call(this, true); 20688 } // Look for any active animations, and finish them 20689 20690 20691 for (index = timers.length; index--;) { 20692 if (timers[index].elem === this && timers[index].queue === type) { 20693 timers[index].anim.stop(true); 20694 timers.splice(index, 1); 20695 } 20696 } // Look for any animations in the old queue and finish them 20697 20698 20699 for (index = 0; index < length; index++) { 20700 if (queue[index] && queue[index].finish) { 20701 queue[index].finish.call(this); 20702 } 20703 } // Turn off finishing flag 20704 20705 20706 delete data.finish; 20707 }); 20708 } 20709 }); 20710 jQuery.each(["toggle", "show", "hide"], function (_i, name) { 20711 var cssFn = jQuery.fn[name]; 20712 20713 jQuery.fn[name] = function (speed, easing, callback) { 20714 return speed == null || typeof speed === "boolean" ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback); 20715 }; 20716 }); // Generate shortcuts for custom animations 20717 20718 jQuery.each({ 20719 slideDown: genFx("show"), 20720 slideUp: genFx("hide"), 20721 slideToggle: genFx("toggle"), 20722 fadeIn: { 20723 opacity: "show" 20724 }, 20725 fadeOut: { 20726 opacity: "hide" 20727 }, 20728 fadeToggle: { 20729 opacity: "toggle" 20730 } 20731 }, function (name, props) { 20732 jQuery.fn[name] = function (speed, easing, callback) { 20733 return this.animate(props, speed, easing, callback); 20734 }; 20735 }); 20736 jQuery.timers = []; 20737 20738 jQuery.fx.tick = function () { 20739 var timer, 20740 i = 0, 20741 timers = jQuery.timers; 20742 fxNow = Date.now(); 20743 20744 for (; i < timers.length; i++) { 20745 timer = timers[i]; // Run the timer and safely remove it when done (allowing for external removal) 20746 20747 if (!timer() && timers[i] === timer) { 20748 timers.splice(i--, 1); 20749 } 20750 } 20751 20752 if (!timers.length) { 20753 jQuery.fx.stop(); 20754 } 20755 20756 fxNow = undefined; 20757 }; 20758 20759 jQuery.fx.timer = function (timer) { 20760 jQuery.timers.push(timer); 20761 jQuery.fx.start(); 20762 }; 20763 20764 jQuery.fx.interval = 13; 20765 20766 jQuery.fx.start = function () { 20767 if (inProgress) { 20768 return; 20769 } 20770 20771 inProgress = true; 20772 schedule(); 20773 }; 20774 20775 jQuery.fx.stop = function () { 20776 inProgress = null; 20777 }; 20778 20779 jQuery.fx.speeds = { 20780 slow: 600, 20781 fast: 200, 20782 // Default speed 20783 _default: 400 20784 }; // Based off of the plugin by Clint Helfers, with permission. 20785 // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ 20786
vendor: 5,692 bytes, lines 20787-20979
20787 jQuery.fn.delay = function (time, type) { 20788 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time; 20789 type = type || "fx"; 20790 return this.queue(type, function (next, hooks) { 20791 var timeout = window.setTimeout(next, time); 20792 20793 hooks.stop = function () { 20794 window.clearTimeout(timeout); 20795 }; 20796 }); 20797 }; 20798 20799 (function () { 20800 var input = document.createElement("input"), 20801 select = document.createElement("select"), 20802 opt = select.appendChild(document.createElement("option")); 20803 input.type = "checkbox"; // Support: Android <=4.3 only 20804 // Default value for a checkbox should be "on" 20805 20806 support.checkOn = input.value !== ""; // Support: IE <=11 only 20807 // Must access selectedIndex to make default options select 20808 20809 support.optSelected = opt.selected; // Support: IE <=11 only 20810 // An input loses its value after becoming a radio 20811 20812 input = document.createElement("input"); 20813 input.value = "t"; 20814 input.type = "radio"; 20815 support.radioValue = input.value === "t"; 20816 })(); 20817 20818 var boolHook, 20819 attrHandle = jQuery.expr.attrHandle; 20820 jQuery.fn.extend({ 20821 attr: function attr(name, value) { 20822 return access(this, jQuery.attr, name, value, arguments.length > 1); 20823 }, 20824 removeAttr: function removeAttr(name) { 20825 return this.each(function () { 20826 jQuery.removeAttr(this, name); 20827 }); 20828 } 20829 }); 20830 jQuery.extend({ 20831 attr: function attr(elem, name, value) { 20832 var ret, 20833 hooks, 20834 nType = elem.nodeType; // Don't get/set attributes on text, comment and attribute nodes 20835 20836 if (nType === 3 || nType === 8 || nType === 2) { 20837 return; 20838 } // Fallback to prop when attributes are not supported 20839 20840 20841 if (typeof elem.getAttribute === "undefined") { 20842 return jQuery.prop(elem, name, value); 20843 } // Attribute hooks are determined by the lowercase version 20844 // Grab necessary hook if one is defined 20845 20846 20847 if (nType !== 1 || !jQuery.isXMLDoc(elem)) { 20848 hooks = jQuery.attrHooks[name.toLowerCase()] || (jQuery.expr.match.bool.test(name) ? boolHook : undefined); 20849 } 20850 20851 if (value !== undefined) { 20852 if (value === null) { 20853 jQuery.removeAttr(elem, name); 20854 return; 20855 } 20856 20857 if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) { 20858 return ret; 20859 } 20860 20861 elem.setAttribute(name, value + ""); 20862 return value; 20863 } 20864 20865 if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) { 20866 return ret; 20867 } 20868 20869 ret = jQuery.find.attr(elem, name); // Non-existent attributes return null, we normalize to undefined 20870 20871 return ret == null ? undefined : ret; 20872 }, 20873 attrHooks: { 20874 type: { 20875 set: function set(elem, value) { 20876 if (!support.radioValue && value === "radio" && nodeName(elem, "input")) { 20877 var val = elem.value; 20878 elem.setAttribute("type", value); 20879 20880 if (val) { 20881 elem.value = val; 20882 } 20883 20884 return value; 20885 } 20886 } 20887 } 20888 }, 20889 removeAttr: function removeAttr(elem, value) { 20890 var name, 20891 i = 0, 20892 // Attribute names can contain non-HTML whitespace characters 20893 // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 20894 attrNames = value && value.match(rnothtmlwhite); 20895 20896 if (attrNames && elem.nodeType === 1) { 20897 while (name = attrNames[i++]) { 20898 elem.removeAttribute(name); 20899 } 20900 } 20901 } 20902 }); // Hooks for boolean attributes 20903 20904 boolHook = { 20905 set: function set(elem, value, name) { 20906 if (value === false) { 20907 // Remove boolean attributes when set to false 20908 jQuery.removeAttr(elem, name); 20909 } else { 20910 elem.setAttribute(name, name); 20911 } 20912 20913 return name; 20914 } 20915 }; 20916 jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function (_i, name) { 20917 var getter = attrHandle[name] || jQuery.find.attr; 20918 20919 attrHandle[name] = function (elem, name, isXML) { 20920 var ret, 20921 handle, 20922 lowercaseName = name.toLowerCase(); 20923 20924 if (!isXML) { 20925 // Avoid an infinite loop by temporarily removing this function from the getter 20926 handle = attrHandle[lowercaseName]; 20927 attrHandle[lowercaseName] = ret; 20928 ret = getter(elem, name, isXML) != null ? lowercaseName : null; 20929 attrHandle[lowercaseName] = handle; 20930 } 20931 20932 return ret; 20933 }; 20934 }); 20935 var rfocusable = /^(?:input|select|textarea|button)$/i, 20936 rclickable = /^(?:a|area)$/i; 20937 jQuery.fn.extend({ 20938 prop: function prop(name, value) { 20939 return access(this, jQuery.prop, name, value, arguments.length > 1); 20940 }, 20941 removeProp: function removeProp(name) { 20942 return this.each(function () { 20943 delete this[jQuery.propFix[name] || name]; 20944 }); 20945 } 20946 }); 20947 jQuery.extend({ 20948 prop: function prop(elem, name, value) { 20949 var ret, 20950 hooks, 20951 nType = elem.nodeType; // Don't get/set properties on text, comment and attribute nodes 20952 20953 if (nType === 3 || nType === 8 || nType === 2) { 20954 return; 20955 } 20956 20957 if (nType !== 1 || !jQuery.isXMLDoc(elem)) { 20958 // Fix name and attach hooks 20959 name = jQuery.propFix[name] || name; 20960 hooks = jQuery.propHooks[name]; 20961 } 20962 20963 if (value !== undefined) { 20964 if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) { 20965 return ret; 20966 } 20967 20968 return elem[name] = value; 20969 } 20970 20971 if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) { 20972 return ret; 20973 } 20974 20975 return elem[name]; 20976 }, 20977 propHooks: { 20978 tabIndex: { 20979 get: function get(elem) {
20980 // Support: IE <=9 - 11 only 20981 // elem.tabIndex doesn't always return the 20982 // correct value when it hasn't been explicitly set 20983 // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ 20984 // Use proper attribute retrieval(#12072) 20985 var tabindex = jQuery.find.attr(elem, "tabindex"); 20986 20987 if (tabindex) { 20988 return parseInt(tabindex, 10); 20989 } 20990 20991 if (rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href) { 20992 return 0; 20993 } 20994 20995 return -1; 20996 } 20997 } 20998 }, 20999 propFix: { 21000 "for": "htmlFor", 21001 "class": "className" 21002 } 21003 }); // Support: IE <=11 only 21004 // Accessing the selectedIndex property 21005 // forces the browser to respect setting selected 21006 // on the option 21007 // The getter ensures a default option is selected 21008 // when in an optgroup 21009 // eslint rule "no-unused-expressions" is disabled for this code 21010 // since it considers such accessions noop 21011 21012 if (!support.optSelected) { 21013 jQuery.propHooks.selected = { 21014 get: function get(elem) { 21015 /* eslint no-unused-expressions: "off" */ 21016 var parent = elem.parentNode; 21017 21018 if (parent && parent.parentNode) { 21019 parent.parentNode.selectedIndex; 21020 } 21021 21022 return null; 21023 }, 21024 set: function set(elem) { 21025 /* eslint no-unused-expressions: "off" */ 21026 var parent = elem.parentNode; 21027 21028 if (parent) { 21029 parent.selectedIndex; 21030 21031 if (parent.parentNode) { 21032 parent.parentNode.selectedIndex; 21033 } 21034 } 21035 } 21036 }; 21037 } 21038 21039 jQuery.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function () { 21040 jQuery.propFix[this.toLowerCase()] = this; 21041 }); // Strip and collapse whitespace according to HTML spec 21042 // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace 21043 21044 function stripAndCollapse(value) { 21045 var tokens = value.match(rnothtmlwhite) || []; 21046 return tokens.join(" "); 21047 } 21048 21049 function getClass(elem) { 21050 return elem.getAttribute && elem.getAttribute("class") || ""; 21051 } 21052 21053 function classesToArray(value) { 21054 if (Array.isArray(value)) { 21055 return value; 21056 } 21057 21058 if (typeof value === "string") { 21059 return value.match(rnothtmlwhite) || []; 21060 } 21061 21062 return []; 21063 } 21064 21065 jQuery.fn.extend({ 21066 addClass: function addClass(value) { 21067 var classes, 21068 elem, 21069 cur, 21070 curValue, 21071 clazz, 21072 j, 21073 finalValue, 21074 i = 0; 21075 21076 if (isFunction(value)) { 21077 return this.each(function (j) { 21078 jQuery(this).addClass(value.call(this, j, getClass(this))); 21079 }); 21080 } 21081 21082 classes = classesToArray(value); 21083 21084 if (classes.length) { 21085 while (elem = this[i++]) { 21086 curValue = getClass(elem); 21087 cur = elem.nodeType === 1 && " " + stripAndCollapse(curValue) + " "; 21088 21089 if (cur) { 21090 j = 0; 21091 21092 while (clazz = classes[j++]) { 21093 if (cur.indexOf(" " + clazz + " ") < 0) { 21094 cur += clazz + " "; 21095 } 21096 } // Only assign if different to avoid unneeded rendering. 21097 21098 21099 finalValue = stripAndCollapse(cur); 21100 21101 if (curValue !== finalValue) { 21102 elem.setAttribute("class", finalValue); 21103 } 21104 } 21105 } 21106 } 21107 21108 return this; 21109 }, 21110 removeClass: function removeClass(value) { 21111 var classes, 21112 elem, 21113 cur, 21114 curValue, 21115 clazz, 21116 j, 21117 finalValue, 21118 i = 0; 21119 21120 if (isFunction(value)) { 21121 return this.each(function (j) { 21122 jQuery(this).removeClass(value.call(this, j, getClass(this))); 21123 }); 21124 } 21125 21126 if (!arguments.length) { 21127 return this.attr("class", ""); 21128 } 21129 21130 classes = classesToArray(value); 21131 21132 if (classes.length) { 21133 while (elem = this[i++]) { 21134 curValue = getClass(elem); // This expression is here for better compressibility (see addClass) 21135 21136 cur = elem.nodeType === 1 && " " + stripAndCollapse(curValue) + " "; 21137 21138 if (cur) { 21139 j = 0; 21140 21141 while (clazz = classes[j++]) {
vendor: 4,650 bytes, lines 21142-21295
21142 // Remove *all* instances 21143 while (cur.indexOf(" " + clazz + " ") > -1) { 21144 cur = cur.replace(" " + clazz + " ", " "); 21145 } 21146 } // Only assign if different to avoid unneeded rendering. 21147 21148 21149 finalValue = stripAndCollapse(cur); 21150 21151 if (curValue !== finalValue) { 21152 elem.setAttribute("class", finalValue); 21153 } 21154 } 21155 } 21156 } 21157 21158 return this; 21159 }, 21160 toggleClass: function toggleClass(value, stateVal) { 21161 var type = _typeof(value), 21162 isValidValue = type === "string" || Array.isArray(value); 21163 21164 if (typeof stateVal === "boolean" && isValidValue) { 21165 return stateVal ? this.addClass(value) : this.removeClass(value); 21166 } 21167 21168 if (isFunction(value)) { 21169 return this.each(function (i) { 21170 jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal); 21171 }); 21172 } 21173 21174 return this.each(function () { 21175 var className, i, self, classNames; 21176 21177 if (isValidValue) { 21178 // Toggle individual class names 21179 i = 0; 21180 self = jQuery(this); 21181 classNames = classesToArray(value); 21182 21183 while (className = classNames[i++]) { 21184 // Check each className given, space separated list 21185 if (self.hasClass(className)) { 21186 self.removeClass(className); 21187 } else { 21188 self.addClass(className); 21189 } 21190 } // Toggle whole class name 21191 21192 } else if (value === undefined || type === "boolean") { 21193 className = getClass(this); 21194 21195 if (className) { 21196 // Store className if set 21197 dataPriv.set(this, "__className__", className); 21198 } // If the element has a class name or if we're passed `false`, 21199 // then remove the whole classname (if there was one, the above saved it). 21200 // Otherwise bring back whatever was previously saved (if anything), 21201 // falling back to the empty string if nothing was stored. 21202 21203 21204 if (this.setAttribute) { 21205 this.setAttribute("class", className || value === false ? "" : dataPriv.get(this, "__className__") || ""); 21206 } 21207 } 21208 }); 21209 }, 21210 hasClass: function hasClass(selector) { 21211 var className, 21212 elem, 21213 i = 0; 21214 className = " " + selector + " "; 21215 21216 while (elem = this[i++]) { 21217 if (elem.nodeType === 1 && (" " + stripAndCollapse(getClass(elem)) + " ").indexOf(className) > -1) { 21218 return true; 21219 } 21220 } 21221 21222 return false; 21223 } 21224 }); 21225 var rreturn = /\r/g; 21226 jQuery.fn.extend({ 21227 val: function val(value) { 21228 var hooks, 21229 ret, 21230 valueIsFunction, 21231 elem = this[0]; 21232 21233 if (!arguments.length) { 21234 if (elem) { 21235 hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()]; 21236 21237 if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined) { 21238 return ret; 21239 } 21240 21241 ret = elem.value; // Handle most common string cases 21242 21243 if (typeof ret === "string") { 21244 return ret.replace(rreturn, ""); 21245 } // Handle cases where value is null/undef or number 21246 21247 21248 return ret == null ? "" : ret; 21249 } 21250 21251 return; 21252 } 21253 21254 valueIsFunction = isFunction(value); 21255 return this.each(function (i) { 21256 var val; 21257 21258 if (this.nodeType !== 1) { 21259 return; 21260 } 21261 21262 if (valueIsFunction) { 21263 val = value.call(this, i, jQuery(this).val()); 21264 } else { 21265 val = value; 21266 } // Treat null/undefined as ""; convert numbers to string 21267 21268 21269 if (val == null) { 21270 val = ""; 21271 } else if (typeof val === "number") { 21272 val += ""; 21273 } else if (Array.isArray(val)) { 21274 val = jQuery.map(val, function (value) { 21275 return value == null ? "" : value + ""; 21276 }); 21277 } 21278 21279 hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()]; // If set returns undefined, fall back to normal setting 21280 21281 if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) { 21282 this.value = val; 21283 } 21284 }); 21285 } 21286 }); 21287 jQuery.extend({ 21288 valHooks: { 21289 option: { 21290 get: function get(elem) { 21291 var val = jQuery.find.attr(elem, "value"); 21292 return val != null ? val : // Support: IE <=10 - 11 only 21293 // option.text throws exceptions (#14686, #14858) 21294 // Strip and collapse whitespace 21295 // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
vendor: 4,161 bytes, lines 21296-21425
21296 stripAndCollapse(jQuery.text(elem)); 21297 } 21298 }, 21299 select: { 21300 get: function get(elem) { 21301 var value, 21302 option, 21303 i, 21304 options = elem.options, 21305 index = elem.selectedIndex, 21306 one = elem.type === "select-one", 21307 values = one ? null : [], 21308 max = one ? index + 1 : options.length; 21309 21310 if (index < 0) { 21311 i = max; 21312 } else { 21313 i = one ? index : 0; 21314 } // Loop through all the selected options 21315 21316 21317 for (; i < max; i++) { 21318 option = options[i]; // Support: IE <=9 only 21319 // IE8-9 doesn't update selected after form reset (#2551) 21320 21321 if ((option.selected || i === index) && // Don't return options that are disabled or in a disabled optgroup 21322 !option.disabled && (!option.parentNode.disabled || !nodeName(option.parentNode, "optgroup"))) { 21323 // Get the specific value for the option 21324 value = jQuery(option).val(); // We don't need an array for one selects 21325 21326 if (one) { 21327 return value; 21328 } // Multi-Selects return an array 21329 21330 21331 values.push(value); 21332 } 21333 } 21334 21335 return values; 21336 }, 21337 set: function set(elem, value) { 21338 var optionSet, 21339 option, 21340 options = elem.options, 21341 values = jQuery.makeArray(value), 21342 i = options.length; 21343 21344 while (i--) { 21345 option = options[i]; 21346 /* eslint-disable no-cond-assign */ 21347 21348 if (option.selected = jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) { 21349 optionSet = true; 21350 } 21351 /* eslint-enable no-cond-assign */ 21352 21353 } // Force browsers to behave consistently when non-matching value is set 21354 21355 21356 if (!optionSet) { 21357 elem.selectedIndex = -1; 21358 } 21359 21360 return values; 21361 } 21362 } 21363 } 21364 }); // Radios and checkboxes getter/setter 21365 21366 jQuery.each(["radio", "checkbox"], function () { 21367 jQuery.valHooks[this] = { 21368 set: function set(elem, value) { 21369 if (Array.isArray(value)) { 21370 return elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1; 21371 } 21372 } 21373 }; 21374 21375 if (!support.checkOn) { 21376 jQuery.valHooks[this].get = function (elem) { 21377 return elem.getAttribute("value") === null ? "on" : elem.value; 21378 }; 21379 } 21380 }); // Return jQuery for attributes-only inclusion 21381 21382 support.focusin = "onfocusin" in window; 21383 21384 var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, 21385 stopPropagationCallback = function stopPropagationCallback(e) { 21386 e.stopPropagation(); 21387 }; 21388 21389 jQuery.extend(jQuery.event, { 21390 trigger: function trigger(event, data, elem, onlyHandlers) { 21391 var i, 21392 cur, 21393 tmp, 21394 bubbleType, 21395 ontype, 21396 handle, 21397 special, 21398 lastElement, 21399 eventPath = [elem || document], 21400 type = hasOwn.call(event, "type") ? event.type : event, 21401 namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : []; 21402 cur = lastElement = tmp = elem = elem || document; // Don't do events on text and comment nodes 21403 21404 if (elem.nodeType === 3 || elem.nodeType === 8) { 21405 return; 21406 } // focus/blur morphs to focusin/out; ensure we're not firing them right now 21407 21408 21409 if (rfocusMorph.test(type + jQuery.event.triggered)) { 21410 return; 21411 } 21412 21413 if (type.indexOf(".") > -1) { 21414 // Namespaced trigger; create a regexp to match event type in handle() 21415 namespaces = type.split("."); 21416 type = namespaces.shift(); 21417 namespaces.sort(); 21418 } 21419 21420 ontype = type.indexOf(":") < 0 && "on" + type; // Caller can pass in a jQuery.Event object, Object, or just an event type string 21421 21422 event = event[jQuery.expando] ? event : new jQuery.Event(type, _typeof(event) === "object" && event); // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) 21423 21424 event.isTrigger = onlyHandlers ? 2 : 3; 21425 event.namespace = namespaces.join(".");
vendor: 4,099 bytes, lines 21426-21550
21426 event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; // Clean up the event in case it is being reused 21427 21428 event.result = undefined; 21429 21430 if (!event.target) { 21431 event.target = elem; 21432 } // Clone any incoming data and prepend the event, creating the handler arg list 21433 21434 21435 data = data == null ? [event] : jQuery.makeArray(data, [event]); // Allow special events to draw outside the lines 21436 21437 special = jQuery.event.special[type] || {}; 21438 21439 if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) { 21440 return; 21441 } // Determine event propagation path in advance, per W3C events spec (#9951) 21442 // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) 21443 21444 21445 if (!onlyHandlers && !special.noBubble && !isWindow(elem)) { 21446 bubbleType = special.delegateType || type; 21447 21448 if (!rfocusMorph.test(bubbleType + type)) { 21449 cur = cur.parentNode; 21450 } 21451 21452 for (; cur; cur = cur.parentNode) { 21453 eventPath.push(cur); 21454 tmp = cur; 21455 } // Only add window if we got to document (e.g., not plain obj or detached DOM) 21456 21457 21458 if (tmp === (elem.ownerDocument || document)) { 21459 eventPath.push(tmp.defaultView || tmp.parentWindow || window); 21460 } 21461 } // Fire handlers on the event path 21462 21463 21464 i = 0; 21465 21466 while ((cur = eventPath[i++]) && !event.isPropagationStopped()) { 21467 lastElement = cur; 21468 event.type = i > 1 ? bubbleType : special.bindType || type; // jQuery handler 21469 21470 handle = (dataPriv.get(cur, "events") || Object.create(null))[event.type] && dataPriv.get(cur, "handle"); 21471 21472 if (handle) { 21473 handle.apply(cur, data); 21474 } // Native handler 21475 21476 21477 handle = ontype && cur[ontype]; 21478 21479 if (handle && handle.apply && acceptData(cur)) { 21480 event.result = handle.apply(cur, data); 21481 21482 if (event.result === false) { 21483 event.preventDefault(); 21484 } 21485 } 21486 } 21487 21488 event.type = type; // If nobody prevented the default action, do it now 21489 21490 if (!onlyHandlers && !event.isDefaultPrevented()) { 21491 if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) { 21492 // Call a native DOM method on the target with the same name as the event. 21493 // Don't do default actions on window, that's where global variables be (#6170) 21494 if (ontype && isFunction(elem[type]) && !isWindow(elem)) { 21495 // Don't re-trigger an onFOO event when we call its FOO() method 21496 tmp = elem[ontype]; 21497 21498 if (tmp) { 21499 elem[ontype] = null; 21500 } // Prevent re-triggering of the same event, since we already bubbled it above 21501 21502 21503 jQuery.event.triggered = type; 21504 21505 if (event.isPropagationStopped()) { 21506 lastElement.addEventListener(type, stopPropagationCallback); 21507 } 21508 21509 elem[type](); 21510 21511 if (event.isPropagationStopped()) { 21512 lastElement.removeEventListener(type, stopPropagationCallback); 21513 } 21514 21515 jQuery.event.triggered = undefined; 21516 21517 if (tmp) { 21518 elem[ontype] = tmp; 21519 } 21520 } 21521 } 21522 } 21523 21524 return event.result; 21525 }, 21526 // Piggyback on a donor event to simulate a different one 21527 // Used only for `focus(in | out)` events 21528 simulate: function simulate(type, elem, event) { 21529 var e = jQuery.extend(new jQuery.Event(), event, { 21530 type: type, 21531 isSimulated: true 21532 }); 21533 jQuery.event.trigger(e, null, elem); 21534 } 21535 }); 21536 jQuery.fn.extend({ 21537 trigger: function trigger(type, data) { 21538 return this.each(function () { 21539 jQuery.event.trigger(type, data, this); 21540 }); 21541 }, 21542 triggerHandler: function triggerHandler(type, data) { 21543 var elem = this[0]; 21544 21545 if (elem) { 21546 return jQuery.event.trigger(type, data, elem, true); 21547 } 21548 } 21549 }); // Support: Firefox <=44 21550 // Firefox doesn't have focus(in | out) events
21551 // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 21552 // 21553 // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 21554 // focus(in | out) events fire after focus & blur events, 21555 // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order 21556 // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 21557 21558 if (!support.focusin) { 21559 jQuery.each({ 21560 focus: "focusin", 21561 blur: "focusout" 21562 }, function (orig, fix) { 21563 // Attach a single capturing handler on the document while someone wants focusin/focusout 21564 var handler = function handler(event) { 21565 jQuery.event.simulate(fix, event.target, jQuery.event.fix(event)); 21566 }; 21567 21568 jQuery.event.special[fix] = { 21569 setup: function setup() { 21570 // Handle: regular nodes (via `this.ownerDocument`), window 21571 // (via `this.document`) & document (via `this`). 21572 var doc = this.ownerDocument || this.document || this, 21573 attaches = dataPriv.access(doc, fix); 21574 21575 if (!attaches) { 21576 doc.addEventListener(orig, handler, true); 21577 } 21578 21579 dataPriv.access(doc, fix, (attaches || 0) + 1); 21580 }, 21581 teardown: function teardown() { 21582 var doc = this.ownerDocument || this.document || this, 21583 attaches = dataPriv.access(doc, fix) - 1; 21584 21585 if (!attaches) { 21586 doc.removeEventListener(orig, handler, true); 21587 dataPriv.remove(doc, fix); 21588 } else {
21589 dataPriv.access(doc, fix, attaches); 21590 } 21591 } 21592 }; 21593 }); 21594 } 21595 21596 var location = window.location; 21597 var nonce = { 21598 guid: Date.now() 21599 }; 21600 var rquery = /\?/; // Cross-browser xml parsing 21601 21602 jQuery.parseXML = function (data) { 21603 var xml; 21604 21605 if (!data || typeof data !== "string") { 21606 return null; 21607 } // Support: IE 9 - 11 only 21608 // IE throws on parseFromString with invalid input. 21609 21610 21611 try { 21612 xml = new window.DOMParser().parseFromString(data, "text/xml"); 21613 } catch (e) { 21614 xml = undefined; 21615 } 21616 21617 if (!xml || xml.getElementsByTagName("parsererror").length) { 21618 jQuery.error("Invalid XML: " + data); 21619 } 21620 21621 return xml; 21622 }; 21623 21624 var rbracket = /\[\]$/, 21625 rCRLF = /\r?\n/g, 21626 rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, 21627 rsubmittable = /^(?:input|select|textarea|keygen)/i; 21628 21629 function buildParams(prefix, obj, traditional, add) { 21630 var name; 21631 21632 if (Array.isArray(obj)) { 21633 // Serialize array item. 21634 jQuery.each(obj, function (i, v) { 21635 if (traditional || rbracket.test(prefix)) { 21636 // Treat each array item as a scalar. 21637 add(prefix, v); 21638 } else { 21639 // Item is non-scalar (array or object), encode its numeric index. 21640 buildParams(prefix + "[" + (_typeof(v) === "object" && v != null ? i : "") + "]", v, traditional, add); 21641 } 21642 }); 21643 } else if (!traditional && toType(obj) === "object") { 21644 // Serialize object item. 21645 for (name in obj) { 21646 buildParams(prefix + "[" + name + "]", obj[name], traditional, add); 21647 } 21648 } else { 21649 // Serialize scalar item. 21650 add(prefix, obj); 21651 } 21652 } // Serialize an array of form elements or a set of 21653 // key/values into a query string 21654 21655 21656 jQuery.param = function (a, traditional) { 21657 var prefix, 21658 s = [], 21659 add = function add(key, valueOrFunction) { 21660 // If value is a function, invoke it and use its return value 21661 var value = isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction; 21662 s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value == null ? "" : value); 21663 }; 21664 21665 if (a == null) { 21666 return ""; 21667 } // If an array was passed in, assume that it is an array of form elements. 21668 21669 21670 if (Array.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) { 21671 // Serialize the form elements 21672 jQuery.each(a, function () { 21673 add(this.name, this.value); 21674 }); 21675 } else { 21676 // If traditional, encode the "old" way (the way 1.3.2 or older 21677 // did it), otherwise encode params recursively. 21678 for (prefix in a) { 21679 buildParams(prefix, a[prefix], traditional, add); 21680 } 21681 } // Return the resulting serialization 21682 21683 21684 return s.join("&"); 21685 }; 21686 21687 jQuery.fn.extend({ 21688 serialize: function serialize() { 21689 return jQuery.param(this.serializeArray()); 21690 }, 21691 serializeArray: function serializeArray() { 21692 return this.map(function () { 21693 // Can add propHook for "elements" to filter or add form elements 21694 var elements = jQuery.prop(this, "elements"); 21695 return elements ? jQuery.makeArray(elements) : this; 21696 }).filter(function () { 21697 var type = this.type; // Use .is( ":disabled" ) so that fieldset[disabled] works 21698 21699 return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type)); 21700 }).map(function (_i, elem) { 21701 var val = jQuery(this).val(); 21702 21703 if (val == null) { 21704 return null; 21705 } 21706 21707 if (Array.isArray(val)) { 21708 return jQuery.map(val, function (val) { 21709 return { 21710 name: elem.name, 21711 value: val.replace(rCRLF, "\r\n") 21712 }; 21713 }); 21714 } 21715 21716 return { 21717 name: elem.name, 21718 value: val.replace(rCRLF, "\r\n") 21719 }; 21720 }).get(); 21721 } 21722 }); 21723 var r20 = /%20/g, 21724 rhash = /#.*$/, 21725 rantiCache = /([?&])_=[^&]*/, 21726 rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, 21727 // #7653, #8125, #8152: local protocol detection 21728 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, 21729 rnoContent = /^(?:GET|HEAD)$/, 21730 rprotocol = /^\/\//, 21731 21732 /* Prefilters 21733 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) 21734 * 2) These are called: 21735 * - BEFORE asking for a transport
21736 * - AFTER param serialization (s.data is a string if s.processData is true) 21737 * 3) key is the dataType 21738 * 4) the catchall symbol "*" can be used 21739 * 5) execution will start with transport dataType and THEN continue down to "*" if needed 21740 */ 21741 prefilters = {}, 21742 21743 /* Transports bindings 21744 * 1) key is the dataType 21745 * 2) the catchall symbol "*" can be used 21746 * 3) selection will start with transport dataType and THEN go to "*" if needed 21747 */ 21748 transports = {}, 21749 // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression 21750 allTypes = "*/".concat("*"), 21751 // Anchor tag for parsing the document origin 21752 originAnchor = document.createElement("a"); 21753 originAnchor.href = location.href; // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport 21754 21755 function addToPrefiltersOrTransports(structure) { 21756 // dataTypeExpression is optional and defaults to "*" 21757 return function (dataTypeExpression, func) { 21758 if (typeof dataTypeExpression !== "string") { 21759 func = dataTypeExpression; 21760 dataTypeExpression = "*"; 21761 } 21762 21763 var dataType, 21764 i = 0, 21765 dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || []; 21766 21767 if (isFunction(func)) { 21768 // For each dataType in the dataTypeExpression 21769 while (dataType = dataTypes[i++]) { 21770 // Prepend if requested 21771 if (dataType[0] === "+") { 21772 dataType = dataType.slice(1) || "*"; 21773 (structure[dataType] = structure[dataType] || []).unshift(func); // Otherwise append 21774 } else { 21775 (structure[dataType] = structure[dataType] || []).push(func); 21776 } 21777 } 21778 } 21779 }; 21780 } // Base inspection function for prefilters and transports 21781 21782 21783 function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) { 21784 var inspected = {}, 21785 seekingTransport = structure === transports; 21786 21787 function inspect(dataType) { 21788 var selected; 21789 inspected[dataType] = true; 21790 jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) { 21791 var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR); 21792 21793 if (typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[dataTypeOrTransport]) { 21794 options.dataTypes.unshift(dataTypeOrTransport); 21795 inspect(dataTypeOrTransport); 21796 return false; 21797 } else if (seekingTransport) { 21798 return !(selected = dataTypeOrTransport); 21799 } 21800 }); 21801 return selected; 21802 } 21803 21804 return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*"); 21805 } // A special extend for ajax options 21806 // that takes "flat" options (not to be deep extended) 21807 // Fixes #9887 21808 21809 21810 function ajaxExtend(target, src) { 21811 var key, 21812 deep, 21813 flatOptions = jQuery.ajaxSettings.flatOptions || {}; 21814 21815 for (key in src) { 21816 if (src[key] !== undefined) { 21817 (flatOptions[key] ? target : deep || (deep = {}))[key] = src[key]; 21818 } 21819 } 21820 21821 if (deep) { 21822 jQuery.extend(true, target, deep); 21823 } 21824 21825 return target; 21826 } 21827 /* Handles responses to an ajax request: 21828 * - finds the right dataType (mediates between content-type and expected dataType) 21829 * - returns the corresponding response 21830 */ 21831 21832 21833 function ajaxHandleResponses(s, jqXHR, responses) { 21834 var ct, 21835 type, 21836 finalDataType, 21837 firstDataType, 21838 contents = s.contents, 21839 dataTypes = s.dataTypes; // Remove auto dataType and get content-type in the process 21840 21841 while (dataTypes[0] === "*") { 21842 dataTypes.shift(); 21843 21844 if (ct === undefined) { 21845 ct = s.mimeType || jqXHR.getResponseHeader("Content-Type"); 21846 } 21847 } // Check if we're dealing with a known content-type 21848 21849 21850 if (ct) { 21851 for (type in contents) { 21852 if (contents[type] && contents[type].test(ct)) { 21853 dataTypes.unshift(type); 21854 break; 21855 } 21856 } 21857 } // Check to see if we have a response for the expected dataType 21858 21859 21860 if (dataTypes[0] in responses) { 21861 finalDataType = dataTypes[0]; 21862 } else {
vendor: 4,080 bytes, lines 21863-22005
21863 // Try convertible dataTypes 21864 for (type in responses) { 21865 if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) { 21866 finalDataType = type; 21867 break; 21868 } 21869 21870 if (!firstDataType) { 21871 firstDataType = type; 21872 } 21873 } // Or just use first one 21874 21875 21876 finalDataType = finalDataType || firstDataType; 21877 } // If we found a dataType 21878 // We add the dataType to the list if needed 21879 // and return the corresponding response 21880 21881 21882 if (finalDataType) { 21883 if (finalDataType !== dataTypes[0]) { 21884 dataTypes.unshift(finalDataType); 21885 } 21886 21887 return responses[finalDataType]; 21888 } 21889 } 21890 /* Chain conversions given the request and the original response 21891 * Also sets the responseXXX fields on the jqXHR instance 21892 */ 21893 21894 21895 function ajaxConvert(s, response, jqXHR, isSuccess) { 21896 var conv2, 21897 current, 21898 conv, 21899 tmp, 21900 prev, 21901 converters = {}, 21902 // Work with a copy of dataTypes in case we need to modify it for conversion 21903 dataTypes = s.dataTypes.slice(); // Create converters map with lowercased keys 21904 21905 if (dataTypes[1]) { 21906 for (conv in s.converters) { 21907 converters[conv.toLowerCase()] = s.converters[conv]; 21908 } 21909 } 21910 21911 current = dataTypes.shift(); // Convert to each sequential dataType 21912 21913 while (current) { 21914 if (s.responseFields[current]) { 21915 jqXHR[s.responseFields[current]] = response; 21916 } // Apply the dataFilter if provided 21917 21918 21919 if (!prev && isSuccess && s.dataFilter) { 21920 response = s.dataFilter(response, s.dataType); 21921 } 21922 21923 prev = current; 21924 current = dataTypes.shift(); 21925 21926 if (current) { 21927 // There's only work to do if current dataType is non-auto 21928 if (current === "*") { 21929 current = prev; // Convert response if prev dataType is non-auto and differs from current 21930 } else if (prev !== "*" && prev !== current) { 21931 // Seek a direct converter 21932 conv = converters[prev + " " + current] || converters["* " + current]; // If none found, seek a pair 21933 21934 if (!conv) { 21935 for (conv2 in converters) { 21936 // If conv2 outputs current 21937 tmp = conv2.split(" "); 21938 21939 if (tmp[1] === current) { 21940 // If prev can be converted to accepted input 21941 conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]]; 21942 21943 if (conv) { 21944 // Condense equivalence converters 21945 if (conv === true) { 21946 conv = converters[conv2]; // Otherwise, insert the intermediate dataType 21947 } else if (converters[conv2] !== true) { 21948 current = tmp[0]; 21949 dataTypes.unshift(tmp[1]); 21950 } 21951 21952 break; 21953 } 21954 } 21955 } 21956 } // Apply converter (if not an equivalence) 21957 21958 21959 if (conv !== true) { 21960 // Unless errors are allowed to bubble, catch and return them 21961 if (conv && s["throws"]) { 21962 response = conv(response); 21963 } else { 21964 try { 21965 response = conv(response); 21966 } catch (e) { 21967 return { 21968 state: "parsererror", 21969 error: conv ? e : "No conversion from " + prev + " to " + current 21970 }; 21971 } 21972 } 21973 } 21974 } 21975 } 21976 } 21977 21978 return { 21979 state: "success", 21980 data: response 21981 }; 21982 } 21983 21984 jQuery.extend({ 21985 // Counter for holding the number of active queries 21986 active: 0, 21987 // Last-Modified header cache for next request 21988 lastModified: {}, 21989 etag: {}, 21990 ajaxSettings: { 21991 url: location.href, 21992 type: "GET", 21993 isLocal: rlocalProtocol.test(location.protocol), 21994 global: true, 21995 processData: true, 21996 async: true, 21997 contentType: "application/x-www-form-urlencoded; charset=UTF-8", 21998 21999 /* 22000 timeout: 0, 22001 data: null, 22002 dataType: null, 22003 username: null, 22004 password: null, 22005 cache: null,
vendor: 6,254 bytes, lines 22006-22188
22006 throws: false, 22007 traditional: false, 22008 headers: {}, 22009 */ 22010 accepts: { 22011 "*": allTypes, 22012 text: "text/plain", 22013 html: "text/html", 22014 xml: "application/xml, text/xml", 22015 json: "application/json, text/javascript" 22016 }, 22017 contents: { 22018 xml: /\bxml\b/, 22019 html: /\bhtml/, 22020 json: /\bjson\b/ 22021 }, 22022 responseFields: { 22023 xml: "responseXML", 22024 text: "responseText", 22025 json: "responseJSON" 22026 }, 22027 // Data converters 22028 // Keys separate source (or catchall "*") and destination types with a single space 22029 converters: { 22030 // Convert anything to text 22031 "* text": String, 22032 // Text to html (true = no transformation) 22033 "text html": true, 22034 // Evaluate text as a json expression 22035 "text json": JSON.parse, 22036 // Parse text as xml 22037 "text xml": jQuery.parseXML 22038 }, 22039 // For options that shouldn't be deep extended: 22040 // you can add your own custom options here if 22041 // and when you create one that shouldn't be 22042 // deep extended (see ajaxExtend) 22043 flatOptions: { 22044 url: true, 22045 context: true 22046 } 22047 }, 22048 // Creates a full fledged settings object into target 22049 // with both ajaxSettings and settings fields. 22050 // If target is omitted, writes into ajaxSettings. 22051 ajaxSetup: function ajaxSetup(target, settings) { 22052 return settings ? // Building a settings object 22053 ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : // Extending ajaxSettings 22054 ajaxExtend(jQuery.ajaxSettings, target); 22055 }, 22056 ajaxPrefilter: addToPrefiltersOrTransports(prefilters), 22057 ajaxTransport: addToPrefiltersOrTransports(transports), 22058 // Main method 22059 ajax: function ajax(url, options) { 22060 // If url is an object, simulate pre-1.5 signature 22061 if (_typeof(url) === "object") { 22062 options = url; 22063 url = undefined; 22064 } // Force options to be an object 22065 22066 22067 options = options || {}; 22068 22069 var transport, 22070 // URL without anti-cache param 22071 cacheURL, 22072 // Response headers 22073 responseHeadersString, 22074 responseHeaders, 22075 // timeout handle 22076 timeoutTimer, 22077 // Url cleanup var 22078 urlAnchor, 22079 // Request state (becomes false upon send and true upon completion) 22080 completed, 22081 // To know if global events are to be dispatched 22082 fireGlobals, 22083 // Loop variable 22084 i, 22085 // uncached part of the url 22086 uncached, 22087 // Create the final options object 22088 s = jQuery.ajaxSetup({}, options), 22089 // Callbacks context 22090 callbackContext = s.context || s, 22091 // Context for global events is callbackContext if it is a DOM node or jQuery collection 22092 globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event, 22093 // Deferreds 22094 deferred = jQuery.Deferred(), 22095 completeDeferred = jQuery.Callbacks("once memory"), 22096 // Status-dependent callbacks 22097 _statusCode = s.statusCode || {}, 22098 // Headers (they are sent all at once) 22099 requestHeaders = {}, 22100 requestHeadersNames = {}, 22101 // Default abort message 22102 strAbort = "canceled", 22103 // Fake xhr 22104 jqXHR = { 22105 readyState: 0, 22106 // Builds headers hashtable if needed 22107 getResponseHeader: function getResponseHeader(key) { 22108 var match; 22109 22110 if (completed) { 22111 if (!responseHeaders) { 22112 responseHeaders = {}; 22113 22114 while (match = rheaders.exec(responseHeadersString)) { 22115 responseHeaders[match[1].toLowerCase() + " "] = (responseHeaders[match[1].toLowerCase() + " "] || []).concat(match[2]); 22116 } 22117 } 22118 22119 match = responseHeaders[key.toLowerCase() + " "]; 22120 } 22121 22122 return match == null ? null : match.join(", "); 22123 }, 22124 // Raw string 22125 getAllResponseHeaders: function getAllResponseHeaders() { 22126 return completed ? responseHeadersString : null; 22127 }, 22128 // Caches the header 22129 setRequestHeader: function setRequestHeader(name, value) { 22130 if (completed == null) { 22131 name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name; 22132 requestHeaders[name] = value; 22133 } 22134 22135 return this; 22136 }, 22137 // Overrides response content-type header 22138 overrideMimeType: function overrideMimeType(type) { 22139 if (completed == null) { 22140 s.mimeType = type; 22141 } 22142 22143 return this; 22144 }, 22145 // Status-dependent callbacks 22146 statusCode: function statusCode(map) { 22147 var code; 22148 22149 if (map) { 22150 if (completed) { 22151 // Execute the appropriate callbacks 22152 jqXHR.always(map[jqXHR.status]); 22153 } else { 22154 // Lazy-add the new callbacks in a way that preserves old ones 22155 for (code in map) { 22156 _statusCode[code] = [_statusCode[code], map[code]]; 22157 } 22158 } 22159 } 22160 22161 return this; 22162 }, 22163 // Cancel the request 22164 abort: function abort(statusText) { 22165 var finalText = statusText || strAbort; 22166 22167 if (transport) { 22168 transport.abort(finalText); 22169 } 22170 22171 done(0, finalText); 22172 return this; 22173 } 22174 }; // Attach deferreds 22175 22176 22177 deferred.promise(jqXHR); // Add protocol if not provided (prefilters might expect it) 22178 // Handle falsy url in the settings object (#10093: consistency with old signature) 22179 // We also use the url parameter if available 22180 22181 s.url = ((url || s.url || location.href) + "").replace(rprotocol, location.protocol + "//"); // Alias method option to type as per ticket #12004 22182 22183 s.type = options.method || options.type || s.method || s.type; // Extract dataTypes list 22184 22185 s.dataTypes = (s.dataType || "*").toLowerCase().match(rnothtmlwhite) || [""]; // A cross-domain request is in order when the origin doesn't match the current origin. 22186 22187 if (s.crossDomain == null) { 22188 urlAnchor = document.createElement("a");
vendor: 4,926 bytes, lines 22188-22316
22188 // Support: IE <=8 - 11, Edge 12 - 15 22189 // IE throws exception on accessing the href property if url is malformed, 22190 // e.g. http://example.com:80x/ 22191 22192 try { 22193 urlAnchor.href = s.url; // Support: IE <=8 - 11 only 22194 // Anchor's host property isn't correctly set when s.url is relative 22195 22196 urlAnchor.href = urlAnchor.href; 22197 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host; 22198 } catch (e) { 22199 // If there is an error parsing the URL, assume it is crossDomain, 22200 // it can be rejected by the transport if it is invalid 22201 s.crossDomain = true; 22202 } 22203 } // Convert data if not already a string 22204 22205 22206 if (s.data && s.processData && typeof s.data !== "string") { 22207 s.data = jQuery.param(s.data, s.traditional); 22208 } // Apply prefilters 22209 22210 22211 inspectPrefiltersOrTransports(prefilters, s, options, jqXHR); // If request was aborted inside a prefilter, stop there 22212 22213 if (completed) { 22214 return jqXHR; 22215 } // We can fire global events as of now if asked to 22216 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) 22217 22218 22219 fireGlobals = jQuery.event && s.global; // Watch for a new set of requests 22220 22221 if (fireGlobals && jQuery.active++ === 0) { 22222 jQuery.event.trigger("ajaxStart"); 22223 } // Uppercase the type 22224 22225 22226 s.type = s.type.toUpperCase(); // Determine if request has content 22227 22228 s.hasContent = !rnoContent.test(s.type); // Save the URL in case we're toying with the If-Modified-Since 22229 // and/or If-None-Match header later on 22230 // Remove hash to simplify url manipulation 22231 22232 cacheURL = s.url.replace(rhash, ""); // More options handling for requests with no content 22233 22234 if (!s.hasContent) { 22235 // Remember the hash so we can put it back 22236 uncached = s.url.slice(cacheURL.length); // If data is available and should be processed, append data to url 22237 22238 if (s.data && (s.processData || typeof s.data === "string")) { 22239 cacheURL += (rquery.test(cacheURL) ? "&" : "?") + s.data; // #9682: remove data so that it's not used in an eventual retry 22240 22241 delete s.data; 22242 } // Add or update anti-cache param if needed 22243 22244 22245 if (s.cache === false) { 22246 cacheURL = cacheURL.replace(rantiCache, "$1"); 22247 uncached = (rquery.test(cacheURL) ? "&" : "?") + "_=" + nonce.guid++ + uncached; 22248 } // Put hash and anti-cache on the URL that will be requested (gh-1732) 22249 22250 22251 s.url = cacheURL + uncached; // Change '%20' to '+' if this is encoded form body content (gh-2658) 22252 } else if (s.data && s.processData && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0) { 22253 s.data = s.data.replace(r20, "+"); 22254 } // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 22255 22256 22257 if (s.ifModified) { 22258 if (jQuery.lastModified[cacheURL]) { 22259 jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]); 22260 } 22261 22262 if (jQuery.etag[cacheURL]) { 22263 jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]); 22264 } 22265 } // Set the correct header, if data is being sent 22266 22267 22268 if (s.data && s.hasContent && s.contentType !== false || options.contentType) { 22269 jqXHR.setRequestHeader("Content-Type", s.contentType); 22270 } // Set the Accepts header for the server, depending on the dataType 22271 22272 22273 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["*"]); // Check for headers option 22274 22275 for (i in s.headers) { 22276 jqXHR.setRequestHeader(i, s.headers[i]); 22277 } // Allow custom headers/mimetypes and early abort 22278 22279 22280 if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || completed)) { 22281 // Abort if not done already and return 22282 return jqXHR.abort(); 22283 } // Aborting is no longer a cancellation 22284 22285 22286 strAbort = "abort"; // Install callbacks on deferreds 22287 22288 completeDeferred.add(s.complete); 22289 jqXHR.done(s.success); 22290 jqXHR.fail(s.error); // Get transport 22291 22292 transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR); // If no transport, we auto-abort 22293 22294 if (!transport) { 22295 done(-1, "No Transport"); 22296 } else { 22297 jqXHR.readyState = 1; // Send global event 22298 22299 if (fireGlobals) { 22300 globalEventContext.trigger("ajaxSend", [jqXHR, s]); 22301 } // If request was aborted inside ajaxSend, stop there 22302 22303 22304 if (completed) { 22305 return jqXHR; 22306 } // Timeout 22307 22308 22309 if (s.async && s.timeout > 0) { 22310 timeoutTimer = window.setTimeout(function () { 22311 jqXHR.abort("timeout"); 22312 }, s.timeout); 22313 } 22314 22315 try { 22316 completed = false;
vendor: 7,346 bytes, lines 22317-22576
22317 transport.send(requestHeaders, done); 22318 } catch (e) { 22319 // Rethrow post-completion exceptions 22320 if (completed) { 22321 throw e; 22322 } // Propagate others as results 22323 22324 22325 done(-1, e); 22326 } 22327 } // Callback for when everything is done 22328 22329 22330 function done(status, nativeStatusText, responses, headers) { 22331 var isSuccess, 22332 success, 22333 error, 22334 response, 22335 modified, 22336 statusText = nativeStatusText; // Ignore repeat invocations 22337 22338 if (completed) { 22339 return; 22340 } 22341 22342 completed = true; // Clear timeout if it exists 22343 22344 if (timeoutTimer) { 22345 window.clearTimeout(timeoutTimer); 22346 } // Dereference transport for early garbage collection 22347 // (no matter how long the jqXHR object will be used) 22348 22349 22350 transport = undefined; // Cache response headers 22351 22352 responseHeadersString = headers || ""; // Set readyState 22353 22354 jqXHR.readyState = status > 0 ? 4 : 0; // Determine if successful 22355 22356 isSuccess = status >= 200 && status < 300 || status === 304; // Get response data 22357 22358 if (responses) { 22359 response = ajaxHandleResponses(s, jqXHR, responses); 22360 } // Use a noop converter for missing script 22361 22362 22363 if (!isSuccess && jQuery.inArray("script", s.dataTypes) > -1) { 22364 s.converters["text script"] = function () {}; 22365 } // Convert no matter what (that way responseXXX fields are always set) 22366 22367 22368 response = ajaxConvert(s, response, jqXHR, isSuccess); // If successful, handle type chaining 22369 22370 if (isSuccess) { 22371 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 22372 if (s.ifModified) { 22373 modified = jqXHR.getResponseHeader("Last-Modified"); 22374 22375 if (modified) { 22376 jQuery.lastModified[cacheURL] = modified; 22377 } 22378 22379 modified = jqXHR.getResponseHeader("etag"); 22380 22381 if (modified) { 22382 jQuery.etag[cacheURL] = modified; 22383 } 22384 } // if no content 22385 22386 22387 if (status === 204 || s.type === "HEAD") { 22388 statusText = "nocontent"; // if not modified 22389 } else if (status === 304) { 22390 statusText = "notmodified"; // If we have data, let's convert it 22391 } else { 22392 statusText = response.state; 22393 success = response.data; 22394 error = response.error; 22395 isSuccess = !error; 22396 } 22397 } else { 22398 // Extract error from statusText and normalize for non-aborts 22399 error = statusText; 22400 22401 if (status || !statusText) { 22402 statusText = "error"; 22403 22404 if (status < 0) { 22405 status = 0; 22406 } 22407 } 22408 } // Set data for the fake xhr object 22409 22410 22411 jqXHR.status = status; 22412 jqXHR.statusText = (nativeStatusText || statusText) + ""; // Success/Error 22413 22414 if (isSuccess) { 22415 deferred.resolveWith(callbackContext, [success, statusText, jqXHR]); 22416 } else { 22417 deferred.rejectWith(callbackContext, [jqXHR, statusText, error]); 22418 } // Status-dependent callbacks 22419 22420 22421 jqXHR.statusCode(_statusCode); 22422 _statusCode = undefined; 22423 22424 if (fireGlobals) { 22425 globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? success : error]); 22426 } // Complete 22427 22428 22429 completeDeferred.fireWith(callbackContext, [jqXHR, statusText]); 22430 22431 if (fireGlobals) { 22432 globalEventContext.trigger("ajaxComplete", [jqXHR, s]); // Handle the global AJAX counter 22433 22434 if (! --jQuery.active) { 22435 jQuery.event.trigger("ajaxStop"); 22436 } 22437 } 22438 } 22439 22440 return jqXHR; 22441 }, 22442 getJSON: function getJSON(url, data, callback) { 22443 return jQuery.get(url, data, callback, "json"); 22444 }, 22445 getScript: function getScript(url, callback) { 22446 return jQuery.get(url, undefined, callback, "script"); 22447 } 22448 }); 22449 jQuery.each(["get", "post"], function (_i, method) { 22450 jQuery[method] = function (url, data, callback, type) { 22451 // Shift arguments if data argument was omitted 22452 if (isFunction(data)) { 22453 type = type || callback; 22454 callback = data; 22455 data = undefined; 22456 } // The url can be an options object (which then must have .url) 22457 22458 22459 return jQuery.ajax(jQuery.extend({ 22460 url: url, 22461 type: method, 22462 dataType: type, 22463 data: data, 22464 success: callback 22465 }, jQuery.isPlainObject(url) && url)); 22466 }; 22467 }); 22468 jQuery.ajaxPrefilter(function (s) { 22469 var i; 22470 22471 for (i in s.headers) { 22472 if (i.toLowerCase() === "content-type") { 22473 s.contentType = s.headers[i] || ""; 22474 } 22475 } 22476 }); 22477 22478 jQuery._evalUrl = function (url, options, doc) { 22479 return jQuery.ajax({ 22480 url: url, 22481 // Make this explicit, since user can override this through ajaxSetup (#11264) 22482 type: "GET", 22483 dataType: "script", 22484 cache: true, 22485 async: false, 22486 global: false, 22487 // Only evaluate the response if it is successful (gh-4126) 22488 // dataFilter is not invoked for failure responses, so using it instead 22489 // of the default converter is kludgy but it works. 22490 converters: { 22491 "text script": function textScript() {} 22492 }, 22493 dataFilter: function dataFilter(response) { 22494 jQuery.globalEval(response, options, doc); 22495 } 22496 }); 22497 }; 22498 22499 jQuery.fn.extend({ 22500 wrapAll: function wrapAll(html) { 22501 var wrap; 22502 22503 if (this[0]) { 22504 if (isFunction(html)) { 22505 html = html.call(this[0]); 22506 } // The elements to wrap the target around 22507 22508 22509 wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true); 22510 22511 if (this[0].parentNode) { 22512 wrap.insertBefore(this[0]); 22513 } 22514 22515 wrap.map(function () { 22516 var elem = this; 22517 22518 while (elem.firstElementChild) { 22519 elem = elem.firstElementChild; 22520 } 22521 22522 return elem; 22523 }).append(this); 22524 } 22525 22526 return this; 22527 }, 22528 wrapInner: function wrapInner(html) { 22529 if (isFunction(html)) { 22530 return this.each(function (i) { 22531 jQuery(this).wrapInner(html.call(this, i)); 22532 }); 22533 } 22534 22535 return this.each(function () { 22536 var self = jQuery(this), 22537 contents = self.contents(); 22538 22539 if (contents.length) { 22540 contents.wrapAll(html); 22541 } else { 22542 self.append(html); 22543 } 22544 }); 22545 }, 22546 wrap: function wrap(html) { 22547 var htmlIsFunction = isFunction(html); 22548 return this.each(function (i) { 22549 jQuery(this).wrapAll(htmlIsFunction ? html.call(this, i) : html); 22550 }); 22551 }, 22552 unwrap: function unwrap(selector) { 22553 this.parent(selector).not("body").each(function () { 22554 jQuery(this).replaceWith(this.childNodes); 22555 }); 22556 return this; 22557 } 22558 }); 22559 22560 jQuery.expr.pseudos.hidden = function (elem) { 22561 return !jQuery.expr.pseudos.visible(elem); 22562 }; 22563 22564 jQuery.expr.pseudos.visible = function (elem) { 22565 return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length); 22566 }; 22567 22568 jQuery.ajaxSettings.xhr = function () { 22569 try { 22570 return new window.XMLHttpRequest(); 22571 } catch (e) {} 22572 }; 22573 22574 var xhrSuccessStatus = { 22575 // File protocol always yields status code 0, assume 200 22576 0: 200,
22577 // Support: IE <=9 only 22578 // #1450: sometimes IE returns 1223 when it should be 204 22579 1223: 204 22580 }, 22581 xhrSupported = jQuery.ajaxSettings.xhr(); 22582 support.cors = !!xhrSupported && "withCredentials" in xhrSupported; 22583 support.ajax = xhrSupported = !!xhrSupported; 22584 jQuery.ajaxTransport(function (options) { 22585 var _callback, errorCallback; // Cross domain only allowed if supported through XMLHttpRequest 22586 22587 22588 if (support.cors || xhrSupported && !options.crossDomain) { 22589 return { 22590 send: function send(headers, complete) { 22591 var i, 22592 xhr = options.xhr(); 22593 xhr.open(options.type, options.url, options.async, options.username, options.password); // Apply custom fields if provided 22594 22595 if (options.xhrFields) { 22596 for (i in options.xhrFields) { 22597 xhr[i] = options.xhrFields[i]; 22598 } 22599 } // Override mime type if needed 22600 22601 22602 if (options.mimeType && xhr.overrideMimeType) { 22603 xhr.overrideMimeType(options.mimeType); 22604 } // X-Requested-With header 22605 // For cross-domain requests, seeing as conditions for a preflight are 22606 // akin to a jigsaw puzzle, we simply never set it to be sure. 22607 // (it can always be set on a per-request basis or even using ajaxSetup)
vendor: 5,814 bytes, lines 22608-22776
22608 // For same-domain requests, won't change header if already provided. 22609 22610 22611 if (!options.crossDomain && !headers["X-Requested-With"]) { 22612 headers["X-Requested-With"] = "XMLHttpRequest"; 22613 } // Set headers 22614 22615 22616 for (i in headers) { 22617 xhr.setRequestHeader(i, headers[i]); 22618 } // Callback 22619 22620 22621 _callback = function callback(type) { 22622 return function () { 22623 if (_callback) { 22624 _callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null; 22625 22626 if (type === "abort") { 22627 xhr.abort(); 22628 } else if (type === "error") { 22629 // Support: IE <=9 only 22630 // On a manual native abort, IE9 throws 22631 // errors on any property access that is not readyState 22632 if (typeof xhr.status !== "number") { 22633 complete(0, "error"); 22634 } else { 22635 complete( // File: protocol always yields status 0; see #8605, #14207 22636 xhr.status, xhr.statusText); 22637 } 22638 } else { 22639 complete(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText, // Support: IE <=9 only 22640 // IE9 has no XHR2 but throws on binary (trac-11426) 22641 // For XHR2 non-text, let the caller handle it (gh-2498) 22642 (xhr.responseType || "text") !== "text" || typeof xhr.responseText !== "string" ? { 22643 binary: xhr.response 22644 } : { 22645 text: xhr.responseText 22646 }, xhr.getAllResponseHeaders()); 22647 } 22648 } 22649 }; 22650 }; // Listen to events 22651 22652 22653 xhr.onload = _callback(); 22654 errorCallback = xhr.onerror = xhr.ontimeout = _callback("error"); // Support: IE 9 only 22655 // Use onreadystatechange to replace onabort 22656 // to handle uncaught aborts 22657 22658 if (xhr.onabort !== undefined) { 22659 xhr.onabort = errorCallback; 22660 } else { 22661 xhr.onreadystatechange = function () { 22662 // Check readyState before timeout as it changes 22663 if (xhr.readyState === 4) { 22664 // Allow onerror to be called first, 22665 // but that will not handle a native abort 22666 // Also, save errorCallback to a variable 22667 // as xhr.onerror cannot be accessed 22668 window.setTimeout(function () { 22669 if (_callback) { 22670 errorCallback(); 22671 } 22672 }); 22673 } 22674 }; 22675 } // Create the abort callback 22676 22677 22678 _callback = _callback("abort"); 22679 22680 try { 22681 // Do send the request (this may raise an exception) 22682 xhr.send(options.hasContent && options.data || null); 22683 } catch (e) { 22684 // #14683: Only rethrow if this hasn't been notified as an error yet 22685 if (_callback) { 22686 throw e; 22687 } 22688 } 22689 }, 22690 abort: function abort() { 22691 if (_callback) { 22692 _callback(); 22693 } 22694 } 22695 }; 22696 } 22697 }); // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) 22698 22699 jQuery.ajaxPrefilter(function (s) { 22700 if (s.crossDomain) { 22701 s.contents.script = false; 22702 } 22703 }); // Install script dataType 22704 22705 jQuery.ajaxSetup({ 22706 accepts: { 22707 script: "text/javascript, application/javascript, " + "application/ecmascript, application/x-ecmascript" 22708 }, 22709 contents: { 22710 script: /\b(?:java|ecma)script\b/ 22711 }, 22712 converters: { 22713 "text script": function textScript(text) { 22714 jQuery.globalEval(text); 22715 return text; 22716 } 22717 } 22718 }); // Handle cache's special case and crossDomain 22719 22720 jQuery.ajaxPrefilter("script", function (s) { 22721 if (s.cache === undefined) { 22722 s.cache = false; 22723 } 22724 22725 if (s.crossDomain) { 22726 s.type = "GET"; 22727 } 22728 }); // Bind script tag hack transport 22729 22730 jQuery.ajaxTransport("script", function (s) { 22731 // This transport only deals with cross domain or forced-by-attrs requests 22732 if (s.crossDomain || s.scriptAttrs) { 22733 var script, _callback2; 22734 22735 return { 22736 send: function send(_, complete) { 22737 script = jQuery("<script>").attr(s.scriptAttrs || {}).prop({ 22738 charset: s.scriptCharset, 22739 src: s.url 22740 }).on("load error", _callback2 = function callback(evt) { 22741 script.remove(); 22742 _callback2 = null; 22743 22744 if (evt) { 22745 complete(evt.type === "error" ? 404 : 200, evt.type); 22746 } 22747 }); // Use native DOM manipulation to avoid our domManip AJAX trickery 22748 22749 document.head.appendChild(script[0]); 22750 }, 22751 abort: function abort() { 22752 if (_callback2) { 22753 _callback2(); 22754 } 22755 } 22756 }; 22757 } 22758 }); 22759 var oldCallbacks = [], 22760 rjsonp = /(=)\?(?=&|$)|\?\?/; // Default jsonp settings 22761 22762 jQuery.ajaxSetup({ 22763 jsonp: "callback", 22764 jsonpCallback: function jsonpCallback() { 22765 var callback = oldCallbacks.pop() || jQuery.expando + "_" + nonce.guid++; 22766 this[callback] = true; 22767 return callback; 22768 } 22769 }); // Detect, normalize options and install callbacks for jsonp requests 22770 22771 jQuery.ajaxPrefilter("json jsonp", function (s, originalSettings, jqXHR) { 22772 var callbackName, 22773 overwritten, 22774 responseContainer, 22775 jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ? "url" : typeof s.data === "string" && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0 && rjsonp.test(s.data) && "data"); // Handle iff the expected data type is "jsonp" or we have a parameter to set 22776
vendor: 7,828 bytes, lines 22777-23016
22777 if (jsonProp || s.dataTypes[0] === "jsonp") { 22778 // Get callback name, remembering preexisting value associated with it 22779 callbackName = s.jsonpCallback = isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback; // Insert callback into url or form data 22780 22781 if (jsonProp) { 22782 s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName); 22783 } else if (s.jsonp !== false) { 22784 s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName; 22785 } // Use data converter to retrieve json after script execution 22786 22787 22788 s.converters["script json"] = function () { 22789 if (!responseContainer) { 22790 jQuery.error(callbackName + " was not called"); 22791 } 22792 22793 return responseContainer[0]; 22794 }; // Force json dataType 22795 22796 22797 s.dataTypes[0] = "json"; // Install callback 22798 22799 overwritten = window[callbackName]; 22800 22801 window[callbackName] = function () { 22802 responseContainer = arguments; 22803 }; // Clean-up function (fires after converters) 22804 22805 22806 jqXHR.always(function () { 22807 // If previous value didn't exist - remove it 22808 if (overwritten === undefined) { 22809 jQuery(window).removeProp(callbackName); // Otherwise restore preexisting value 22810 } else { 22811 window[callbackName] = overwritten; 22812 } // Save back as free 22813 22814 22815 if (s[callbackName]) { 22816 // Make sure that re-using the options doesn't screw things around 22817 s.jsonpCallback = originalSettings.jsonpCallback; // Save the callback name for future use 22818 22819 oldCallbacks.push(callbackName); 22820 } // Call if it was a function and we have a response 22821 22822 22823 if (responseContainer && isFunction(overwritten)) { 22824 overwritten(responseContainer[0]); 22825 } 22826 22827 responseContainer = overwritten = undefined; 22828 }); // Delegate to script 22829 22830 return "script"; 22831 } 22832 }); // Support: Safari 8 only 22833 // In Safari 8 documents created via document.implementation.createHTMLDocument 22834 // collapse sibling forms: the second one becomes a child of the first one. 22835 // Because of that, this security measure has to be disabled in Safari 8. 22836 // https://bugs.webkit.org/show_bug.cgi?id=137337 22837 22838 support.createHTMLDocument = function () { 22839 var body = document.implementation.createHTMLDocument("").body; 22840 body.innerHTML = "<form></form><form></form>"; 22841 return body.childNodes.length === 2; 22842 }(); // Argument "data" should be string of html 22843 // context (optional): If specified, the fragment will be created in this context, 22844 // defaults to document 22845 // keepScripts (optional): If true, will include scripts passed in the html string 22846 22847 22848 jQuery.parseHTML = function (data, context, keepScripts) { 22849 if (typeof data !== "string") { 22850 return []; 22851 } 22852 22853 if (typeof context === "boolean") { 22854 keepScripts = context; 22855 context = false; 22856 } 22857 22858 var base, parsed, scripts; 22859 22860 if (!context) { 22861 // Stop scripts or inline event handlers from being executed immediately 22862 // by using document.implementation 22863 if (support.createHTMLDocument) { 22864 context = document.implementation.createHTMLDocument(""); // Set the base href for the created document 22865 // so any parsed elements with URLs 22866 // are based on the document's URL (gh-2965) 22867 22868 base = context.createElement("base"); 22869 base.href = document.location.href; 22870 context.head.appendChild(base); 22871 } else { 22872 context = document; 22873 } 22874 } 22875 22876 parsed = rsingleTag.exec(data); 22877 scripts = !keepScripts && []; // Single tag 22878 22879 if (parsed) { 22880 return [context.createElement(parsed[1])]; 22881 } 22882 22883 parsed = buildFragment([data], context, scripts); 22884 22885 if (scripts && scripts.length) { 22886 jQuery(scripts).remove(); 22887 } 22888 22889 return jQuery.merge([], parsed.childNodes); 22890 }; 22891 /** 22892 * Load a url into a page 22893 */ 22894 22895 22896 jQuery.fn.load = function (url, params, callback) { 22897 var selector, 22898 type, 22899 response, 22900 self = this, 22901 off = url.indexOf(" "); 22902 22903 if (off > -1) { 22904 selector = stripAndCollapse(url.slice(off)); 22905 url = url.slice(0, off); 22906 } // If it's a function 22907 22908 22909 if (isFunction(params)) { 22910 // We assume that it's the callback 22911 callback = params; 22912 params = undefined; // Otherwise, build a param string 22913 } else if (params && _typeof(params) === "object") { 22914 type = "POST"; 22915 } // If we have elements to modify, make the request 22916 22917 22918 if (self.length > 0) { 22919 jQuery.ajax({ 22920 url: url, 22921 // If "type" variable is undefined, then "GET" method will be used. 22922 // Make value of this field explicit since 22923 // user can override it through ajaxSetup method 22924 type: type || "GET", 22925 dataType: "html", 22926 data: params 22927 }).done(function (responseText) { 22928 // Save response for use in complete callback 22929 response = arguments; 22930 self.html(selector ? // If a selector was specified, locate the right elements in a dummy div 22931 // Exclude scripts to avoid IE 'Permission Denied' errors 22932 jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) : // Otherwise use the full result 22933 responseText); // If the request succeeds, this function gets "data", "status", "jqXHR" 22934 // but they are ignored because response was set above. 22935 // If it fails, this function gets "jqXHR", "status", "error" 22936 }).always(callback && function (jqXHR, status) { 22937 self.each(function () { 22938 callback.apply(this, response || [jqXHR.responseText, status, jqXHR]); 22939 }); 22940 }); 22941 } 22942 22943 return this; 22944 }; 22945 22946 jQuery.expr.pseudos.animated = function (elem) { 22947 return jQuery.grep(jQuery.timers, function (fn) { 22948 return elem === fn.elem; 22949 }).length; 22950 }; 22951 22952 jQuery.offset = { 22953 setOffset: function setOffset(elem, options, i) { 22954 var curPosition, 22955 curLeft, 22956 curCSSTop, 22957 curTop, 22958 curOffset, 22959 curCSSLeft, 22960 calculatePosition, 22961 position = jQuery.css(elem, "position"), 22962 curElem = jQuery(elem), 22963 props = {}; // Set position first, in-case top/left are set even on static elem 22964 22965 if (position === "static") { 22966 elem.style.position = "relative"; 22967 } 22968 22969 curOffset = curElem.offset(); 22970 curCSSTop = jQuery.css(elem, "top"); 22971 curCSSLeft = jQuery.css(elem, "left"); 22972 calculatePosition = (position === "absolute" || position === "fixed") && (curCSSTop + curCSSLeft).indexOf("auto") > -1; // Need to be able to calculate position if either 22973 // top or left is auto and position is either absolute or fixed 22974 22975 if (calculatePosition) { 22976 curPosition = curElem.position(); 22977 curTop = curPosition.top; 22978 curLeft = curPosition.left; 22979 } else { 22980 curTop = parseFloat(curCSSTop) || 0; 22981 curLeft = parseFloat(curCSSLeft) || 0; 22982 } 22983 22984 if (isFunction(options)) { 22985 // Use jQuery.extend here to allow modification of coordinates argument (gh-1848) 22986 options = options.call(elem, i, jQuery.extend({}, curOffset)); 22987 } 22988 22989 if (options.top != null) { 22990 props.top = options.top - curOffset.top + curTop; 22991 } 22992 22993 if (options.left != null) { 22994 props.left = options.left - curOffset.left + curLeft; 22995 } 22996 22997 if ("using" in options) { 22998 options.using.call(elem, props); 22999 } else { 23000 if (typeof props.top === "number") { 23001 props.top += "px"; 23002 } 23003 23004 if (typeof props.left === "number") { 23005 props.left += "px"; 23006 } 23007 23008 curElem.css(props); 23009 } 23010 } 23011 }; 23012 jQuery.fn.extend({ 23013 // offset() relates an element's border box to the document origin 23014 offset: function offset(options) { 23015 // Preserve chaining for setter 23016 if (arguments.length) {
vendor: 4,402 bytes, lines 23017-23144
23017 return options === undefined ? this : this.each(function (i) { 23018 jQuery.offset.setOffset(this, options, i); 23019 }); 23020 } 23021 23022 var rect, 23023 win, 23024 elem = this[0]; 23025 23026 if (!elem) { 23027 return; 23028 } // Return zeros for disconnected and hidden (display: none) elements (gh-2310) 23029 // Support: IE <=11 only 23030 // Running getBoundingClientRect on a 23031 // disconnected node in IE throws an error 23032 23033 23034 if (!elem.getClientRects().length) { 23035 return { 23036 top: 0, 23037 left: 0 23038 }; 23039 } // Get document-relative position by adding viewport scroll to viewport-relative gBCR 23040 23041 23042 rect = elem.getBoundingClientRect(); 23043 win = elem.ownerDocument.defaultView; 23044 return { 23045 top: rect.top + win.pageYOffset, 23046 left: rect.left + win.pageXOffset 23047 }; 23048 }, 23049 // position() relates an element's margin box to its offset parent's padding box 23050 // This corresponds to the behavior of CSS absolute positioning 23051 position: function position() { 23052 if (!this[0]) { 23053 return; 23054 } 23055 23056 var offsetParent, 23057 offset, 23058 doc, 23059 elem = this[0], 23060 parentOffset = { 23061 top: 0, 23062 left: 0 23063 }; // position:fixed elements are offset from the viewport, which itself always has zero offset 23064 23065 if (jQuery.css(elem, "position") === "fixed") { 23066 // Assume position:fixed implies availability of getBoundingClientRect 23067 offset = elem.getBoundingClientRect(); 23068 } else { 23069 offset = this.offset(); // Account for the *real* offset parent, which can be the document or its root element 23070 // when a statically positioned element is identified 23071 23072 doc = elem.ownerDocument; 23073 offsetParent = elem.offsetParent || doc.documentElement; 23074 23075 while (offsetParent && (offsetParent === doc.body || offsetParent === doc.documentElement) && jQuery.css(offsetParent, "position") === "static") { 23076 offsetParent = offsetParent.parentNode; 23077 } 23078 23079 if (offsetParent && offsetParent !== elem && offsetParent.nodeType === 1) { 23080 // Incorporate borders into its offset, since they are outside its content origin 23081 parentOffset = jQuery(offsetParent).offset(); 23082 parentOffset.top += jQuery.css(offsetParent, "borderTopWidth", true); 23083 parentOffset.left += jQuery.css(offsetParent, "borderLeftWidth", true); 23084 } 23085 } // Subtract parent offsets and element margins 23086 23087 23088 return { 23089 top: offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true), 23090 left: offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true) 23091 }; 23092 }, 23093 // This method will return documentElement in the following cases: 23094 // 1) For the element inside the iframe without offsetParent, this method will return 23095 // documentElement of the parent window 23096 // 2) For the hidden or detached element 23097 // 3) For body or html element, i.e. in case of the html node - it will return itself 23098 // 23099 // but those exceptions were never presented as a real life use-cases 23100 // and might be considered as more preferable results. 23101 // 23102 // This logic, however, is not guaranteed and can change at any point in the future 23103 offsetParent: function offsetParent() { 23104 return this.map(function () { 23105 var offsetParent = this.offsetParent; 23106 23107 while (offsetParent && jQuery.css(offsetParent, "position") === "static") { 23108 offsetParent = offsetParent.offsetParent; 23109 } 23110 23111 return offsetParent || documentElement; 23112 }); 23113 } 23114 }); // Create scrollLeft and scrollTop methods 23115 23116 jQuery.each({ 23117 scrollLeft: "pageXOffset", 23118 scrollTop: "pageYOffset" 23119 }, function (method, prop) { 23120 var top = "pageYOffset" === prop; 23121 23122 jQuery.fn[method] = function (val) { 23123 return access(this, function (elem, method, val) { 23124 // Coalesce documents and windows 23125 var win; 23126 23127 if (isWindow(elem)) { 23128 win = elem; 23129 } else if (elem.nodeType === 9) { 23130 win = elem.defaultView; 23131 } 23132 23133 if (val === undefined) { 23134 return win ? win[prop] : elem[method]; 23135 } 23136 23137 if (win) { 23138 win.scrollTo(!top ? val : win.pageXOffset, top ? val : win.pageYOffset); 23139 } else { 23140 elem[method] = val; 23141 } 23142 }, method, val, arguments.length); 23143 }; 23144 });
vendor: 8,991 bytes, lines 23144-23377
23144 // Support: Safari <=7 - 9.1, Chrome <=37 - 49 23145 // Add the top/left cssHooks using jQuery.fn.position 23146 // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 23147 // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347 23148 // getComputedStyle returns percent when specified for top/left/bottom/right; 23149 // rather than make the css module depend on the offset module, just check for it here 23150 23151 jQuery.each(["top", "left"], function (_i, prop) { 23152 jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function (elem, computed) { 23153 if (computed) { 23154 computed = curCSS(elem, prop); // If curCSS returns percentage, fallback to offset 23155 23156 return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + "px" : computed; 23157 } 23158 }); 23159 }); // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods 23160 23161 jQuery.each({ 23162 Height: "height", 23163 Width: "width" 23164 }, function (name, type) { 23165 jQuery.each({ 23166 padding: "inner" + name, 23167 content: type, 23168 "": "outer" + name 23169 }, function (defaultExtra, funcName) { 23170 // Margin is only for outerHeight, outerWidth 23171 jQuery.fn[funcName] = function (margin, value) { 23172 var chainable = arguments.length && (defaultExtra || typeof margin !== "boolean"), 23173 extra = defaultExtra || (margin === true || value === true ? "margin" : "border"); 23174 return access(this, function (elem, type, value) { 23175 var doc; 23176 23177 if (isWindow(elem)) { 23178 // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729) 23179 return funcName.indexOf("outer") === 0 ? elem["inner" + name] : elem.document.documentElement["client" + name]; 23180 } // Get document width or height 23181 23182 23183 if (elem.nodeType === 9) { 23184 doc = elem.documentElement; // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], 23185 // whichever is greatest 23186 23187 return Math.max(elem.body["scroll" + name], doc["scroll" + name], elem.body["offset" + name], doc["offset" + name], doc["client" + name]); 23188 } 23189 23190 return value === undefined ? // Get width or height on the element, requesting but not forcing parseFloat 23191 jQuery.css(elem, type, extra) : // Set width or height on the element 23192 jQuery.style(elem, type, value, extra); 23193 }, type, chainable ? margin : undefined, chainable); 23194 }; 23195 }); 23196 }); 23197 jQuery.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function (_i, type) { 23198 jQuery.fn[type] = function (fn) { 23199 return this.on(type, fn); 23200 }; 23201 }); 23202 jQuery.fn.extend({ 23203 bind: function bind(types, data, fn) { 23204 return this.on(types, null, data, fn); 23205 }, 23206 unbind: function unbind(types, fn) { 23207 return this.off(types, null, fn); 23208 }, 23209 delegate: function delegate(selector, types, data, fn) { 23210 return this.on(types, selector, data, fn); 23211 }, 23212 undelegate: function undelegate(selector, types, fn) { 23213 // ( namespace ) or ( selector, types [, fn] ) 23214 return arguments.length === 1 ? this.off(selector, "**") : this.off(types, selector || "**", fn); 23215 }, 23216 hover: function hover(fnOver, fnOut) { 23217 return this.mouseenter(fnOver).mouseleave(fnOut || fnOver); 23218 } 23219 }); 23220 jQuery.each(("blur focus focusin focusout resize scroll click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup contextmenu").split(" "), function (_i, name) { 23221 // Handle event binding 23222 jQuery.fn[name] = function (data, fn) { 23223 return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name); 23224 }; 23225 }); // Support: Android <=4.0 only 23226 // Make sure we trim BOM and NBSP 23227 23228 var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g; // Bind a function to a context, optionally partially applying any 23229 // arguments. 23230 // jQuery.proxy is deprecated to promote standards (specifically Function#bind) 23231 // However, it is not slated for removal any time soon 23232 23233 jQuery.proxy = function (fn, context) { 23234 var tmp, args, proxy; 23235 23236 if (typeof context === "string") { 23237 tmp = fn[context]; 23238 context = fn; 23239 fn = tmp; 23240 } // Quick check to determine if target is callable, in the spec 23241 // this throws a TypeError, but we will just return undefined. 23242 23243 23244 if (!isFunction(fn)) { 23245 return undefined; 23246 } // Simulated bind 23247 23248 23249 args = _slice.call(arguments, 2); 23250 23251 proxy = function proxy() { 23252 return fn.apply(context || this, args.concat(_slice.call(arguments))); 23253 }; // Set the guid of unique handler to the same of original handler, so it can be removed 23254 23255 23256 proxy.guid = fn.guid = fn.guid || jQuery.guid++; 23257 return proxy; 23258 }; 23259 23260 jQuery.holdReady = function (hold) { 23261 if (hold) { 23262 jQuery.readyWait++; 23263 } else { 23264 jQuery.ready(true); 23265 } 23266 }; 23267 23268 jQuery.isArray = Array.isArray; 23269 jQuery.parseJSON = JSON.parse; 23270 jQuery.nodeName = nodeName; 23271 jQuery.isFunction = isFunction; 23272 jQuery.isWindow = isWindow; 23273 jQuery.camelCase = camelCase; 23274 jQuery.type = toType; 23275 jQuery.now = Date.now; 23276 23277 jQuery.isNumeric = function (obj) { 23278 // As of jQuery 3.0, isNumeric is limited to 23279 // strings and numbers (primitives or objects) 23280 // that can be coerced to finite numbers (gh-2662) 23281 var type = jQuery.type(obj); 23282 return (type === "number" || type === "string") && // parseFloat NaNs numeric-cast false positives ("") 23283 // ...but misinterprets leading-number strings, particularly hex literals ("0x...") 23284 // subtraction forces infinities to NaN 23285 !isNaN(obj - parseFloat(obj)); 23286 }; 23287 23288 jQuery.trim = function (text) { 23289 return text == null ? "" : (text + "").replace(rtrim, ""); 23290 }; // Register as a named AMD module, since jQuery can be concatenated with other 23291 // files that may use define, but not via a proper concatenation script that 23292 // understands anonymous AMD modules. A named AMD is safest and most robust 23293 // way to register. Lowercase jquery is used because AMD module names are 23294 // derived from file names, and jQuery is normally delivered in a lowercase 23295 // file name. Do this after creating the global so that if an AMD module wants 23296 // to call noConflict to hide this version of jQuery, it will work. 23297 // Note that for maximum portability, libraries that are not jQuery should 23298 // declare themselves as anonymous modules, and avoid setting a global if an 23299 // AMD loader is present. jQuery is a special case. For more information, see 23300 // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon 23301 23302 23303 if (true) { 23304 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () { 23305 return jQuery; 23306 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 23307 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 23308 } 23309 23310 var // Map over jQuery in case of overwrite 23311 _jQuery = window.jQuery, 23312 // Map over the $ in case of overwrite 23313 _$ = window.$; 23314 23315 jQuery.noConflict = function (deep) { 23316 if (window.$ === jQuery) { 23317 window.$ = _$; 23318 } 23319 23320 if (deep && window.jQuery === jQuery) { 23321 window.jQuery = _jQuery; 23322 } 23323 23324 return jQuery; 23325 }; // Expose jQuery and $ identifiers, even in AMD 23326 // (#7102#comment:10, https://github.com/jquery/jquery/pull/557) 23327 // and CommonJS for browser emulators (#13566) 23328 23329 23330 if (typeof noGlobal === "undefined") { 23331 window.jQuery = window.$ = jQuery; 23332 } 23333 23334 return jQuery; 23335}); 23336 23337/***/ }), 23338 23339/***/ 8791: 23340/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 23341 23342/* module decorator */ module = __webpack_require__.nmd(module); 23343function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 23344 23345(function (window, factory) { 23346 var lazySizes = factory(window, window.document, Date); 23347 window.lazySizes = lazySizes; 23348 23349 if (( false ? 0 : _typeof(module)) == 'object' && module.exports) { 23350 module.exports = lazySizes; 23351 } 23352})(typeof window != 'undefined' ? window : {}, function l(window, document, Date) { 23353 // Pass in the windoe Date function also for SSR because the Date class can be lost 23354 'use strict'; 23355 /*jshint eqnull:true */ 23356 23357 var lazysizes, lazySizesCfg; 23358 23359 (function () { 23360 var prop; 23361 var lazySizesDefaults = { 23362 lazyClass: 'lazyload', 23363 loadedClass: 'lazyloaded', 23364 loadingClass: 'lazyloading', 23365 preloadClass: 'lazypreload', 23366 errorClass: 'lazyerror', 23367 //strictClass: 'lazystrict', 23368 autosizesClass: 'lazyautosizes', 23369 srcAttr: 'data-src', 23370 srcsetAttr: 'data-srcset', 23371 sizesAttr: 'data-sizes', 23372 //preloadAfterLoad: false, 23373 minSize: 40, 23374 customMedia: {}, 23375 init: true, 23376 expFactor: 1.5, 23377 hFac: 0.8,
23378 loadMode: 2, 23379 loadHidden: true, 23380 ricTimeout: 0, 23381 throttleDelay: 125 23382 }; 23383 lazySizesCfg = window.lazySizesConfig || window.lazysizesConfig || {}; 23384 23385 for (prop in lazySizesDefaults) { 23386 if (!(prop in lazySizesCfg)) { 23387 lazySizesCfg[prop] = lazySizesDefaults[prop]; 23388 } 23389 } 23390 })(); 23391 23392 if (!document || !document.getElementsByClassName) { 23393 return { 23394 init: function init() {}, 23395 cfg: lazySizesCfg, 23396 noSupport: true 23397 }; 23398 } 23399 23400 var docElem = document.documentElement; 23401 var supportPicture = window.HTMLPictureElement; 23402 var _addEventListener = 'addEventListener'; 23403 var _getAttribute = 'getAttribute'; 23404 /** 23405 * Update to bind to window because 'this' becomes null during SSR 23406 * builds. 23407 */ 23408 23409 var addEventListener = window[_addEventListener].bind(window); 23410 23411 var setTimeout = window.setTimeout; 23412 var requestAnimationFrame = window.requestAnimationFrame || setTimeout; 23413 var requestIdleCallback = window.requestIdleCallback; 23414 var regPicture = /^picture$/i; 23415 var loadEvents = ['load', 'error', 'lazyincluded', '_lazyloaded']; 23416 var regClassCache = {}; 23417 var forEach = Array.prototype.forEach; 23418 23419 var hasClass = function hasClass(ele, cls) { 23420 if (!regClassCache[cls]) { 23421 regClassCache[cls] = new RegExp('(\\s|^)' + cls + '(\\s|$)'); 23422 } 23423 23424 return regClassCache[cls].test(ele[_getAttribute]('class') || '') && regClassCache[cls]; 23425 }; 23426 23427 var addClass = function addClass(ele, cls) { 23428 if (!hasClass(ele, cls)) { 23429 ele.setAttribute('class', (ele[_getAttribute]('class') || '').trim() + ' ' + cls); 23430 } 23431 }; 23432 23433 var removeClass = function removeClass(ele, cls) { 23434 var reg; 23435 23436 if (reg = hasClass(ele, cls)) { 23437 ele.setAttribute('class', (ele[_getAttribute]('class') || '').replace(reg, ' ')); 23438 } 23439 }; 23440 23441 var addRemoveLoadEvents = function addRemoveLoadEvents(dom, fn, add) { 23442 var action = add ? _addEventListener : 'removeEventListener'; 23443 23444 if (add) { 23445 addRemoveLoadEvents(dom, fn); 23446 } 23447 23448 loadEvents.forEach(function (evt) { 23449 dom[action](evt, fn); 23450 }); 23451 }; 23452 23453 var triggerEvent = function triggerEvent(elem, name, detail, noBubbles, noCancelable) { 23454 var event = document.createEvent('Event'); 23455 23456 if (!detail) { 23457 detail = {}; 23458 } 23459 23460 detail.instance = lazysizes; 23461 event.initEvent(name, !noBubbles, !noCancelable); 23462 event.detail = detail; 23463 elem.dispatchEvent(event); 23464 return event; 23465 }; 23466 23467 var updatePolyfill = function updatePolyfill(el, full) { 23468 var polyfill; 23469 23470 if (!supportPicture && (polyfill = window.picturefill || lazySizesCfg.pf)) { 23471 if (full && full.src && !el[_getAttribute]('srcset')) { 23472 el.setAttribute('srcset', full.src); 23473 } 23474 23475 polyfill({ 23476 reevaluate: true, 23477 elements: [el] 23478 }); 23479 } else if (full && full.src) { 23480 el.src = full.src; 23481 } 23482 }; 23483 23484 var getCSS = function getCSS(elem, style) { 23485 return (getComputedStyle(elem, null) || {})[style]; 23486 }; 23487 23488 var getWidth = function getWidth(elem, parent, width) { 23489 width = width || elem.offsetWidth; 23490 23491 while (width < lazySizesCfg.minSize && parent && !elem._lazysizesWidth) { 23492 width = parent.offsetWidth; 23493 parent = parent.parentNode; 23494 } 23495 23496 return width; 23497 }; 23498 23499 var rAF = function () { 23500 var running, waiting; 23501 var firstFns = []; 23502 var secondFns = []; 23503 var fns = firstFns; 23504 23505 var run = function run() { 23506 var runFns = fns; 23507 fns = firstFns.length ? secondFns : firstFns; 23508 running = true; 23509 waiting = false; 23510 23511 while (runFns.length) { 23512 runFns.shift()(); 23513 } 23514 23515 running = false; 23516 }; 23517 23518 var rafBatch = function rafBatch(fn, queue) { 23519 if (running && !queue) { 23520 fn.apply(this, arguments); 23521 } else { 23522 fns.push(fn); 23523 23524 if (!waiting) { 23525 waiting = true; 23526 (document.hidden ? setTimeout : requestAnimationFrame)(run); 23527 } 23528 } 23529 }; 23530 23531 rafBatch._lsFlush = run; 23532 return rafBatch; 23533 }(); 23534 23535 var rAFIt = function rAFIt(fn, simple) { 23536 return simple ? function () { 23537 rAF(fn); 23538 } : function () { 23539 var that = this; 23540 var args = arguments; 23541 rAF(function () { 23542 fn.apply(that, args); 23543 }); 23544 }; 23545 }; 23546 23547 var throttle = function throttle(fn) { 23548 var running; 23549 var lastTime = 0; 23550 var gDelay = lazySizesCfg.throttleDelay; 23551 var rICTimeout = lazySizesCfg.ricTimeout; 23552 23553 var run = function run() { 23554 running = false;
23555 lastTime = Date.now(); 23556 fn(); 23557 }; 23558 23559 var idleCallback = requestIdleCallback && rICTimeout > 49 ? function () { 23560 requestIdleCallback(run, { 23561 timeout: rICTimeout 23562 }); 23563 23564 if (rICTimeout !== lazySizesCfg.ricTimeout) { 23565 rICTimeout = lazySizesCfg.ricTimeout; 23566 } 23567 } : rAFIt(function () { 23568 setTimeout(run); 23569 }, true); 23570 return function (isPriority) { 23571 var delay; 23572 23573 if (isPriority = isPriority === true) { 23574 rICTimeout = 33; 23575 } 23576 23577 if (running) { 23578 return; 23579 } 23580 23581 running = true; 23582 delay = gDelay - (Date.now() - lastTime); 23583 23584 if (delay < 0) { 23585 delay = 0; 23586 } 23587 23588 if (isPriority || delay < 9) { 23589 idleCallback(); 23590 } else { 23591 setTimeout(idleCallback, delay); 23592 } 23593 }; 23594 }; //based on http://modernjavascript.blogspot.de/2013/08/building-better-debounce.html 23595 23596 23597 var debounce = function debounce(func) { 23598 var timeout, timestamp; 23599 var wait = 99; 23600 23601 var run = function run() { 23602 timeout = null; 23603 func(); 23604 }; 23605 23606 var later = function later() { 23607 var last = Date.now() - timestamp; 23608 23609 if (last < wait) { 23610 setTimeout(later, wait - last); 23611 } else { 23612 (requestIdleCallback || run)(run); 23613 } 23614 }; 23615 23616 return function () { 23617 timestamp = Date.now(); 23618 23619 if (!timeout) { 23620 timeout = setTimeout(later, wait); 23621 } 23622 }; 23623 }; 23624 23625 var loader = function () { 23626 var preloadElems, isCompleted, resetPreloadingTimer, loadMode, started; 23627 var eLvW, elvH, eLtop, eLleft, eLright, eLbottom, isBodyHidden; 23628 var regImg = /^img$/i; 23629 var regIframe = /^iframe$/i; 23630 var supportScroll = 'onscroll' in window && !/(gle|ing)bot/.test(navigator.userAgent); 23631 var shrinkExpand = 0; 23632 var currentExpand = 0; 23633 var isLoading = 0; 23634 var lowRuns = -1; 23635 23636 var resetPreloading = function resetPreloading(e) { 23637 isLoading--; 23638 23639 if (!e || isLoading < 0 || !e.target) { 23640 isLoading = 0; 23641 } 23642 }; 23643 23644 var isVisible = function isVisible(elem) { 23645 if (isBodyHidden == null) { 23646 isBodyHidden = getCSS(document.body, 'visibility') == 'hidden'; 23647 } 23648 23649 return isBodyHidden || !(getCSS(elem.parentNode, 'visibility') == 'hidden' && getCSS(elem, 'visibility') == 'hidden'); 23650 }; 23651 23652 var isNestedVisible = function isNestedVisible(elem, elemExpand) { 23653 var outerRect; 23654 var parent = elem; 23655 var visible = isVisible(elem); 23656 eLtop -= elemExpand; 23657 eLbottom += elemExpand; 23658 eLleft -= elemExpand; 23659 eLright += elemExpand; 23660 23661 while (visible && (parent = parent.offsetParent) && parent != document.body && parent != docElem) { 23662 visible = (getCSS(parent, 'opacity') || 1) > 0; 23663 23664 if (visible && getCSS(parent, 'overflow') != 'visible') { 23665 outerRect = parent.getBoundingClientRect(); 23666 visible = eLright > outerRect.left && eLleft < outerRect.right && eLbottom > outerRect.top - 1 && eLtop < outerRect.bottom + 1; 23667 } 23668 } 23669 23670 return visible; 23671 }; 23672 23673 var checkElements = function checkElements() { 23674 var eLlen, i, rect, autoLoadElem, loadedSomething, elemExpand, elemNegativeExpand, elemExpandVal, beforeExpandVal, defaultExpand, preloadExpand, hFac; 23675 var lazyloadElems = lazysizes.elements; 23676 23677 if ((loadMode = lazySizesCfg.loadMode) && isLoading < 8 && (eLlen = lazyloadElems.length)) { 23678 i = 0; 23679 lowRuns++; 23680 23681 for (; i < eLlen; i++) { 23682 if (!lazyloadElems[i] || lazyloadElems[i]._lazyRace) { 23683 continue; 23684 } 23685 23686 if (!supportScroll || lazysizes.prematureUnveil && lazysizes.prematureUnveil(lazyloadElems[i])) { 23687 unveilElement(lazyloadElems[i]); 23688 continue; 23689 } 23690 23691 if (!(elemExpandVal = lazyloadElems[i][_getAttribute]('data-expand')) || !(elemExpand = elemExpandVal * 1)) { 23692 elemExpand = currentExpand; 23693 } 23694 23695 if (!defaultExpand) { 23696 defaultExpand = !lazySizesCfg.expand || lazySizesCfg.expand < 1 ? docElem.clientHeight > 500 && docElem.clientWidth > 500 ? 500 : 370 : lazySizesCfg.expand; 23697 lazysizes._defEx = defaultExpand; 23698 preloadExpand = defaultExpand * lazySizesCfg.expFactor; 23699 hFac = lazySizesCfg.hFac; 23700 isBodyHidden = null; 23701 23702 if (currentExpand < preloadExpand && isLoading < 1 && lowRuns >
23702 2 && loadMode > 2 && !document.hidden) { 23703 currentExpand = preloadExpand; 23704 lowRuns = 0; 23705 } else if (loadMode > 1 && lowRuns > 1 && isLoading < 6) { 23706 currentExpand = defaultExpand; 23707 } else { 23708 currentExpand = shrinkExpand; 23709 } 23710 } 23711 23712 if (beforeExpandVal !== elemExpand) { 23713 eLvW = innerWidth + elemExpand * hFac; 23714 elvH = innerHeight + elemExpand; 23715 elemNegativeExpand = elemExpand * -1; 23716 beforeExpandVal = elemExpand; 23717 } 23718 23719 rect = lazyloadElems[i].getBoundingClientRect(); 23720 23721 if ((eLbottom = rect.bottom) >= elemNegativeExpand && (eLtop = rect.top) <= elvH && (eLright = rect.right) >= elemNegativeExpand * hFac && (eLleft = rect.left) <= eLvW && (eLbottom || eLright || eLleft || eLtop) && (lazySizesCfg.loadHidden || isVisible(lazyloadElems[i])) && (isCompleted && isLoading < 3 && !elemExpandVal && (loadMode < 3 || lowRuns < 4) || isNestedVisible(lazyloadElems[i], elemExpand))) { 23722 unveilElement(lazyloadElems[i]); 23723 loadedSomething = true; 23724 23725 if (isLoading > 9) { 23726 break; 23727 } 23728 } else if (!loadedSomething && isCompleted && !autoLoadElem && isLoading < 4 && lowRuns < 4 && loadMode > 2 && (preloadElems[0] || lazySizesCfg.preloadAfterLoad) && (preloadElems[0] || !elemExpandVal && (eLbottom || eLright || eLleft || eLtop || lazyloadElems[i][_getAttribute](lazySizesCfg.sizesAttr) != 'auto'))) { 23729 autoLoadElem = preloadElems[0] || lazyloadElems[i]; 23730 } 23731 } 23732 23733 if (autoLoadElem && !loadedSomething) { 23734 unveilElement(autoLoadElem); 23735 } 23736 } 23737 }; 23738 23739 var throttledCheckElements = throttle(checkElements); 23740 23741 var switchLoadingClass = function switchLoadingClass(e) { 23742 var elem = e.target; 23743 23744 if (elem._lazyCache) { 23745 delete elem._lazyCache; 23746 return; 23747 } 23748 23749 resetPreloading(e); 23750 addClass(elem, lazySizesCfg.loadedClass); 23751 removeClass(elem, lazySizesCfg.loadingClass); 23752 addRemoveLoadEvents(elem, rafSwitchLoadingClass); 23753 triggerEvent(elem, 'lazyloaded'); 23754 }; 23755 23756 var rafedSwitchLoadingClass = rAFIt(switchLoadingClass); 23757 23758 var rafSwitchLoadingClass = function rafSwitchLoadingClass(e) { 23759 rafedSwitchLoadingClass({ 23760 target: e.target 23761 }); 23762 }; 23763 23764 var changeIframeSrc = function changeIframeSrc(elem, src) { 23765 try { 23766 elem.contentWindow.location.replace(src); 23767 } catch (e) { 23768 elem.src = src; 23769 } 23770 }; 23771 23772 var handleSources = function handleSources(source) { 23773 var customMedia; 23774 23775 var sourceSrcset = source[_getAttribute](lazySizesCfg.srcsetAttr); 23776 23777 if (customMedia = lazySizesCfg.customMedia[source[_getAttribute]('data-media') || source[_getAttribute]('media')]) { 23778 source.setAttribute('media', customMedia); 23779 } 23780 23781 if (sourceSrcset) { 23782 source.setAttribute('srcset', sourceSrcset); 23783 } 23784 }; 23785 23786 var lazyUnveil = rAFIt(function (elem, detail, isAuto, sizes, isImg) { 23787 var src, srcset, parent, isPicture, event, firesLoad; 23788 23789 if (!(event = triggerEvent(elem, 'lazybeforeunveil', detail)).defaultPrevented) { 23790 if (sizes) { 23791 if (isAuto) { 23792 addClass(elem, lazySizesCfg.autosizesClass); 23793 } else { 23794 elem.setAttribute('sizes', sizes); 23795 } 23796 } 23797 23798 srcset = elem[_getAttribute](lazySizesCfg.srcsetAttr); 23799 src = elem[_getAttribute](lazySizesCfg.srcAttr); 23800 23801 if (isImg) { 23802 parent = elem.parentNode; 23803 isPicture = parent && regPicture.test(parent.nodeName || ''); 23804 } 23805 23806 firesLoad = detail.firesLoad || 'src' in elem && (srcset || src || isPicture); 23807 event = { 23808 target: elem 23809 }; 23810 addClass(elem, lazySizesCfg.loadingClass); 23811 23812 if (firesLoad) { 23813 clearTimeout(resetPreloadingTimer); 23814 resetPreloadingTimer = setTimeout(resetPreloading, 2500); 23815 addRemoveLoadEvents(elem, rafSwitchLoadingClass, true); 23816 } 23817 23818 if (isPicture) {
vendor: 6,844 bytes, lines 23819-24056
23819 forEach.call(parent.getElementsByTagName('source'), handleSources); 23820 } 23821 23822 if (srcset) { 23823 elem.setAttribute('srcset', srcset); 23824 } else if (src && !isPicture) { 23825 if (regIframe.test(elem.nodeName)) { 23826 changeIframeSrc(elem, src); 23827 } else { 23828 elem.src = src; 23829 } 23830 } 23831 23832 if (isImg && (srcset || isPicture)) { 23833 updatePolyfill(elem, { 23834 src: src 23835 }); 23836 } 23837 } 23838 23839 if (elem._lazyRace) { 23840 delete elem._lazyRace; 23841 } 23842 23843 removeClass(elem, lazySizesCfg.lazyClass); 23844 rAF(function () { 23845 // Part of this can be removed as soon as this fix is older: https://bugs.chromium.org/p/chromium/issues/detail?id=7731 (2015) 23846 var isLoaded = elem.complete && elem.naturalWidth > 1; 23847 23848 if (!firesLoad || isLoaded) { 23849 if (isLoaded) { 23850 addClass(elem, 'ls-is-cached'); 23851 } 23852 23853 switchLoadingClass(event); 23854 elem._lazyCache = true; 23855 setTimeout(function () { 23856 if ('_lazyCache' in elem) { 23857 delete elem._lazyCache; 23858 } 23859 }, 9); 23860 } 23861 23862 if (elem.loading == 'lazy') { 23863 isLoading--; 23864 } 23865 }, true); 23866 }); 23867 23868 var unveilElement = function unveilElement(elem) { 23869 if (elem._lazyRace) { 23870 return; 23871 } 23872 23873 var detail; 23874 var isImg = regImg.test(elem.nodeName); //allow using sizes="auto", but don't use. it's invalid. Use data-sizes="auto" or a valid value for sizes instead (i.e.: sizes="80vw") 23875 23876 var sizes = isImg && (elem[_getAttribute](lazySizesCfg.sizesAttr) || elem[_getAttribute]('sizes')); 23877 23878 var isAuto = sizes == 'auto'; 23879 23880 if ((isAuto || !isCompleted) && isImg && (elem[_getAttribute]('src') || elem.srcset) && !elem.complete && !hasClass(elem, lazySizesCfg.errorClass) && hasClass(elem, lazySizesCfg.lazyClass)) { 23881 return; 23882 } 23883 23884 detail = triggerEvent(elem, 'lazyunveilread').detail; 23885 23886 if (isAuto) { 23887 autoSizer.updateElem(elem, true, elem.offsetWidth); 23888 } 23889 23890 elem._lazyRace = true; 23891 isLoading++; 23892 lazyUnveil(elem, detail, isAuto, sizes, isImg); 23893 }; 23894 23895 var afterScroll = debounce(function () { 23896 lazySizesCfg.loadMode = 3; 23897 throttledCheckElements(); 23898 }); 23899 23900 var altLoadmodeScrollListner = function altLoadmodeScrollListner() { 23901 if (lazySizesCfg.loadMode == 3) { 23902 lazySizesCfg.loadMode = 2; 23903 } 23904 23905 afterScroll(); 23906 }; 23907 23908 var onload = function onload() { 23909 if (isCompleted) { 23910 return; 23911 } 23912 23913 if (Date.now() - started < 999) { 23914 setTimeout(onload, 999); 23915 return; 23916 } 23917 23918 isCompleted = true; 23919 lazySizesCfg.loadMode = 3; 23920 throttledCheckElements(); 23921 addEventListener('scroll', altLoadmodeScrollListner, true); 23922 }; 23923 23924 return { 23925 _: function _() { 23926 started = Date.now(); 23927 lazysizes.elements = document.getElementsByClassName(lazySizesCfg.lazyClass); 23928 preloadElems = document.getElementsByClassName(lazySizesCfg.lazyClass + ' ' + lazySizesCfg.preloadClass); 23929 addEventListener('scroll', throttledCheckElements, true); 23930 addEventListener('resize', throttledCheckElements, true); 23931 addEventListener('pageshow', function (e) { 23932 if (e.persisted) { 23933 var loadingElements = document.querySelectorAll('.' + lazySizesCfg.loadingClass); 23934 23935 if (loadingElements.length && loadingElements.forEach) { 23936 requestAnimationFrame(function () { 23937 loadingElements.forEach(function (img) { 23938 if (img.complete) { 23939 unveilElement(img); 23940 } 23941 }); 23942 }); 23943 } 23944 } 23945 }); 23946 23947 if (window.MutationObserver) { 23948 new MutationObserver(throttledCheckElements).observe(docElem, { 23949 childList: true, 23950 subtree: true, 23951 attributes: true 23952 }); 23953 } else { 23954 docElem[_addEventListener]('DOMNodeInserted', throttledCheckElements, true); 23955 23956 docElem[_addEventListener]('DOMAttrModified', throttledCheckElements, true); 23957 23958 setInterval(throttledCheckElements, 999); 23959 } 23960 23961 addEventListener('hashchange', throttledCheckElements, true); //, 'fullscreenchange' 23962 23963 ['focus', 'mouseover', 'click', 'load', 'transitionend', 'animationend'].forEach(function (name) { 23964 document[_addEventListener](name, throttledCheckElements, true); 23965 }); 23966 23967 if (/d$|^c/.test(document.readyState)) { 23968 onload(); 23969 } else { 23970 addEventListener('load', onload); 23971 23972 document[_addEventListener]('DOMContentLoaded', throttledCheckElements); 23973 23974 setTimeout(onload, 20000); 23975 } 23976 23977 if (lazysizes.elements.length) { 23978 checkElements(); 23979 23980 rAF._lsFlush(); 23981 } else { 23982 throttledCheckElements(); 23983 } 23984 }, 23985 checkElems: throttledCheckElements, 23986 unveil: unveilElement, 23987 _aLSL: altLoadmodeScrollListner 23988 }; 23989 }(); 23990 23991 var autoSizer = function () { 23992 var autosizesElems; 23993 var sizeElement = rAFIt(function (elem, parent, event, width) { 23994 var sources, i, len; 23995 elem._lazysizesWidth = width; 23996 width += 'px'; 23997 elem.setAttribute('sizes', width); 23998 23999 if (regPicture.test(parent.nodeName || '')) { 24000 sources = parent.getElementsByTagName('source'); 24001 24002 for (i = 0, len = sources.length; i < len; i++) { 24003 sources[i].setAttribute('sizes', width); 24004 } 24005 } 24006 24007 if (!event.detail.dataAttr) { 24008 updatePolyfill(elem, event.detail); 24009 } 24010 }); 24011 24012 var getSizeElement = function getSizeElement(elem, dataAttr, width) { 24013 var event; 24014 var parent = elem.parentNode; 24015 24016 if (parent) { 24017 width = getWidth(elem, parent, width); 24018 event = triggerEvent(elem, 'lazybeforesizes', { 24019 width: width, 24020 dataAttr: !!dataAttr 24021 }); 24022 24023 if (!event.defaultPrevented) { 24024 width = event.detail.width; 24025 24026 if (width && width !== elem._lazysizesWidth) { 24027 sizeElement(elem, parent, event, width); 24028 } 24029 } 24030 } 24031 }; 24032 24033 var updateElementsSizes = function updateElementsSizes() { 24034 var i; 24035 var len = autosizesElems.length; 24036 24037 if (len) { 24038 i = 0; 24039 24040 for (; i < len; i++) { 24041 getSizeElement(autosizesElems[i]); 24042 } 24043 } 24044 }; 24045 24046 var debouncedUpdateElementsSizes = debounce(updateElementsSizes); 24047 return { 24048 _: function _() { 24049 autosizesElems = document.getElementsByClassName(lazySizesCfg.autosizesClass); 24050 addEventListener('resize', debouncedUpdateElementsSizes); 24051 }, 24052 checkElems: debouncedUpdateElementsSizes, 24053 updateElem: getSizeElement 24054 }; 24055 }(); 24056
24057 var init = function init() { 24058 if (!init.i && document.getElementsByClassName) { 24059 init.i = true; 24060 24061 autoSizer._(); 24062 24063 loader._(); 24064 } 24065 }; 24066 24067 setTimeout(function () { 24068 if (lazySizesCfg.init) { 24069 init(); 24070 } 24071 }); 24072 lazysizes = { 24073 cfg: lazySizesCfg, 24074 autoSizer: autoSizer, 24075 loader: loader, 24076 init: init, 24077 uP: updatePolyfill, 24078 aC: addClass, 24079 rC: removeClass, 24080 hC: hasClass, 24081 fire: triggerEvent, 24082 gW: getWidth, 24083 rAF: rAF 24084 }; 24085 return lazysizes; 24086}); 24087 24088/***/ }), 24089 24090/***/ 2057: 24091/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24092 24093var root = __webpack_require__(3269); 24094/** Built-in value references. */ 24095 24096 24097var _Symbol = root.Symbol; 24098module.exports = _Symbol; 24099 24100/***/ }), 24101 24102/***/ 6192: 24103/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24104 24105var _Symbol = __webpack_require__(2057), 24106 getRawTag = __webpack_require__(4299), 24107 objectToString = __webpack_require__(2702); 24108/** `Object#toString` result references. */ 24109 24110 24111var nullTag = '[object Null]', 24112 undefinedTag = '[object Undefined]'; 24113/** Built-in value references. */ 24114 24115var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined; 24116/** 24117 * The base implementation of `getTag` without fallbacks for buggy environments. 24118 * 24119 * @private 24120 * @param {*} value The value to query. 24121 * @returns {string} Returns the `toStringTag`. 24122 */ 24123 24124function baseGetTag(value) { 24125 if (value == null) { 24126 return value === undefined ? undefinedTag : nullTag; 24127 } 24128 24129 return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value); 24130} 24131 24132module.exports = baseGetTag; 24133 24134/***/ }), 24135 24136/***/ 2728: 24137/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24138 24139var trimmedEndIndex = __webpack_require__(9312); 24140/** Used to match leading whitespace. */ 24141 24142 24143var reTrimStart = /^\s+/; 24144/** 24145 * The base implementation of `_.trim`. 24146 * 24147 * @private 24148 * @param {string} string The string to trim. 24149 * @returns {string} Returns the trimmed string. 24150 */ 24151 24152function baseTrim(string) { 24153 return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '') : string; 24154} 24155 24156module.exports = baseTrim; 24157 24158/***/ }), 24159 24160/***/ 9696: 24161/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24162 24163function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 24164 24165/** Detect free variable `global` from Node.js. */ 24166var freeGlobal = (typeof __webpack_require__.g === "undefined" ? "undefined" : _typeof(__webpack_require__.g)) == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g; 24167module.exports = freeGlobal; 24168 24169/***/ }), 24170 24171/***/ 4299: 24172/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24173 24174var _Symbol = __webpack_require__(2057); 24175/** Used for built-in method references. */ 24176 24177 24178var objectProto = Object.prototype; 24179/** Used to check objects for own properties. */ 24180 24181var hasOwnProperty = objectProto.hasOwnProperty; 24182/** 24183 * Used to resolve the 24184 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) 24185 * of values. 24186 */ 24187 24188var nativeObjectToString = objectProto.toString; 24189/** Built-in value references. */ 24190 24191var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined; 24192/** 24193 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. 24194 * 24195 * @private 24196 * @param {*} value The value to query. 24197 * @returns {string} Returns the raw `toStringTag`. 24198 */ 24199 24200function getRawTag(value) { 24201 var isOwn = hasOwnProperty.call(value, symToStringTag), 24202 tag = value[symToStringTag]; 24203 24204 try { 24205 value[symToStringTag] = undefined; 24206 var unmasked = true; 24207 } catch (e) {} 24208 24209 var result = nativeObjectToString.call(value); 24210 24211 if (unmasked) { 24212 if (isOwn) { 24213 value[symToStringTag] = tag; 24214 } else { 24215 delete value[symToStringTag]; 24216 } 24217 } 24218 24219 return result; 24220} 24221 24222module.exports = getRawTag; 24223 24224/***/ }), 24225 24226/***/ 2702: 24227/***/ ((module) => { 24228 24229/** Used for built-in method references. */ 24230var objectProto = Object.prototype; 24231/** 24232 * Used to resolve the 24233 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) 24234 * of values. 24235 */ 24236 24237var nativeObjectToString = objectProto.toString; 24238/** 24239 * Converts `value` to a string using `Object.prototype.toString`. 24240 * 24241 * @private 24242 * @param {*} value The value to convert. 24243 * @returns {string} Returns the converted string. 24244 */ 24245 24246function objectToString(value) { 24247 return nativeObjectToString.call(value); 24248} 24249 24250module.exports = objectToString; 24251 24252/***/ }), 24253 24254/***/ 3269: 24255/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24256 24257function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 24258 24259var freeGlobal = __webpack_require__(9696); 24260/** Detect free variable `self`. */ 24261 24262 24263var freeSelf = (typeof self === "undefined" ? "undefined" : _typeof(self)) == 'object' && self && self.Object === Object && self; 24264/** Used as a reference to the global object. */ 24265 24266var root = freeGlobal || freeSelf || Function('return this')(); 24267module.exports = root; 24268 24269/***/ }), 24270 24271/***/ 9312: 24272/***/ ((module) => { 24273 24274/** Used to match a single whitespace character. */ 24275var reWhitespace = /\s/; 24276/** 24277 * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace 24278 * character of `string`. 24279 * 24280 * @private 24281 * @param {string} string The string to inspect. 24282 * @returns {number} Returns the index of the last non-whitespace character. 24283 */ 24284 24285function trimmedEndIndex(string) { 24286 var index = string.length; 24287 24288 while (index-- && reWhitespace.test(string.charAt(index))) {} 24289 24290 return index; 24291} 24292 24293module.exports = trimmedEndIndex; 24294 24295/***/ }), 24296 24297/***/ 613: 24298/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24299 24300var isObject = __webpack_require__(6245), 24301 now = __webpack_require__(6100), 24302 toNumber = __webpack_require__(3766); 24303/** Error message constants. */ 24304 24305
vendor: 9,128 bytes, lines 24306-24611
24306var FUNC_ERROR_TEXT = 'Expected a function'; 24307/* Built-in method references for those with the same name as other `lodash` methods. */ 24308 24309var nativeMax = Math.max, 24310 nativeMin = Math.min; 24311/** 24312 * Creates a debounced function that delays invoking `func` until after `wait` 24313 * milliseconds have elapsed since the last time the debounced function was 24314 * invoked. The debounced function comes with a `cancel` method to cancel 24315 * delayed `func` invocations and a `flush` method to immediately invoke them. 24316 * Provide `options` to indicate whether `func` should be invoked on the 24317 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked 24318 * with the last arguments provided to the debounced function. Subsequent 24319 * calls to the debounced function return the result of the last `func` 24320 * invocation. 24321 * 24322 * **Note:** If `leading` and `trailing` options are `true`, `func` is 24323 * invoked on the trailing edge of the timeout only if the debounced function 24324 * is invoked more than once during the `wait` timeout. 24325 * 24326 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred 24327 * until to the next tick, similar to `setTimeout` with a timeout of `0`. 24328 * 24329 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) 24330 * for details over the differences between `_.debounce` and `_.throttle`. 24331 * 24332 * @static 24333 * @memberOf _ 24334 * @since 0.1.0 24335 * @category Function 24336 * @param {Function} func The function to debounce. 24337 * @param {number} [wait=0] The number of milliseconds to delay. 24338 * @param {Object} [options={}] The options object. 24339 * @param {boolean} [options.leading=false] 24340 * Specify invoking on the leading edge of the timeout. 24341 * @param {number} [options.maxWait] 24342 * The maximum time `func` is allowed to be delayed before it's invoked. 24343 * @param {boolean} [options.trailing=true] 24344 * Specify invoking on the trailing edge of the timeout. 24345 * @returns {Function} Returns the new debounced function. 24346 * @example 24347 * 24348 * // Avoid costly calculations while the window size is in flux. 24349 * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); 24350 * 24351 * // Invoke `sendMail` when clicked, debouncing subsequent calls. 24352 * jQuery(element).on('click', _.debounce(sendMail, 300, { 24353 * 'leading': true, 24354 * 'trailing': false 24355 * })); 24356 * 24357 * // Ensure `batchLog` is invoked once after 1 second of debounced calls. 24358 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); 24359 * var source = new EventSource('/stream'); 24360 * jQuery(source).on('message', debounced); 24361 * 24362 * // Cancel the trailing debounced invocation. 24363 * jQuery(window).on('popstate', debounced.cancel); 24364 */ 24365 24366function debounce(func, wait, options) { 24367 var lastArgs, 24368 lastThis, 24369 maxWait, 24370 result, 24371 timerId, 24372 lastCallTime, 24373 lastInvokeTime = 0, 24374 leading = false, 24375 maxing = false, 24376 trailing = true; 24377 24378 if (typeof func != 'function') { 24379 throw new TypeError(FUNC_ERROR_TEXT); 24380 } 24381 24382 wait = toNumber(wait) || 0; 24383 24384 if (isObject(options)) { 24385 leading = !!options.leading; 24386 maxing = 'maxWait' in options; 24387 maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; 24388 trailing = 'trailing' in options ? !!options.trailing : trailing; 24389 } 24390 24391 function invokeFunc(time) { 24392 var args = lastArgs, 24393 thisArg = lastThis; 24394 lastArgs = lastThis = undefined; 24395 lastInvokeTime = time; 24396 result = func.apply(thisArg, args); 24397 return result; 24398 } 24399 24400 function leadingEdge(time) { 24401 // Reset any `maxWait` timer. 24402 lastInvokeTime = time; // Start the timer for the trailing edge. 24403 24404 timerId = setTimeout(timerExpired, wait); // Invoke the leading edge. 24405 24406 return leading ? invokeFunc(time) : result; 24407 } 24408 24409 function remainingWait(time) { 24410 var timeSinceLastCall = time - lastCallTime, 24411 timeSinceLastInvoke = time - lastInvokeTime, 24412 timeWaiting = wait - timeSinceLastCall; 24413 return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting; 24414 } 24415 24416 function shouldInvoke(time) { 24417 var timeSinceLastCall = time - lastCallTime, 24418 timeSinceLastInvoke = time - lastInvokeTime; // Either this is the first call, activity has stopped and we're at the 24419 // trailing edge, the system time has gone backwards and we're treating 24420 // it as the trailing edge, or we've hit the `maxWait` limit. 24421 24422 return lastCallTime === undefined || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait; 24423 } 24424 24425 function timerExpired() { 24426 var time = now(); 24427 24428 if (shouldInvoke(time)) { 24429 return trailingEdge(time); 24430 } // Restart the timer. 24431 24432 24433 timerId = setTimeout(timerExpired, remainingWait(time)); 24434 } 24435 24436 function trailingEdge(time) { 24437 timerId = undefined; // Only invoke if we have `lastArgs` which means `func` has been 24438 // debounced at least once. 24439 24440 if (trailing && lastArgs) { 24441 return invokeFunc(time); 24442 } 24443 24444 lastArgs = lastThis = undefined; 24445 return result; 24446 } 24447 24448 function cancel() { 24449 if (timerId !== undefined) { 24450 clearTimeout(timerId); 24451 } 24452 24453 lastInvokeTime = 0; 24454 lastArgs = lastCallTime = lastThis = timerId = undefined; 24455 } 24456 24457 function flush() { 24458 return timerId === undefined ? result : trailingEdge(now()); 24459 } 24460 24461 function debounced() { 24462 var time = now(), 24463 isInvoking = shouldInvoke(time); 24464 lastArgs = arguments; 24465 lastThis = this; 24466 lastCallTime = time; 24467 24468 if (isInvoking) { 24469 if (timerId === undefined) { 24470 return leadingEdge(lastCallTime); 24471 } 24472 24473 if (maxing) { 24474 // Handle invocations in a tight loop. 24475 clearTimeout(timerId); 24476 timerId = setTimeout(timerExpired, wait); 24477 return invokeFunc(lastCallTime); 24478 } 24479 } 24480 24481 if (timerId === undefined) { 24482 timerId = setTimeout(timerExpired, wait); 24483 } 24484 24485 return result; 24486 } 24487 24488 debounced.cancel = cancel; 24489 debounced.flush = flush; 24490 return debounced; 24491} 24492 24493module.exports = debounce; 24494 24495/***/ }), 24496 24497/***/ 6245: 24498/***/ ((module) => { 24499 24500function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 24501 24502/** 24503 * Checks if `value` is the 24504 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) 24505 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) 24506 * 24507 * @static 24508 * @memberOf _ 24509 * @since 0.1.0 24510 * @category Lang 24511 * @param {*} value The value to check. 24512 * @returns {boolean} Returns `true` if `value` is an object, else `false`. 24513 * @example 24514 * 24515 * _.isObject({}); 24516 * // => true 24517 * 24518 * _.isObject([1, 2, 3]); 24519 * // => true 24520 * 24521 * _.isObject(_.noop); 24522 * // => true 24523 * 24524 * _.isObject(null); 24525 * // => false 24526 */ 24527function isObject(value) { 24528 var type = _typeof(value); 24529 24530 return value != null && (type == 'object' || type == 'function'); 24531} 24532 24533module.exports = isObject; 24534 24535/***/ }), 24536 24537/***/ 9282: 24538/***/ ((module) => { 24539 24540function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 24541 24542/** 24543 * Checks if `value` is object-like. A value is object-like if it's not `null` 24544 * and has a `typeof` result of "object". 24545 * 24546 * @static 24547 * @memberOf _ 24548 * @since 4.0.0 24549 * @category Lang 24550 * @param {*} value The value to check. 24551 * @returns {boolean} Returns `true` if `value` is object-like, else `false`. 24552 * @example 24553 * 24554 * _.isObjectLike({}); 24555 * // => true 24556 * 24557 * _.isObjectLike([1, 2, 3]); 24558 * // => true 24559 * 24560 * _.isObjectLike(_.noop); 24561 * // => false 24562 * 24563 * _.isObjectLike(null); 24564 * // => false 24565 */ 24566function isObjectLike(value) { 24567 return value != null && _typeof(value) == 'object'; 24568} 24569 24570module.exports = isObjectLike; 24571 24572/***/ }), 24573 24574/***/ 5794: 24575/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24576 24577function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 24578 24579var baseGetTag = __webpack_require__(6192), 24580 isObjectLike = __webpack_require__(9282); 24581/** `Object#toString` result references. */ 24582 24583 24584var symbolTag = '[object Symbol]'; 24585/** 24586 * Checks if `value` is classified as a `Symbol` primitive or object. 24587 * 24588 * @static 24589 * @memberOf _ 24590 * @since 4.0.0 24591 * @category Lang 24592 * @param {*} value The value to check. 24593 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. 24594 * @example 24595 * 24596 * _.isSymbol(Symbol.iterator); 24597 * // => true 24598 * 24599 * _.isSymbol('abc'); 24600 * // => false 24601 */ 24602 24603function isSymbol(value) { 24604 return _typeof(value) == 'symbol' || isObjectLike(value) && baseGetTag(value) == symbolTag; 24605} 24606 24607module.exports = isSymbol; 24608 24609/***/ }), 24610 24611/***/ 6100:
24612/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24613 24614var root = __webpack_require__(3269); 24615/** 24616 * Gets the timestamp of the number of milliseconds that have elapsed since 24617 * the Unix epoch (1 January 1970 00:00:00 UTC). 24618 * 24619 * @static 24620 * @memberOf _ 24621 * @since 2.4.0 24622 * @category Date 24623 * @returns {number} Returns the timestamp. 24624 * @example 24625 * 24626 * _.defer(function(stamp) { 24627 * console.log(_.now() - stamp); 24628 * }, _.now()); 24629 * // => Logs the number of milliseconds it took for the deferred invocation. 24630 */ 24631 24632 24633var now = function now() { 24634 return root.Date.now(); 24635}; 24636 24637module.exports = now; 24638 24639/***/ }), 24640 24641/***/ 3766: 24642/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24643 24644var baseTrim = __webpack_require__(2728), 24645 isObject = __webpack_require__(6245), 24646 isSymbol = __webpack_require__(5794); 24647/** Used as references for various `Number` constants. */ 24648 24649 24650var NAN = 0 / 0; 24651/** Used to detect bad signed hexadecimal string values. */ 24652 24653var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; 24654/** Used to detect binary string values. */ 24655 24656var reIsBinary = /^0b[01]+$/i; 24657/** Used to detect octal string values. */ 24658 24659var reIsOctal = /^0o[0-7]+$/i; 24660/** Built-in method references without a dependency on `root`. */ 24661 24662var freeParseInt = parseInt; 24663/** 24664 * Converts `value` to a number. 24665 * 24666 * @static 24667 * @memberOf _ 24668 * @since 4.0.0 24669 * @category Lang 24670 * @param {*} value The value to process. 24671 * @returns {number} Returns the number. 24672 * @example 24673 * 24674 * _.toNumber(3.2); 24675 * // => 3.2 24676 * 24677 * _.toNumber(Number.MIN_VALUE); 24678 * // => 5e-324 24679 * 24680 * _.toNumber(Infinity); 24681 * // => Infinity 24682 * 24683 * _.toNumber('3.2'); 24684 * // => 3.2 24685 */ 24686 24687function toNumber(value) { 24688 if (typeof value == 'number') { 24689 return value; 24690 } 24691 24692 if (isSymbol(value)) { 24693 return NAN; 24694 } 24695 24696 if (isObject(value)) { 24697 var other = typeof value.valueOf == 'function' ? value.valueOf() : value; 24698 value = isObject(other) ? other + '' : other; 24699 } 24700 24701 if (typeof value != 'string') { 24702 return value === 0 ? value : +value; 24703 } 24704 24705 value = baseTrim(value); 24706 var isBinary = reIsBinary.test(value); 24707 return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value; 24708} 24709 24710module.exports = toNumber; 24711 24712/***/ }), 24713 24714/***/ 4986: 24715/***/ ((module, exports, __webpack_require__) => { 24716 24717var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 24718 24719/*! 24720 * Select2 4.0.13 24721 * https://select2.github.io 24722 * 24723 * Released under the MIT license 24724 * https://github.com/select2/select2/blob/master/LICENSE.md 24725 */ 24726; 24727 24728(function (factory) { 24729 if (true) { 24730 // AMD. Register as an anonymous module. 24731 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(4540)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 24732 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 24733 (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), 24734 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 24735 } else {} 24736})(function (jQuery) { 24737 // This is needed so we can catch the AMD loader configuration and use it 24738 // The inner file should be wrapped (by `banner.start.js`) in a function that 24739 // returns the AMD loader references. 24740 var S2 = function () { 24741 // Restore the Select2 AMD loader so it can be used 24742 // Needed mostly in the language files, where the loader is not inserted 24743 if (jQuery && jQuery.fn && jQuery.fn.select2 && jQuery.fn.select2.amd) { 24744 var S2 = jQuery.fn.select2.amd; 24745 } 24746 24747 var S2; 24748 24749 (function () { 24750 if (!S2 || !S2.requirejs) { 24751 if (!S2) { 24752 S2 = {}; 24753 } else { 24754 require = S2; 24755 } 24756 /** 24757 * @license almond 0.3.3 Copyright jQuery Foundation and other contributors. 24758 * Released under MIT license, http://github.com/requirejs/almond/LICENSE 24759 */ 24760 //Going sloppy to avoid 'use strict' string cost, but strict practices should 24761 //be followed. 24762 24763 /*global setTimeout: false */ 24764 24765 24766 var requirejs, require, define; 24767 24768 (function (undef) { 24769 var main, 24770 _req, 24771 makeMap, 24772 handlers, 24773 defined = {}, 24774 waiting = {}, 24775 config = {}, 24776 defining = {}, 24777 hasOwn = Object.prototype.hasOwnProperty, 24778 aps = [].slice, 24779 jsSuffixRegExp = /\.js$/; 24780 24781 function hasProp(obj, prop) { 24782 return hasOwn.call(obj, prop); 24783 } 24784 /** 24785 * Given a relative module name, like ./something, normalize it to 24786 * a real name that can be mapped to a path. 24787 * @param {String} name the relative name 24788 * @param {String} baseName a real name that the name arg is relative 24789 * to. 24790 * @returns {String} normalized name 24791 */ 24792 24793 24794 function normalize(name, baseName) { 24795 var nameParts, 24796 nameSegment, 24797 mapValue, 24798 foundMap, 24799 lastIndex, 24800 foundI, 24801 foundStarMap, 24802 starI, 24803 i, 24804 j, 24805 part, 24806 normalizedBaseParts, 24807 baseParts = baseName && baseName.split("/"), 24808 map = config.map, 24809 starMap = map && map['*'] || {}; //Adjust any relative paths. 24810 24811 if (name) { 24812 name = name.split('/'); 24813 lastIndex = name.length - 1; // If wanting node ID compatibility, strip .js from end 24814 // of IDs. Have to do this here, and not in nameToUrl 24815 // because node allows either .js or non .js to map 24816 // to same file. 24817 24818 if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) { 24819 name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, ''); 24820 } // Starts with a '.' so need the baseName 24821 24822 24823 if (name[0].charAt(0) === '.' && baseParts) { 24824 //Convert baseName to array, and lop off the last part, 24825 //so that . matches that 'directory' and not name of the baseName's 24826 //module. For instance, baseName of 'one/two/three', maps to 24827 //'one/two/three.js', but we want the directory, 'one/two' for 24828 //this normalization. 24829 normalizedBaseParts = baseParts.slice(0, baseParts.length - 1); 24830 name = normalizedBaseParts.concat(name); 24831 } //start trimDots 24832 24833 24834 for (i = 0; i < name.length; i++) { 24835 part = name[i]; 24836 24837 if (part === '.') { 24838 name.splice(i, 1); 24839 i -= 1; 24840 } else if (part === '..') { 24841 // If at the start, or previous value is still .., 24842 // keep them so that when converted to a path it may 24843 // still work when converted to a path, even though 24844 // as an ID it is less than ideal. In larger point 24845 // releases, may be better to just kick out an error. 24846 if (i === 0 || i === 1 && name[2] === '..' || name[i - 1] === '..') { 24847 continue; 24848 } else if (i > 0) { 24849 name.splice(i - 1, 2); 24850 i -= 2; 24851 } 24852 } 24853 } //end trimDots 24854 24855 24856 name = name.join('/'); 24857 } //Apply map config if available. 24858 24859 24860 if ((baseParts || starMap) && map) {
vendor: 9,627 bytes, lines 24861-25130
24861 nameParts = name.split('/'); 24862 24863 for (i = nameParts.length; i > 0; i -= 1) { 24864 nameSegment = nameParts.slice(0, i).join("/"); 24865 24866 if (baseParts) { 24867 //Find the longest baseName segment match in the config. 24868 //So, do joins on the biggest to smallest lengths of baseParts. 24869 for (j = baseParts.length; j > 0; j -= 1) { 24870 mapValue = map[baseParts.slice(0, j).join('/')]; //baseName segment has config, find if it has one for 24871 //this name. 24872 24873 if (mapValue) { 24874 mapValue = mapValue[nameSegment]; 24875 24876 if (mapValue) { 24877 //Match, update name to the new value. 24878 foundMap = mapValue; 24879 foundI = i; 24880 break; 24881 } 24882 } 24883 } 24884 } 24885 24886 if (foundMap) { 24887 break; 24888 } //Check for a star map match, but just hold on to it, 24889 //if there is a shorter segment match later in a matching 24890 //config, then favor over this star map. 24891 24892 24893 if (!foundStarMap && starMap && starMap[nameSegment]) { 24894 foundStarMap = starMap[nameSegment]; 24895 starI = i; 24896 } 24897 } 24898 24899 if (!foundMap && foundStarMap) { 24900 foundMap = foundStarMap; 24901 foundI = starI; 24902 } 24903 24904 if (foundMap) { 24905 nameParts.splice(0, foundI, foundMap); 24906 name = nameParts.join('/'); 24907 } 24908 } 24909 24910 return name; 24911 } 24912 24913 function makeRequire(relName, forceSync) { 24914 return function () { 24915 //A version of a require function that passes a moduleName 24916 //value for items that may need to 24917 //look up paths relative to the moduleName 24918 var args = aps.call(arguments, 0); //If first arg is not require('string'), and there is only 24919 //one arg, it is the array form without a callback. Insert 24920 //a null so that the following concat is correct. 24921 24922 if (typeof args[0] !== 'string' && args.length === 1) { 24923 args.push(null); 24924 } 24925 24926 return _req.apply(undef, args.concat([relName, forceSync])); 24927 }; 24928 } 24929 24930 function makeNormalize(relName) { 24931 return function (name) { 24932 return normalize(name, relName); 24933 }; 24934 } 24935 24936 function makeLoad(depName) { 24937 return function (value) { 24938 defined[depName] = value; 24939 }; 24940 } 24941 24942 function callDep(name) { 24943 if (hasProp(waiting, name)) { 24944 var args = waiting[name]; 24945 delete waiting[name]; 24946 defining[name] = true; 24947 main.apply(undef, args); 24948 } 24949 24950 if (!hasProp(defined, name) && !hasProp(defining, name)) { 24951 throw new Error('No ' + name); 24952 } 24953 24954 return defined[name]; 24955 } //Turns a plugin!resource to [plugin, resource] 24956 //with the plugin being undefined if the name 24957 //did not have a plugin prefix. 24958 24959 24960 function splitPrefix(name) { 24961 var prefix, 24962 index = name ? name.indexOf('!') : -1; 24963 24964 if (index > -1) { 24965 prefix = name.substring(0, index); 24966 name = name.substring(index + 1, name.length); 24967 } 24968 24969 return [prefix, name]; 24970 } //Creates a parts array for a relName where first part is plugin ID, 24971 //second part is resource ID. Assumes relName has already been normalized. 24972 24973 24974 function makeRelParts(relName) { 24975 return relName ? splitPrefix(relName) : []; 24976 } 24977 /** 24978 * Makes a name map, normalizing the name, and using a plugin 24979 * for normalization if necessary. Grabs a ref to plugin 24980 * too, as an optimization. 24981 */ 24982 24983 24984 makeMap = function makeMap(name, relParts) { 24985 var plugin, 24986 parts = splitPrefix(name), 24987 prefix = parts[0], 24988 relResourceName = relParts[1]; 24989 name = parts[1]; 24990 24991 if (prefix) { 24992 prefix = normalize(prefix, relResourceName); 24993 plugin = callDep(prefix); 24994 } //Normalize according 24995 24996 24997 if (prefix) { 24998 if (plugin && plugin.normalize) { 24999 name = plugin.normalize(name, makeNormalize(relResourceName)); 25000 } else { 25001 name = normalize(name, relResourceName); 25002 } 25003 } else { 25004 name = normalize(name, relResourceName); 25005 parts = splitPrefix(name); 25006 prefix = parts[0]; 25007 name = parts[1]; 25008 25009 if (prefix) { 25010 plugin = callDep(prefix); 25011 } 25012 } //Using ridiculous property names for space reasons 25013 25014 25015 return { 25016 f: prefix ? prefix + '!' + name : name, 25017 //fullName 25018 n: name, 25019 pr: prefix, 25020 p: plugin 25021 }; 25022 }; 25023 25024 function makeConfig(name) { 25025 return function () { 25026 return config && config.config && config.config[name] || {}; 25027 }; 25028 } 25029 25030 handlers = { 25031 require: function require(name) { 25032 return makeRequire(name); 25033 }, 25034 exports: function exports(name) { 25035 var e = defined[name]; 25036 25037 if (typeof e !== 'undefined') { 25038 return e; 25039 } else { 25040 return defined[name] = {}; 25041 } 25042 }, 25043 module: function module(name) { 25044 return { 25045 id: name, 25046 uri: '', 25047 exports: defined[name], 25048 config: makeConfig(name) 25049 }; 25050 } 25051 }; 25052 25053 main = function main(name, deps, callback, relName) { 25054 var cjsModule, 25055 depName, 25056 ret, 25057 map, 25058 i, 25059 relParts, 25060 args = [], 25061 callbackType = _typeof(callback), 25062 usingExports; //Use name if no relName 25063 25064 25065 relName = relName || name; 25066 relParts = makeRelParts(relName); //Call the callback to define the module, if necessary. 25067 25068 if (callbackType === 'undefined' || callbackType === 'function') { 25069 //Pull out the defined dependencies and pass the ordered 25070 //values to the callback. 25071 //Default to [require, exports, module] if no deps 25072 deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps; 25073 25074 for (i = 0; i < deps.length; i += 1) { 25075 map = makeMap(deps[i], relParts); 25076 depName = map.f; //Fast path CommonJS standard dependencies. 25077 25078 if (depName === "require") { 25079 args[i] = handlers.require(name); 25080 } else if (depName === "exports") { 25081 //CommonJS module spec 1.1 25082 args[i] = handlers.exports(name); 25083 usingExports = true; 25084 } else if (depName === "module") { 25085 //CommonJS module spec 1.1 25086 cjsModule = args[i] = handlers.module(name); 25087 } else if (hasProp(defined, depName) || hasProp(waiting, depName) || hasProp(defining, depName)) { 25088 args[i] = callDep(depName); 25089 } else if (map.p) { 25090 map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {}); 25091 args[i] = defined[depName]; 25092 } else { 25093 throw new Error(name + ' missing ' + depName); 25094 } 25095 } 25096 25097 ret = callback ? callback.apply(defined[name], args) : undefined; 25098 25099 if (name) { 25100 //If setting exports via "module" is in play, 25101 //favor that over return value and exports. After that, 25102 //favor a non-undefined return value over exports use. 25103 if (cjsModule && cjsModule.exports !== undef && cjsModule.exports !== defined[name]) { 25104 defined[name] = cjsModule.exports; 25105 } else if (ret !== undef || !usingExports) { 25106 //Use the return value from the function. 25107 defined[name] = ret; 25108 } 25109 } 25110 } else if (name) { 25111 //May just be an object definition for the module. Only 25112 //worry about defining if have a module name. 25113 defined[name] = callback; 25114 } 25115 }; 25116 25117 requirejs = require = _req = function req(deps, callback, relName, forceSync, alt) { 25118 if (typeof deps === "string") { 25119 if (handlers[deps]) { 25120 //callback in this case is really relName 25121 return handlers[deps](callback); 25122 } //Just return the module wanted. In this scenario, the 25123 //deps arg is the module name, and second arg (if passed) 25124 //is just the relName. 25125 //Normalize module name, if it contains . or .. 25126 25127 25128 return callDep(makeMap(deps, makeRelParts(callback)).f); 25129 } else if (!deps.splice) { 25130 //deps is a config object, not an array.
vendor: 9,009 bytes, lines 25131-25433
25131 config = deps; 25132 25133 if (config.deps) { 25134 _req(config.deps, config.callback); 25135 } 25136 25137 if (!callback) { 25138 return; 25139 } 25140 25141 if (callback.splice) { 25142 //callback is an array, which means it is a dependency list. 25143 //Adjust args if there are dependencies 25144 deps = callback; 25145 callback = relName; 25146 relName = null; 25147 } else { 25148 deps = undef; 25149 } 25150 } //Support require(['a']) 25151 25152 25153 callback = callback || function () {}; //If relName is a function, it is an errback handler, 25154 //so remove it. 25155 25156 25157 if (typeof relName === 'function') { 25158 relName = forceSync; 25159 forceSync = alt; 25160 } //Simulate async callback; 25161 25162 25163 if (forceSync) { 25164 main(undef, deps, callback, relName); 25165 } else { 25166 //Using a non-zero value because of concern for what old browsers 25167 //do, and latest browsers "upgrade" to 4 if lower value is used: 25168 //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout: 25169 //If want a value immediately, use require('id') instead -- something 25170 //that works in almond on the global level, but not guaranteed and 25171 //unlikely to work in other AMD implementations. 25172 setTimeout(function () { 25173 main(undef, deps, callback, relName); 25174 }, 4); 25175 } 25176 25177 return _req; 25178 }; 25179 /** 25180 * Just drops the config on the floor, but returns req in case 25181 * the config return value is used. 25182 */ 25183 25184 25185 _req.config = function (cfg) { 25186 return _req(cfg); 25187 }; 25188 /** 25189 * Expose module registry for debugging and tooling 25190 */ 25191 25192 25193 requirejs._defined = defined; 25194 25195 define = function define(name, deps, callback) { 25196 if (typeof name !== 'string') { 25197 throw new Error('See almond README: incorrect module build, no module name'); 25198 } //This module may not have dependencies 25199 25200 25201 if (!deps.splice) { 25202 //deps is not an array, so probably means 25203 //an object literal or factory function for 25204 //the value. Adjust args. 25205 callback = deps; 25206 deps = []; 25207 } 25208 25209 if (!hasProp(defined, name) && !hasProp(waiting, name)) { 25210 waiting[name] = [name, deps, callback]; 25211 } 25212 }; 25213 25214 define.amd = { 25215 jQuery: true 25216 }; 25217 })(); 25218 25219 S2.requirejs = requirejs; 25220 S2.require = require; 25221 S2.define = define; 25222 } 25223 })(); 25224 25225 S2.define("almond", function () {}); 25226 /* global jQuery:false, $:false */ 25227 25228 S2.define('jquery', [], function () { 25229 var _$ = jQuery || $; 25230 25231 if (_$ == null && console && console.error) { 25232 console.error('Select2: An instance of jQuery or a jQuery-compatible library was not ' + 'found. Make sure that you are including jQuery before Select2 on your ' + 'web page.'); 25233 } 25234 25235 return _$; 25236 }); 25237 S2.define('select2/utils', ['jquery'], function ($) { 25238 var Utils = {}; 25239 25240 Utils.Extend = function (ChildClass, SuperClass) { 25241 var __hasProp = {}.hasOwnProperty; 25242 25243 function BaseConstructor() { 25244 this.constructor = ChildClass; 25245 } 25246 25247 for (var key in SuperClass) { 25248 if (__hasProp.call(SuperClass, key)) { 25249 ChildClass[key] = SuperClass[key]; 25250 } 25251 } 25252 25253 BaseConstructor.prototype = SuperClass.prototype; 25254 ChildClass.prototype = new BaseConstructor(); 25255 ChildClass.__super__ = SuperClass.prototype; 25256 return ChildClass; 25257 }; 25258 25259 function getMethods(theClass) { 25260 var proto = theClass.prototype; 25261 var methods = []; 25262 25263 for (var methodName in proto) { 25264 var m = proto[methodName]; 25265 25266 if (typeof m !== 'function') { 25267 continue; 25268 } 25269 25270 if (methodName === 'constructor') { 25271 continue; 25272 } 25273 25274 methods.push(methodName); 25275 } 25276 25277 return methods; 25278 } 25279 25280 Utils.Decorate = function (SuperClass, DecoratorClass) { 25281 var decoratedMethods = getMethods(DecoratorClass); 25282 var superMethods = getMethods(SuperClass); 25283 25284 function DecoratedClass() { 25285 var unshift = Array.prototype.unshift; 25286 var argCount = DecoratorClass.prototype.constructor.length; 25287 var calledConstructor = SuperClass.prototype.constructor; 25288 25289 if (argCount > 0) { 25290 unshift.call(arguments, SuperClass.prototype.constructor); 25291 calledConstructor = DecoratorClass.prototype.constructor; 25292 } 25293 25294 calledConstructor.apply(this, arguments); 25295 } 25296 25297 DecoratorClass.displayName = SuperClass.displayName; 25298 25299 function ctr() { 25300 this.constructor = DecoratedClass; 25301 } 25302 25303 DecoratedClass.prototype = new ctr(); 25304 25305 for (var m = 0; m < superMethods.length; m++) { 25306 var superMethod = superMethods[m]; 25307 DecoratedClass.prototype[superMethod] = SuperClass.prototype[superMethod]; 25308 } 25309 25310 var calledMethod = function calledMethod(methodName) { 25311 // Stub out the original method if it's not decorating an actual method 25312 var originalMethod = function originalMethod() {}; 25313 25314 if (methodName in DecoratedClass.prototype) { 25315 originalMethod = DecoratedClass.prototype[methodName]; 25316 } 25317 25318 var decoratedMethod = DecoratorClass.prototype[methodName]; 25319 return function () { 25320 var unshift = Array.prototype.unshift; 25321 unshift.call(arguments, originalMethod); 25322 return decoratedMethod.apply(this, arguments); 25323 }; 25324 }; 25325 25326 for (var d = 0; d < decoratedMethods.length; d++) { 25327 var decoratedMethod = decoratedMethods[d]; 25328 DecoratedClass.prototype[decoratedMethod] = calledMethod(decoratedMethod); 25329 } 25330 25331 return DecoratedClass; 25332 }; 25333 25334 var Observable = function Observable() { 25335 this.listeners = {}; 25336 }; 25337 25338 Observable.prototype.on = function (event, callback) { 25339 this.listeners = this.listeners || {}; 25340 25341 if (event in this.listeners) { 25342 this.listeners[event].push(callback); 25343 } else { 25344 this.listeners[event] = [callback]; 25345 } 25346 }; 25347 25348 Observable.prototype.trigger = function (event) { 25349 var slice = Array.prototype.slice; 25350 var params = slice.call(arguments, 1); 25351 this.listeners = this.listeners || {}; // Params should always come in as an array 25352 25353 if (params == null) { 25354 params = []; 25355 } // If there are no arguments to the event, use a temporary object 25356 25357 25358 if (params.length === 0) { 25359 params.push({}); 25360 } // Set the `_type` of the first object to the event 25361 25362 25363 params[0]._type = event; 25364 25365 if (event in this.listeners) { 25366 this.invoke(this.listeners[event], slice.call(arguments, 1)); 25367 } 25368 25369 if ('*' in this.listeners) { 25370 this.invoke(this.listeners['*'], arguments); 25371 } 25372 }; 25373 25374 Observable.prototype.invoke = function (listeners, params) { 25375 for (var i = 0, len = listeners.length; i < len; i++) { 25376 listeners[i].apply(this, params); 25377 } 25378 }; 25379 25380 Utils.Observable = Observable; 25381 25382 Utils.generateChars = function (length) { 25383 var chars = ''; 25384 25385 for (var i = 0; i < length; i++) { 25386 var randomChar = Math.floor(Math.random() * 36); 25387 chars += randomChar.toString(36); 25388 } 25389 25390 return chars; 25391 }; 25392 25393 Utils.bind = function (func, context) { 25394 return function () { 25395 func.apply(context, arguments); 25396 }; 25397 }; 25398 25399 Utils._convertData = function (data) { 25400 for (var originalKey in data) { 25401 var keys = originalKey.split('-'); 25402 var dataLevel = data; 25403 25404 if (keys.length === 1) { 25405 continue; 25406 } 25407 25408 for (var k = 0; k < keys.length; k++) { 25409 var key = keys[k]; // Lowercase the first letter 25410 // By default, dash-separated becomes camelCase 25411 25412 key = key.substring(0, 1).toLowerCase() + key.substring(1); 25413 25414 if (!(key in dataLevel)) { 25415 dataLevel[key] = {}; 25416 } 25417 25418 if (k == keys.length - 1) { 25419 dataLevel[key] = data[originalKey]; 25420 } 25421 25422 dataLevel = dataLevel[key]; 25423 } 25424 25425 delete data[originalKey]; 25426 } 25427 25428 return data; 25429 }; 25430 25431 Utils.hasScroll = function (index, el) { 25432 // Adapted from the function created by @ShadowScripter 25433 // and adapted by @BillBarry on the Stack Exchange Code Review website.
25434 // The original code can be found at 25435 // http://codereview.stackexchange.com/q/13338 25436 // and was designed to be used with the Sizzle selector engine. 25437 var $el = $(el); 25438 var overflowX = el.style.overflowX; 25439 var overflowY = el.style.overflowY; //Check both x and y declarations 25440 25441 if (overflowX === overflowY && (overflowY === 'hidden' || overflowY === 'visible')) { 25442 return false; 25443 } 25444 25445 if (overflowX === 'scroll' || overflowY === 'scroll') { 25446 return true; 25447 } 25448 25449 return $el.innerHeight() < el.scrollHeight || $el.innerWidth() < el.scrollWidth; 25450 }; 25451 25452 Utils.escapeMarkup = function (markup) { 25453 var replaceMap = { 25454 '\\': '\', 25455 '&': '&', 25456 '<': '<', 25457 '>': '>', 25458 '"': '"', 25459 '\'': ''', 25460 '/': '/' 25461 }; // Do not try to escape the markup if it's not a string 25462 25463 if (typeof markup !== 'string') { 25464 return markup; 25465 } 25466 25467 return String(markup).replace(/[&<>"'\/\\]/g, function (match) { 25468 return replaceMap[match]; 25469 }); 25470 }; // Append an array of jQuery nodes to a given element. 25471 25472 25473 Utils.appendMany = function ($element, $nodes) { 25474 // jQuery 1.7.x does not support $.fn.append() with an array 25475 // Fall back to a jQuery object collection using $.fn.add() 25476 if ($.fn.jquery.substr(0, 3) === '1.7') { 25477 var $jqNodes = $(); 25478 $.map($nodes, function (node) { 25479 $jqNodes = $jqNodes.add(node); 25480 }); 25481 $nodes = $jqNodes; 25482 } 25483 25484 $element.append($nodes); 25485 }; // Cache objects in Utils.__cache instead of $.data (see #4346) 25486 25487 25488 Utils.__cache = {}; 25489 var id = 0; 25490 25491 Utils.GetUniqueElementId = function (element) { 25492 // Get a unique element Id. If element has no id, 25493 // creates a new unique number, stores it in the id 25494 // attribute and returns the new id. 25495 // If an id already exists, it simply returns it. 25496 var select2Id = element.getAttribute('data-select2-id'); 25497 25498 if (select2Id == null) { 25499 // If element has id, use it. 25500 if (element.id) { 25501 select2Id = element.id; 25502 element.setAttribute('data-select2-id', select2Id); 25503 } else { 25504 element.setAttribute('data-select2-id', ++id); 25505 select2Id = id.toString(); 25506 } 25507 } 25508 25509 return select2Id; 25510 }; 25511 25512 Utils.StoreData = function (element, name, value) { 25513 // Stores an item in the cache for a specified element. 25514 // name is the cache key. 25515 var id = Utils.GetUniqueElementId(element); 25516 25517 if (!Utils.__cache[id]) { 25518 Utils.__cache[id] = {}; 25519 } 25520 25521 Utils.__cache[id][name] = value; 25522 }; 25523 25524 Utils.GetData = function (element, name) { 25525 // Retrieves a value from the cache by its key (name) 25526 // name is optional. If no name specified, return 25527 // all cache items for the specified element. 25528 // and for a specified element. 25529 var id = Utils.GetUniqueElementId(element); 25530 25531 if (name) { 25532 if (Utils.__cache[id]) { 25533 if (Utils.__cache[id][name] != null) { 25534 return Utils.__cache[id][name]; 25535 } 25536 25537 return $(element).data(name); // Fallback to HTML5 data attribs. 25538 } 25539 25540 return $(element).data(name); // Fallback to HTML5 data attribs. 25541 } else { 25542 return Utils.__cache[id]; 25543 } 25544 }; 25545 25546 Utils.RemoveData = function (element) { 25547 // Removes all cached items for a specified element. 25548 var id = Utils.GetUniqueElementId(element); 25549 25550 if (Utils.__cache[id] != null) { 25551 delete Utils.__cache[id]; 25552 } 25553 25554 element.removeAttribute('data-select2-id'); 25555 }; 25556 25557 return Utils; 25558 }); 25559 S2.define('select2/results', ['jquery', './utils'], function ($, Utils) { 25560 function Results($element, options, dataAdapter) { 25561 this.$element = $element; 25562 this.data = dataAdapter; 25563 this.options = options; 25564 25565 Results.__super__.constructor.call(this); 25566 } 25567 25568 Utils.Extend(Results, Utils.Observable); 25569 25570 Results.prototype.render = function () { 25571 var $results = $('<ul class="select2-results__options" role="listbox"></ul>'); 25572 25573 if (this.options.get('multiple')) { 25574 $results.attr('aria-multiselectable', 'true'); 25575 } 25576 25577 this.$results = $results; 25578 return $results; 25579 }; 25580 25581 Results.prototype.clear = function () { 25582 this.$results.empty(); 25583 }; 25584 25585 Results.prototype.displayMessage = function (params) { 25586 var escapeMarkup = this.options.get('escapeMarkup'); 25587 this.clear(); 25588 this.hideLoading(); 25589 var $message = $('<li role="alert" aria-live="assertive"' + ' class="select2-results__option"></li>'); 25590 var message = this.options.get('translations').get(params.message); 25591 $message.append(escapeMarkup(message(params.args))); 25592 $message[0].className += ' select2-results__message';
vendor: 9,969 bytes, lines 25593-25893
25593 this.$results.append($message); 25594 }; 25595 25596 Results.prototype.hideMessages = function () { 25597 this.$results.find('.select2-results__message').remove(); 25598 }; 25599 25600 Results.prototype.append = function (data) { 25601 this.hideLoading(); 25602 var $options = []; 25603 25604 if (data.results == null || data.results.length === 0) { 25605 if (this.$results.children().length === 0) { 25606 this.trigger('results:message', { 25607 message: 'noResults' 25608 }); 25609 } 25610 25611 return; 25612 } 25613 25614 data.results = this.sort(data.results); 25615 25616 for (var d = 0; d < data.results.length; d++) { 25617 var item = data.results[d]; 25618 var $option = this.option(item); 25619 $options.push($option); 25620 } 25621 25622 this.$results.append($options); 25623 }; 25624 25625 Results.prototype.position = function ($results, $dropdown) { 25626 var $resultsContainer = $dropdown.find('.select2-results'); 25627 $resultsContainer.append($results); 25628 }; 25629 25630 Results.prototype.sort = function (data) { 25631 var sorter = this.options.get('sorter'); 25632 return sorter(data); 25633 }; 25634 25635 Results.prototype.highlightFirstItem = function () { 25636 var $options = this.$results.find('.select2-results__option[aria-selected]'); 25637 var $selected = $options.filter('[aria-selected=true]'); // Check if there are any selected options 25638 25639 if ($selected.length > 0) { 25640 // If there are selected options, highlight the first 25641 $selected.first().trigger('mouseenter'); 25642 } else { 25643 // If there are no selected options, highlight the first option 25644 // in the dropdown 25645 $options.first().trigger('mouseenter'); 25646 } 25647 25648 this.ensureHighlightVisible(); 25649 }; 25650 25651 Results.prototype.setClasses = function () { 25652 var self = this; 25653 this.data.current(function (selected) { 25654 var selectedIds = $.map(selected, function (s) { 25655 return s.id.toString(); 25656 }); 25657 var $options = self.$results.find('.select2-results__option[aria-selected]'); 25658 $options.each(function () { 25659 var $option = $(this); 25660 var item = Utils.GetData(this, 'data'); // id needs to be converted to a string when comparing 25661 25662 var id = '' + item.id; 25663 25664 if (item.element != null && item.element.selected || item.element == null && $.inArray(id, selectedIds) > -1) { 25665 $option.attr('aria-selected', 'true'); 25666 } else { 25667 $option.attr('aria-selected', 'false'); 25668 } 25669 }); 25670 }); 25671 }; 25672 25673 Results.prototype.showLoading = function (params) { 25674 this.hideLoading(); 25675 var loadingMore = this.options.get('translations').get('searching'); 25676 var loading = { 25677 disabled: true, 25678 loading: true, 25679 text: loadingMore(params) 25680 }; 25681 var $loading = this.option(loading); 25682 $loading.className += ' loading-results'; 25683 this.$results.prepend($loading); 25684 }; 25685 25686 Results.prototype.hideLoading = function () { 25687 this.$results.find('.loading-results').remove(); 25688 }; 25689 25690 Results.prototype.option = function (data) { 25691 var option = document.createElement('li'); 25692 option.className = 'select2-results__option'; 25693 var attrs = { 25694 'role': 'option', 25695 'aria-selected': 'false' 25696 }; 25697 var matches = window.Element.prototype.matches || window.Element.prototype.msMatchesSelector || window.Element.prototype.webkitMatchesSelector; 25698 25699 if (data.element != null && matches.call(data.element, ':disabled') || data.element == null && data.disabled) { 25700 delete attrs['aria-selected']; 25701 attrs['aria-disabled'] = 'true'; 25702 } 25703 25704 if (data.id == null) { 25705 delete attrs['aria-selected']; 25706 } 25707 25708 if (data._resultId != null) { 25709 option.id = data._resultId; 25710 } 25711 25712 if (data.title) { 25713 option.title = data.title; 25714 } 25715 25716 if (data.children) { 25717 attrs.role = 'group'; 25718 attrs['aria-label'] = data.text; 25719 delete attrs['aria-selected']; 25720 } 25721 25722 for (var attr in attrs) { 25723 var val = attrs[attr]; 25724 option.setAttribute(attr, val); 25725 } 25726 25727 if (data.children) { 25728 var $option = $(option); 25729 var label = document.createElement('strong'); 25730 label.className = 'select2-results__group'; 25731 var $label = $(label); 25732 this.template(data, label); 25733 var $children = []; 25734 25735 for (var c = 0; c < data.children.length; c++) { 25736 var child = data.children[c]; 25737 var $child = this.option(child); 25738 $children.push($child); 25739 } 25740 25741 var $childrenContainer = $('<ul></ul>', { 25742 'class': 'select2-results__options select2-results__options--nested' 25743 }); 25744 $childrenContainer.append($children); 25745 $option.append(label); 25746 $option.append($childrenContainer); 25747 } else { 25748 this.template(data, option); 25749 } 25750 25751 Utils.StoreData(option, 'data', data); 25752 return option; 25753 }; 25754 25755 Results.prototype.bind = function (container, $container) { 25756 var self = this; 25757 var id = container.id + '-results'; 25758 this.$results.attr('id', id); 25759 container.on('results:all', function (params) { 25760 self.clear(); 25761 self.append(params.data); 25762 25763 if (container.isOpen()) { 25764 self.setClasses(); 25765 self.highlightFirstItem(); 25766 } 25767 }); 25768 container.on('results:append', function (params) { 25769 self.append(params.data); 25770 25771 if (container.isOpen()) { 25772 self.setClasses(); 25773 } 25774 }); 25775 container.on('query', function (params) { 25776 self.hideMessages(); 25777 self.showLoading(params); 25778 }); 25779 container.on('select', function () { 25780 if (!container.isOpen()) { 25781 return; 25782 } 25783 25784 self.setClasses(); 25785 25786 if (self.options.get('scrollAfterSelect')) { 25787 self.highlightFirstItem(); 25788 } 25789 }); 25790 container.on('unselect', function () { 25791 if (!container.isOpen()) { 25792 return; 25793 } 25794 25795 self.setClasses(); 25796 25797 if (self.options.get('scrollAfterSelect')) { 25798 self.highlightFirstItem(); 25799 } 25800 }); 25801 container.on('open', function () { 25802 // When the dropdown is open, aria-expended="true" 25803 self.$results.attr('aria-expanded', 'true'); 25804 self.$results.attr('aria-hidden', 'false'); 25805 self.setClasses(); 25806 self.ensureHighlightVisible(); 25807 }); 25808 container.on('close', function () { 25809 // When the dropdown is closed, aria-expended="false" 25810 self.$results.attr('aria-expanded', 'false'); 25811 self.$results.attr('aria-hidden', 'true'); 25812 self.$results.removeAttr('aria-activedescendant'); 25813 }); 25814 container.on('results:toggle', function () { 25815 var $highlighted = self.getHighlightedResults(); 25816 25817 if ($highlighted.length === 0) { 25818 return; 25819 } 25820 25821 $highlighted.trigger('mouseup'); 25822 }); 25823 container.on('results:select', function () { 25824 var $highlighted = self.getHighlightedResults(); 25825 25826 if ($highlighted.length === 0) { 25827 return; 25828 } 25829 25830 var data = Utils.GetData($highlighted[0], 'data'); 25831 25832 if ($highlighted.attr('aria-selected') == 'true') { 25833 self.trigger('close', {}); 25834 } else { 25835 self.trigger('select', { 25836 data: data 25837 }); 25838 } 25839 }); 25840 container.on('results:previous', function () { 25841 var $highlighted = self.getHighlightedResults(); 25842 var $options = self.$results.find('[aria-selected]'); 25843 var currentIndex = $options.index($highlighted); // If we are already at the top, don't move further 25844 // If no options, currentIndex will be -1 25845 25846 if (currentIndex <= 0) { 25847 return; 25848 } 25849 25850 var nextIndex = currentIndex - 1; // If none are highlighted, highlight the first 25851 25852 if ($highlighted.length === 0) { 25853 nextIndex = 0; 25854 } 25855 25856 var $next = $options.eq(nextIndex); 25857 $next.trigger('mouseenter'); 25858 var currentOffset = self.$results.offset().top; 25859 var nextTop = $next.offset().top; 25860 var nextOffset = self.$results.scrollTop() + (nextTop - currentOffset); 25861 25862 if (nextIndex === 0) { 25863 self.$results.scrollTop(0); 25864 } else if (nextTop - currentOffset < 0) { 25865 self.$results.scrollTop(nextOffset); 25866 } 25867 }); 25868 container.on('results:next', function () { 25869 var $highlighted = self.getHighlightedResults(); 25870 var $options = self.$results.find('[aria-selected]'); 25871 var currentIndex = $options.index($highlighted); 25872 var nextIndex = currentIndex + 1; // If we are at the last option, stay there 25873 25874 if (nextIndex >= $options.length) { 25875 return; 25876 } 25877 25878 var $next = $options.eq(nextIndex); 25879 $next.trigger('mouseenter'); 25880 var currentOffset = self.$results.offset().top + self.$results.outerHeight(false); 25881 var nextBottom = $next.offset().top + $next.outerHeight(false); 25882 var nextOffset = self.$results.scrollTop() + nextBottom - currentOffset; 25883 25884 if (nextIndex === 0) { 25885 self.$results.scrollTop(0); 25886 } else if (nextBottom > currentOffset) { 25887 self.$results.scrollTop(nextOffset); 25888 } 25889 }); 25890 container.on('results:focus', function (params) { 25891 params.element.addClass('select2-results__option--highlighted'); 25892 }); 25893 container.on('results:message', function (params) {
vendor: 25,876 bytes, lines 25894-26623
25894 self.displayMessage(params); 25895 }); 25896 25897 if ($.fn.mousewheel) { 25898 this.$results.on('mousewheel', function (e) { 25899 var top = self.$results.scrollTop(); 25900 var bottom = self.$results.get(0).scrollHeight - top + e.deltaY; 25901 var isAtTop = e.deltaY > 0 && top - e.deltaY <= 0; 25902 var isAtBottom = e.deltaY < 0 && bottom <= self.$results.height(); 25903 25904 if (isAtTop) { 25905 self.$results.scrollTop(0); 25906 e.preventDefault(); 25907 e.stopPropagation(); 25908 } else if (isAtBottom) { 25909 self.$results.scrollTop(self.$results.get(0).scrollHeight - self.$results.height()); 25910 e.preventDefault(); 25911 e.stopPropagation(); 25912 } 25913 }); 25914 } 25915 25916 this.$results.on('mouseup', '.select2-results__option[aria-selected]', function (evt) { 25917 var $this = $(this); 25918 var data = Utils.GetData(this, 'data'); 25919 25920 if ($this.attr('aria-selected') === 'true') { 25921 if (self.options.get('multiple')) { 25922 self.trigger('unselect', { 25923 originalEvent: evt, 25924 data: data 25925 }); 25926 } else { 25927 self.trigger('close', {}); 25928 } 25929 25930 return; 25931 } 25932 25933 self.trigger('select', { 25934 originalEvent: evt, 25935 data: data 25936 }); 25937 }); 25938 this.$results.on('mouseenter', '.select2-results__option[aria-selected]', function (evt) { 25939 var data = Utils.GetData(this, 'data'); 25940 self.getHighlightedResults().removeClass('select2-results__option--highlighted'); 25941 self.trigger('results:focus', { 25942 data: data, 25943 element: $(this) 25944 }); 25945 }); 25946 }; 25947 25948 Results.prototype.getHighlightedResults = function () { 25949 var $highlighted = this.$results.find('.select2-results__option--highlighted'); 25950 return $highlighted; 25951 }; 25952 25953 Results.prototype.destroy = function () { 25954 this.$results.remove(); 25955 }; 25956 25957 Results.prototype.ensureHighlightVisible = function () { 25958 var $highlighted = this.getHighlightedResults(); 25959 25960 if ($highlighted.length === 0) { 25961 return; 25962 } 25963 25964 var $options = this.$results.find('[aria-selected]'); 25965 var currentIndex = $options.index($highlighted); 25966 var currentOffset = this.$results.offset().top; 25967 var nextTop = $highlighted.offset().top; 25968 var nextOffset = this.$results.scrollTop() + (nextTop - currentOffset); 25969 var offsetDelta = nextTop - currentOffset; 25970 nextOffset -= $highlighted.outerHeight(false) * 2; 25971 25972 if (currentIndex <= 2) { 25973 this.$results.scrollTop(0); 25974 } else if (offsetDelta > this.$results.outerHeight() || offsetDelta < 0) { 25975 this.$results.scrollTop(nextOffset); 25976 } 25977 }; 25978 25979 Results.prototype.template = function (result, container) { 25980 var template = this.options.get('templateResult'); 25981 var escapeMarkup = this.options.get('escapeMarkup'); 25982 var content = template(result, container); 25983 25984 if (content == null) { 25985 container.style.display = 'none'; 25986 } else if (typeof content === 'string') { 25987 container.innerHTML = escapeMarkup(content); 25988 } else { 25989 $(container).append(content); 25990 } 25991 }; 25992 25993 return Results; 25994 }); 25995 S2.define('select2/keys', [], function () { 25996 var KEYS = { 25997 BACKSPACE: 8, 25998 TAB: 9, 25999 ENTER: 13, 26000 SHIFT: 16, 26001 CTRL: 17, 26002 ALT: 18, 26003 ESC: 27, 26004 SPACE: 32, 26005 PAGE_UP: 33, 26006 PAGE_DOWN: 34, 26007 END: 35, 26008 HOME: 36, 26009 LEFT: 37, 26010 UP: 38, 26011 RIGHT: 39, 26012 DOWN: 40, 26013 DELETE: 46 26014 }; 26015 return KEYS; 26016 }); 26017 S2.define('select2/selection/base', ['jquery', '../utils', '../keys'], function ($, Utils, KEYS) { 26018 function BaseSelection($element, options) { 26019 this.$element = $element; 26020 this.options = options; 26021 26022 BaseSelection.__super__.constructor.call(this); 26023 } 26024 26025 Utils.Extend(BaseSelection, Utils.Observable); 26026 26027 BaseSelection.prototype.render = function () { 26028 var $selection = $('<span class="select2-selection" role="combobox" ' + ' aria-haspopup="true" aria-expanded="false">' + '</span>'); 26029 this._tabindex = 0; 26030 26031 if (Utils.GetData(this.$element[0], 'old-tabindex') != null) { 26032 this._tabindex = Utils.GetData(this.$element[0], 'old-tabindex'); 26033 } else if (this.$element.attr('tabindex') != null) { 26034 this._tabindex = this.$element.attr('tabindex'); 26035 } 26036 26037 $selection.attr('title', this.$element.attr('title')); 26038 $selection.attr('tabindex', this._tabindex); 26039 $selection.attr('aria-disabled', 'false'); 26040 this.$selection = $selection; 26041 return $selection; 26042 }; 26043 26044 BaseSelection.prototype.bind = function (container, $container) { 26045 var self = this; 26046 var resultsId = container.id + '-results'; 26047 this.container = container; 26048 this.$selection.on('focus', function (evt) { 26049 self.trigger('focus', evt); 26050 }); 26051 this.$selection.on('blur', function (evt) { 26052 self._handleBlur(evt); 26053 }); 26054 this.$selection.on('keydown', function (evt) { 26055 self.trigger('keypress', evt); 26056 26057 if (evt.which === KEYS.SPACE) { 26058 evt.preventDefault(); 26059 } 26060 }); 26061 container.on('results:focus', function (params) { 26062 self.$selection.attr('aria-activedescendant', params.data._resultId); 26063 }); 26064 container.on('selection:update', function (params) { 26065 self.update(params.data); 26066 }); 26067 container.on('open', function () { 26068 // When the dropdown is open, aria-expanded="true" 26069 self.$selection.attr('aria-expanded', 'true'); 26070 self.$selection.attr('aria-owns', resultsId); 26071 26072 self._attachCloseHandler(container); 26073 }); 26074 container.on('close', function () { 26075 // When the dropdown is closed, aria-expanded="false" 26076 self.$selection.attr('aria-expanded', 'false'); 26077 self.$selection.removeAttr('aria-activedescendant'); 26078 self.$selection.removeAttr('aria-owns'); 26079 self.$selection.trigger('focus'); 26080 26081 self._detachCloseHandler(container); 26082 }); 26083 container.on('enable', function () { 26084 self.$selection.attr('tabindex', self._tabindex); 26085 self.$selection.attr('aria-disabled', 'false'); 26086 }); 26087 container.on('disable', function () { 26088 self.$selection.attr('tabindex', '-1'); 26089 self.$selection.attr('aria-disabled', 'true'); 26090 }); 26091 }; 26092 26093 BaseSelection.prototype._handleBlur = function (evt) { 26094 var self = this; // This needs to be delayed as the active element is the body when the tab 26095 // key is pressed, possibly along with others. 26096 26097 window.setTimeout(function () { 26098 // Don't trigger `blur` if the focus is still in the selection 26099 if (document.activeElement == self.$selection[0] || $.contains(self.$selection[0], document.activeElement)) { 26100 return; 26101 } 26102 26103 self.trigger('blur', evt); 26104 }, 1); 26105 }; 26106 26107 BaseSelection.prototype._attachCloseHandler = function (container) { 26108 $(document.body).on('mousedown.select2.' + container.id, function (e) { 26109 var $target = $(e.target); 26110 var $select = $target.closest('.select2'); 26111 var $all = $('.select2.select2-container--open'); 26112 $all.each(function () { 26113 if (this == $select[0]) { 26114 return; 26115 } 26116 26117 var $element = Utils.GetData(this, 'element'); 26118 $element.select2('close'); 26119 }); 26120 }); 26121 }; 26122 26123 BaseSelection.prototype._detachCloseHandler = function (container) { 26124 $(document.body).off('mousedown.select2.' + container.id); 26125 }; 26126 26127 BaseSelection.prototype.position = function ($selection, $container) { 26128 var $selectionContainer = $container.find('.selection'); 26129 $selectionContainer.append($selection); 26130 }; 26131 26132 BaseSelection.prototype.destroy = function () { 26133 this._detachCloseHandler(this.container); 26134 }; 26135 26136 BaseSelection.prototype.update = function (data) { 26137 throw new Error('The `update` method must be defined in child classes.'); 26138 }; 26139 /** 26140 * Helper method to abstract the "enabled" (not "disabled") state of this 26141 * object. 26142 * 26143 * @return {true} if the instance is not disabled. 26144 * @return {false} if the instance is disabled. 26145 */ 26146 26147 26148 BaseSelection.prototype.isEnabled = function () { 26149 return !this.isDisabled(); 26150 }; 26151 /** 26152 * Helper method to abstract the "disabled" state of this object. 26153 * 26154 * @return {true} if the disabled option is true. 26155 * @return {false} if the disabled option is false. 26156 */ 26157 26158 26159 BaseSelection.prototype.isDisabled = function () { 26160 return this.options.get('disabled'); 26161 }; 26162 26163 return BaseSelection; 26164 }); 26165 S2.define('select2/selection/single', ['jquery', './base', '../utils', '../keys'], function ($, BaseSelection, Utils, KEYS) { 26166 function SingleSelection() { 26167 SingleSelection.__super__.constructor.apply(this, arguments); 26168 } 26169 26170 Utils.Extend(SingleSelection, BaseSelection); 26171 26172 SingleSelection.prototype.render = function () { 26173 var $selection = SingleSelection.__super__.render.call(this); 26174 26175 $selection.addClass('select2-selection--single'); 26176 $selection.html('<span class="select2-selection__rendered"></span>' + '<span class="select2-selection__arrow" role="presentation">' + '<b role="presentation"></b>' + '</span>'); 26177 return $selection; 26178 }; 26179 26180 SingleSelection.prototype.bind = function (container, $container) { 26181 var self = this; 26182 26183 SingleSelection.__super__.bind.apply(this, arguments); 26184 26185 var id = container.id + '-container'; 26186 this.$selection.find('.select2-selection__rendered').attr('id', id).attr('role', 'textbox').attr('aria-readonly', 'true'); 26187 this.$selection.attr('aria-labelledby', id); 26188 this.$selection.on('mousedown', function (evt) { 26189 // Only respond to left clicks 26190 if (evt.which !== 1) { 26191 return; 26192 } 26193 26194 self.trigger('toggle', { 26195 originalEvent: evt 26196 }); 26197 }); 26198 this.$selection.on('focus', function (evt) {// User focuses on the container 26199 }); 26200 this.$selection.on('blur', function (evt) {// User exits the container 26201 }); 26202 container.on('focus', function (evt) { 26203 if (!container.isOpen()) { 26204 self.$selection.trigger('focus'); 26205 } 26206 }); 26207 }; 26208 26209 SingleSelection.prototype.clear = function () { 26210 var $rendered = this.$selection.find('.select2-selection__rendered'); 26211 $rendered.empty(); 26212 $rendered.removeAttr('title'); // clear tooltip on empty 26213 }; 26214 26215 SingleSelection.prototype.display = function (data, container) { 26216 var template = this.options.get('templateSelection'); 26217 var escapeMarkup = this.options.get('escapeMarkup'); 26218 return escapeMarkup(template(data, container)); 26219 }; 26220 26221 SingleSelection.prototype.selectionContainer = function () { 26222 return $('<span></span>'); 26223 }; 26224 26225 SingleSelection.prototype.update = function (data) { 26226 if (data.length === 0) { 26227 this.clear(); 26228 return; 26229 } 26230 26231 var selection = data[0]; 26232 var $rendered = this.$selection.find('.select2-selection__rendered'); 26233 var formatted = this.display(selection, $rendered); 26234 $rendered.empty().append(formatted); 26235 var title = selection.title || selection.text; 26236 26237 if (title) { 26238 $rendered.attr('title', title); 26239 } else { 26240 $rendered.removeAttr('title'); 26241 } 26242 }; 26243 26244 return SingleSelection; 26245 }); 26246 S2.define('select2/selection/multiple', ['jquery', './base', '../utils'], function ($, BaseSelection, Utils) { 26247 function MultipleSelection($element, options) { 26248 MultipleSelection.__super__.constructor.apply(this, arguments); 26249 } 26250 26251 Utils.Extend(MultipleSelection, BaseSelection); 26252 26253 MultipleSelection.prototype.render = function () { 26254 var $selection = MultipleSelection.__super__.render.call(this); 26255 26256 $selection.addClass('select2-selection--multiple'); 26257 $selection.html('<ul class="select2-selection__rendered"></ul>'); 26258 return $selection; 26259 }; 26260 26261 MultipleSelection.prototype.bind = function (container, $container) { 26262 var self = this; 26263 26264 MultipleSelection.__super__.bind.apply(this, arguments); 26265 26266 this.$selection.on('click', function (evt) { 26267 self.trigger('toggle', { 26268 originalEvent: evt 26269 }); 26270 }); 26271 this.$selection.on('click', '.select2-selection__choice__remove', function (evt) { 26272 // Ignore the event if it is disabled 26273 if (self.isDisabled()) { 26274 return; 26275 } 26276 26277 var $remove = $(this); 26278 var $selection = $remove.parent(); 26279 var data = Utils.GetData($selection[0], 'data'); 26280 self.trigger('unselect', { 26281 originalEvent: evt, 26282 data: data 26283 }); 26284 }); 26285 }; 26286 26287 MultipleSelection.prototype.clear = function () { 26288 var $rendered = this.$selection.find('.select2-selection__rendered'); 26289 $rendered.empty(); 26290 $rendered.removeAttr('title'); 26291 }; 26292 26293 MultipleSelection.prototype.display = function (data, container) { 26294 var template = this.options.get('templateSelection'); 26295 var escapeMarkup = this.options.get('escapeMarkup'); 26296 return escapeMarkup(template(data, container)); 26297 }; 26298 26299 MultipleSelection.prototype.selectionContainer = function () { 26300 var $container = $('<li class="select2-selection__choice">' + '<span class="select2-selection__choice__remove" role="presentation">' + '×' + '</span>' + '</li>'); 26301 return $container; 26302 }; 26303 26304 MultipleSelection.prototype.update = function (data) { 26305 this.clear(); 26306 26307 if (data.length === 0) { 26308 return; 26309 } 26310 26311 var $selections = []; 26312 26313 for (var d = 0; d < data.length; d++) { 26314 var selection = data[d]; 26315 var $selection = this.selectionContainer(); 26316 var formatted = this.display(selection, $selection); 26317 $selection.append(formatted); 26318 var title = selection.title || selection.text; 26319 26320 if (title) { 26321 $selection.attr('title', title); 26322 } 26323 26324 Utils.StoreData($selection[0], 'data', selection); 26325 $selections.push($selection); 26326 } 26327 26328 var $rendered = this.$selection.find('.select2-selection__rendered'); 26329 Utils.appendMany($rendered, $selections); 26330 }; 26331 26332 return MultipleSelection; 26333 }); 26334 S2.define('select2/selection/placeholder', ['../utils'], function (Utils) { 26335 function Placeholder(decorated, $element, options) { 26336 this.placeholder = this.normalizePlaceholder(options.get('placeholder')); 26337 decorated.call(this, $element, options); 26338 } 26339 26340 Placeholder.prototype.normalizePlaceholder = function (_, placeholder) { 26341 if (typeof placeholder === 'string') { 26342 placeholder = { 26343 id: '', 26344 text: placeholder 26345 }; 26346 } 26347 26348 return placeholder; 26349 }; 26350 26351 Placeholder.prototype.createPlaceholder = function (decorated, placeholder) { 26352 var $placeholder = this.selectionContainer(); 26353 $placeholder.html(this.display(placeholder)); 26354 $placeholder.addClass('select2-selection__placeholder').removeClass('select2-selection__choice'); 26355 return $placeholder; 26356 }; 26357 26358 Placeholder.prototype.update = function (decorated, data) { 26359 var singlePlaceholder = data.length == 1 && data[0].id != this.placeholder.id; 26360 var multipleSelections = data.length > 1; 26361 26362 if (multipleSelections || singlePlaceholder) { 26363 return decorated.call(this, data); 26364 } 26365 26366 this.clear(); 26367 var $placeholder = this.createPlaceholder(this.placeholder); 26368 this.$selection.find('.select2-selection__rendered').append($placeholder); 26369 }; 26370 26371 return Placeholder; 26372 }); 26373 S2.define('select2/selection/allowClear', ['jquery', '../keys', '../utils'], function ($, KEYS, Utils) { 26374 function AllowClear() {} 26375 26376 AllowClear.prototype.bind = function (decorated, container, $container) { 26377 var self = this; 26378 decorated.call(this, container, $container); 26379 26380 if (this.placeholder == null) { 26381 if (this.options.get('debug') && window.console && console.error) { 26382 console.error('Select2: The `allowClear` option should be used in combination ' + 'with the `placeholder` option.'); 26383 } 26384 } 26385 26386 this.$selection.on('mousedown', '.select2-selection__clear', function (evt) { 26387 self._handleClear(evt); 26388 }); 26389 container.on('keypress', function (evt) { 26390 self._handleKeyboardClear(evt, container); 26391 }); 26392 }; 26393 26394 AllowClear.prototype._handleClear = function (_, evt) { 26395 // Ignore the event if it is disabled 26396 if (this.isDisabled()) { 26397 return; 26398 } 26399 26400 var $clear = this.$selection.find('.select2-selection__clear'); // Ignore the event if nothing has been selected 26401 26402 if ($clear.length === 0) { 26403 return; 26404 } 26405 26406 evt.stopPropagation(); 26407 var data = Utils.GetData($clear[0], 'data'); 26408 var previousVal = this.$element.val(); 26409 this.$element.val(this.placeholder.id); 26410 var unselectData = { 26411 data: data 26412 }; 26413 this.trigger('clear', unselectData); 26414 26415 if (unselectData.prevented) { 26416 this.$element.val(previousVal); 26417 return; 26418 } 26419 26420 for (var d = 0; d < data.length; d++) { 26421 unselectData = { 26422 data: data[d] 26423 }; // Trigger the `unselect` event, so people can prevent it from being 26424 // cleared. 26425 26426 this.trigger('unselect', unselectData); // If the event was prevented, don't clear it out. 26427 26428 if (unselectData.prevented) { 26429 this.$element.val(previousVal); 26430 return; 26431 } 26432 } 26433 26434 this.$element.trigger('input').trigger('change'); 26435 this.trigger('toggle', {}); 26436 }; 26437 26438 AllowClear.prototype._handleKeyboardClear = function (_, evt, container) { 26439 if (container.isOpen()) { 26440 return; 26441 } 26442 26443 if (evt.which == KEYS.DELETE || evt.which == KEYS.BACKSPACE) { 26444 this._handleClear(evt); 26445 } 26446 }; 26447 26448 AllowClear.prototype.update = function (decorated, data) { 26449 decorated.call(this, data); 26450 26451 if (this.$selection.find('.select2-selection__placeholder').length > 0 || data.length === 0) { 26452 return; 26453 } 26454 26455 var removeAll = this.options.get('translations').get('removeAllItems'); 26456 var $remove = $('<span class="select2-selection__clear" title="' + removeAll() + '">' + '×' + '</span>'); 26457 Utils.StoreData($remove[0], 'data', data); 26458 this.$selection.find('.select2-selection__rendered').prepend($remove); 26459 }; 26460 26461 return AllowClear; 26462 }); 26463 S2.define('select2/selection/search', ['jquery', '../utils', '../keys'], function ($, Utils, KEYS) { 26464 function Search(decorated, $element, options) { 26465 decorated.call(this, $element, options); 26466 } 26467 26468 Search.prototype.render = function (decorated) { 26469 var $search = $('<li class="select2-search select2-search--inline">' + '<input class="select2-search__field" type="search" tabindex="-1"' + ' autocomplete="off" autocorrect="off" autocapitalize="none"' + ' spellcheck="false" role="searchbox" aria-autocomplete="list" />' + '</li>'); 26470 this.$searchContainer = $search; 26471 this.$search = $search.find('input'); 26472 var $rendered = decorated.call(this); 26473 26474 this._transferTabIndex(); 26475 26476 return $rendered; 26477 }; 26478 26479 Search.prototype.bind = function (decorated, container, $container) { 26480 var self = this; 26481 var resultsId = container.id + '-results'; 26482 decorated.call(this, container, $container); 26483 container.on('open', function () { 26484 self.$search.attr('aria-controls', resultsId); 26485 self.$search.trigger('focus'); 26486 }); 26487 container.on('close', function () { 26488 self.$search.val(''); 26489 self.$search.removeAttr('aria-controls'); 26490 self.$search.removeAttr('aria-activedescendant'); 26491 self.$search.trigger('focus'); 26492 }); 26493 container.on('enable', function () { 26494 self.$search.prop('disabled', false); 26495 26496 self._transferTabIndex(); 26497 }); 26498 container.on('disable', function () { 26499 self.$search.prop('disabled', true); 26500 }); 26501 container.on('focus', function (evt) { 26502 self.$search.trigger('focus'); 26503 }); 26504 container.on('results:focus', function (params) { 26505 if (params.data._resultId) { 26506 self.$search.attr('aria-activedescendant', params.data._resultId); 26507 } else { 26508 self.$search.removeAttr('aria-activedescendant'); 26509 } 26510 }); 26511 this.$selection.on('focusin', '.select2-search--inline', function (evt) { 26512 self.trigger('focus', evt); 26513 }); 26514 this.$selection.on('focusout', '.select2-search--inline', function (evt) { 26515 self._handleBlur(evt); 26516 }); 26517 this.$selection.on('keydown', '.select2-search--inline', function (evt) { 26518 evt.stopPropagation(); 26519 self.trigger('keypress', evt); 26520 self._keyUpPrevented = evt.isDefaultPrevented(); 26521 var key = evt.which; 26522 26523 if (key === KEYS.BACKSPACE && self.$search.val() === '') { 26524 var $previousChoice = self.$searchContainer.prev('.select2-selection__choice'); 26525 26526 if ($previousChoice.length > 0) { 26527 var item = Utils.GetData($previousChoice[0], 'data'); 26528 self.searchRemoveChoice(item); 26529 evt.preventDefault(); 26530 } 26531 } 26532 }); 26533 this.$selection.on('click', '.select2-search--inline', function (evt) { 26534 if (self.$search.val()) { 26535 evt.stopPropagation(); 26536 } 26537 }); // Try to detect the IE version should the `documentMode` property that 26538 // is stored on the document. This is only implemented in IE and is 26539 // slightly cleaner than doing a user agent check. 26540 // This property is not available in Edge, but Edge also doesn't have 26541 // this bug. 26542 26543 var msie = document.documentMode; 26544 var disableInputEvents = msie && msie <= 11; // Workaround for browsers which do not support the `input` event 26545 // This will prevent double-triggering of events for browsers which support 26546 // both the `keyup` and `input` events. 26547 26548 this.$selection.on('input.searchcheck', '.select2-search--inline', function (evt) { 26549 // IE will trigger the `input` event when a placeholder is used on a 26550 // search box. To get around this issue, we are forced to ignore all 26551 // `input` events in IE and keep using `keyup`. 26552 if (disableInputEvents) { 26553 self.$selection.off('input.search input.searchcheck'); 26554 return; 26555 } // Unbind the duplicated `keyup` event 26556 26557 26558 self.$selection.off('keyup.search'); 26559 }); 26560 this.$selection.on('keyup.search input.search', '.select2-search--inline', function (evt) { 26561 // IE will trigger the `input` event when a placeholder is used on a 26562 // search box. To get around this issue, we are forced to ignore all 26563 // `input` events in IE and keep using `keyup`. 26564 if (disableInputEvents && evt.type === 'input') { 26565 self.$selection.off('input.search input.searchcheck'); 26566 return; 26567 } 26568 26569 var key = evt.which; // We can freely ignore events from modifier keys 26570 26571 if (key == KEYS.SHIFT || key == KEYS.CTRL || key == KEYS.ALT) { 26572 return; 26573 } // Tabbing will be handled during the `keydown` phase 26574 26575 26576 if (key == KEYS.TAB) { 26577 return; 26578 } 26579 26580 self.handleSearch(evt); 26581 }); 26582 }; 26583 /** 26584 * This method will transfer the tabindex attribute from the rendered 26585 * selection to the search box. This allows for the search box to be used as 26586 * the primary focus instead of the selection container. 26587 * 26588 * @private 26589 */ 26590 26591 26592 Search.prototype._transferTabIndex = function (decorated) { 26593 this.$search.attr('tabindex', this.$selection.attr('tabindex')); 26594 this.$selection.attr('tabindex', '-1'); 26595 }; 26596 26597 Search.prototype.createPlaceholder = function (decorated, placeholder) { 26598 this.$search.attr('placeholder', placeholder.text); 26599 }; 26600 26601 Search.prototype.update = function (decorated, data) { 26602 var searchHadFocus = this.$search[0] == document.activeElement; 26603 this.$search.attr('placeholder', ''); 26604 decorated.call(this, data); 26605 this.$selection.find('.select2-selection__rendered').append(this.$searchContainer); 26606 this.resizeSearch(); 26607 26608 if (searchHadFocus) { 26609 this.$search.trigger('focus'); 26610 } 26611 }; 26612 26613 Search.prototype.handleSearch = function () { 26614 this.resizeSearch(); 26615 26616 if (!this._keyUpPrevented) { 26617 var input = this.$search.val(); 26618 this.trigger('query', { 26619 term: input 26620 }); 26621 } 26622 26623 this._keyUpPrevented = false;
vendor: 4,638 bytes, lines 26624-26795
26624 }; 26625 26626 Search.prototype.searchRemoveChoice = function (decorated, item) { 26627 this.trigger('unselect', { 26628 data: item 26629 }); 26630 this.$search.val(item.text); 26631 this.handleSearch(); 26632 }; 26633 26634 Search.prototype.resizeSearch = function () { 26635 this.$search.css('width', '25px'); 26636 var width = ''; 26637 26638 if (this.$search.attr('placeholder') !== '') { 26639 width = this.$selection.find('.select2-selection__rendered').width(); 26640 } else { 26641 var minimumWidth = this.$search.val().length + 1; 26642 width = minimumWidth * 0.75 + 'em'; 26643 } 26644 26645 this.$search.css('width', width); 26646 }; 26647 26648 return Search; 26649 }); 26650 S2.define('select2/selection/eventRelay', ['jquery'], function ($) { 26651 function EventRelay() {} 26652 26653 EventRelay.prototype.bind = function (decorated, container, $container) { 26654 var self = this; 26655 var relayEvents = ['open', 'opening', 'close', 'closing', 'select', 'selecting', 'unselect', 'unselecting', 'clear', 'clearing']; 26656 var preventableEvents = ['opening', 'closing', 'selecting', 'unselecting', 'clearing']; 26657 decorated.call(this, container, $container); 26658 container.on('*', function (name, params) { 26659 // Ignore events that should not be relayed 26660 if ($.inArray(name, relayEvents) === -1) { 26661 return; 26662 } // The parameters should always be an object 26663 26664 26665 params = params || {}; // Generate the jQuery event for the Select2 event 26666 26667 var evt = $.Event('select2:' + name, { 26668 params: params 26669 }); 26670 self.$element.trigger(evt); // Only handle preventable events if it was one 26671 26672 if ($.inArray(name, preventableEvents) === -1) { 26673 return; 26674 } 26675 26676 params.prevented = evt.isDefaultPrevented(); 26677 }); 26678 }; 26679 26680 return EventRelay; 26681 }); 26682 S2.define('select2/translation', ['jquery', 'require'], function ($, require) { 26683 function Translation(dict) { 26684 this.dict = dict || {}; 26685 } 26686 26687 Translation.prototype.all = function () { 26688 return this.dict; 26689 }; 26690 26691 Translation.prototype.get = function (key) { 26692 return this.dict[key]; 26693 }; 26694 26695 Translation.prototype.extend = function (translation) { 26696 this.dict = $.extend({}, translation.all(), this.dict); 26697 }; // Static functions 26698 26699 26700 Translation._cache = {}; 26701 26702 Translation.loadPath = function (path) { 26703 if (!(path in Translation._cache)) { 26704 var translations = require(path); 26705 26706 Translation._cache[path] = translations; 26707 } 26708 26709 return new Translation(Translation._cache[path]); 26710 }; 26711 26712 return Translation; 26713 }); 26714 S2.define('select2/diacritics', [], function () { 26715 var diacritics = { 26716 "\u24B6": 'A', 26717 "\uFF21": 'A', 26718 "\xC0": 'A', 26719 "\xC1": 'A', 26720 "\xC2": 'A', 26721 "\u1EA6": 'A', 26722 "\u1EA4": 'A', 26723 "\u1EAA": 'A', 26724 "\u1EA8": 'A', 26725 "\xC3": 'A', 26726 "\u0100": 'A', 26727 "\u0102": 'A', 26728 "\u1EB0": 'A', 26729 "\u1EAE": 'A', 26730 "\u1EB4": 'A', 26731 "\u1EB2": 'A', 26732 "\u0226": 'A', 26733 "\u01E0": 'A', 26734 "\xC4": 'A', 26735 "\u01DE": 'A', 26736 "\u1EA2": 'A', 26737 "\xC5": 'A', 26738 "\u01FA": 'A', 26739 "\u01CD": 'A', 26740 "\u0200": 'A', 26741 "\u0202": 'A', 26742 "\u1EA0": 'A', 26743 "\u1EAC": 'A', 26744 "\u1EB6": 'A', 26745 "\u1E00": 'A', 26746 "\u0104": 'A', 26747 "\u023A": 'A', 26748 "\u2C6F": 'A', 26749 "\uA732": 'AA', 26750 "\xC6": 'AE', 26751 "\u01FC": 'AE', 26752 "\u01E2": 'AE', 26753 "\uA734": 'AO', 26754 "\uA736": 'AU', 26755 "\uA738": 'AV', 26756 "\uA73A": 'AV', 26757 "\uA73C": 'AY', 26758 "\u24B7": 'B', 26759 "\uFF22": 'B', 26760 "\u1E02": 'B', 26761 "\u1E04": 'B', 26762 "\u1E06": 'B', 26763 "\u0243": 'B', 26764 "\u0182": 'B', 26765 "\u0181": 'B', 26766 "\u24B8": 'C', 26767 "\uFF23": 'C', 26768 "\u0106": 'C', 26769 "\u0108": 'C', 26770 "\u010A": 'C', 26771 "\u010C": 'C', 26772 "\xC7": 'C', 26773 "\u1E08": 'C', 26774 "\u0187": 'C', 26775 "\u023B": 'C', 26776 "\uA73E": 'C', 26777 "\u24B9": 'D', 26778 "\uFF24": 'D', 26779 "\u1E0A": 'D', 26780 "\u010E": 'D', 26781 "\u1E0C": 'D', 26782 "\u1E10": 'D', 26783 "\u1E12": 'D', 26784 "\u1E0E": 'D', 26785 "\u0110": 'D', 26786 "\u018B": 'D', 26787 "\u018A": 'D', 26788 "\u0189": 'D', 26789 "\uA779": 'D', 26790 "\u01F1": 'DZ', 26791 "\u01C4": 'DZ', 26792 "\u01F2": 'Dz', 26793 "\u01C5": 'Dz', 26794 "\u24BA": 'E', 26795 "\uFF25": 'E',
26796 "\xC8": 'E', 26797 "\xC9": 'E', 26798 "\xCA": 'E', 26799 "\u1EC0": 'E', 26800 "\u1EBE": 'E', 26801 "\u1EC4": 'E', 26802 "\u1EC2": 'E', 26803 "\u1EBC": 'E', 26804 "\u0112": 'E', 26805 "\u1E14": 'E', 26806 "\u1E16": 'E', 26807 "\u0114": 'E', 26808 "\u0116": 'E', 26809 "\xCB": 'E', 26810 "\u1EBA": 'E', 26811 "\u011A": 'E', 26812 "\u0204": 'E', 26813 "\u0206": 'E', 26814 "\u1EB8": 'E', 26815 "\u1EC6": 'E', 26816 "\u0228": 'E', 26817 "\u1E1C": 'E', 26818 "\u0118": 'E', 26819 "\u1E18": 'E', 26820 "\u1E1A": 'E', 26821 "\u0190": 'E', 26822 "\u018E": 'E', 26823 "\u24BB": 'F', 26824 "\uFF26": 'F', 26825 "\u1E1E": 'F', 26826 "\u0191": 'F', 26827 "\uA77B": 'F', 26828 "\u24BC": 'G', 26829 "\uFF27": 'G', 26830 "\u01F4": 'G', 26831 "\u011C": 'G', 26832 "\u1E20": 'G', 26833 "\u011E": 'G', 26834 "\u0120": 'G', 26835 "\u01E6": 'G', 26836 "\u0122": 'G', 26837 "\u01E4": 'G', 26838 "\u0193": 'G', 26839 "\uA7A0": 'G', 26840 "\uA77D": 'G', 26841 "\uA77E": 'G', 26842 "\u24BD": 'H', 26843 "\uFF28": 'H', 26844 "\u0124": 'H', 26845 "\u1E22": 'H', 26846 "\u1E26": 'H', 26847 "\u021E": 'H', 26848 "\u1E24": 'H', 26849 "\u1E28": 'H', 26850 "\u1E2A": 'H', 26851 "\u0126": 'H', 26852 "\u2C67": 'H', 26853 "\u2C75": 'H', 26854 "\uA78D": 'H', 26855 "\u24BE": 'I', 26856 "\uFF29": 'I', 26857 "\xCC": 'I', 26858 "\xCD": 'I', 26859 "\xCE": 'I', 26860 "\u0128": 'I', 26861 "\u012A": 'I', 26862 "\u012C": 'I', 26863 "\u0130": 'I', 26864 "\xCF": 'I', 26865 "\u1E2E": 'I', 26866 "\u1EC8": 'I', 26867 "\u01CF": 'I', 26868 "\u0208": 'I', 26869 "\u020A": 'I', 26870 "\u1ECA": 'I', 26871 "\u012E": 'I', 26872 "\u1E2C": 'I', 26873 "\u0197": 'I', 26874 "\u24BF": 'J', 26875 "\uFF2A": 'J', 26876 "\u0134": 'J', 26877 "\u0248": 'J', 26878 "\u24C0": 'K', 26879 "\uFF2B": 'K', 26880 "\u1E30": 'K', 26881 "\u01E8": 'K', 26882 "\u1E32": 'K', 26883 "\u0136": 'K', 26884 "\u1E34": 'K', 26885 "\u0198": 'K', 26886 "\u2C69": 'K', 26887 "\uA740": 'K', 26888 "\uA742": 'K', 26889 "\uA744": 'K', 26890 "\uA7A2": 'K', 26891 "\u24C1": 'L', 26892 "\uFF2C": 'L', 26893 "\u013F": 'L', 26894 "\u0139": 'L', 26895 "\u013D": 'L', 26896 "\u1E36": 'L', 26897 "\u1E38": 'L', 26898 "\u013B": 'L', 26899 "\u1E3C": 'L', 26900 "\u1E3A": 'L', 26901 "\u0141": 'L', 26902 "\u023D": 'L', 26903 "\u2C62": 'L', 26904 "\u2C60": 'L', 26905 "\uA748": 'L', 26906 "\uA746": 'L', 26907 "\uA780": 'L', 26908 "\u01C7": 'LJ', 26909 "\u01C8": 'Lj', 26910 "\u24C2": 'M', 26911 "\uFF2D": 'M', 26912 "\u1E3E": 'M', 26913 "\u1E40": 'M', 26914 "\u1E42": 'M', 26915 "\u2C6E": 'M', 26916 "\u019C": 'M', 26917 "\u24C3": 'N', 26918 "\uFF2E": 'N', 26919 "\u01F8": 'N', 26920 "\u0143": 'N', 26921 "\xD1": 'N', 26922 "\u1E44": 'N', 26923 "\u0147": 'N', 26924 "\u1E46": 'N', 26925 "\u0145": 'N', 26926 "\u1E4A": 'N', 26927 "\u1E48": 'N', 26928 "\u0220": 'N', 26929 "\u019D": 'N', 26930 "\uA790": 'N', 26931 "\uA7A4": 'N', 26932 "\u01CA": 'NJ', 26933 "\u01CB": 'Nj', 26934 "\u24C4": 'O', 26935 "\uFF2F": 'O', 26936 "\xD2": 'O', 26937 "\xD3": 'O', 26938 "\xD4": 'O', 26939 "\u1ED2": 'O', 26940 "\u1ED0": 'O', 26941 "\u1ED6": 'O', 26942 "\u1ED4": 'O', 26943 "\xD5": 'O', 26944 "\u1E4C": 'O', 26945 "\u022C": 'O', 26946 "\u1E4E": 'O', 26947 "\u014C": 'O', 26948 "\u1E50": 'O', 26949 "\u1E52": 'O', 26950 "\u014E": 'O', 26951 "\u022E": 'O', 26952 "\u0230": 'O', 26953 "\xD6": 'O', 26954 "\u022A": 'O', 26955 "\u1ECE": 'O', 26956 "\u0150": 'O', 26957 "\u01D1": 'O', 26958 "\u020C": 'O', 26959 "\u020E": 'O', 26960 "\u01A0": 'O', 26961 "\u1EDC": 'O', 26962 "\u1EDA": 'O', 26963 "\u1EE0": 'O', 26964 "\u1EDE": 'O', 26965 "\u1EE2": 'O', 26966 "\u1ECC": 'O', 26967 "\u1ED8": 'O', 26968 "\u01EA": 'O', 26969 "\u01EC": 'O', 26970 "\xD8": 'O', 26971 "\u01FE": 'O', 26972 "\u0186": 'O', 26973 "\u019F": 'O', 26974 "\uA74A": 'O', 26975 "\uA74C": 'O', 26976 "\u0152": 'OE', 26977 "\u01A2": 'OI', 26978 "\uA74E": 'OO', 26979 "\u0222": 'OU', 26980 "\u24C5": 'P', 26981 "\uFF30": 'P', 26982 "\u1E54": 'P', 26983 "\u1E56": 'P', 26984 "\u01A4": 'P', 26985 "\u2C63": 'P', 26986 "\uA750": 'P', 26987 "\uA752": 'P', 26988 "\uA754": 'P', 26989 "\u24C6": 'Q', 26990 "\uFF31": 'Q', 26991 "\uA756": 'Q', 26992 "\uA758": 'Q', 26993 "\u024A": 'Q', 26994 "\u24C7": 'R', 26995 "\uFF32": 'R', 26996 "\u0154": 'R', 26997 "\u1E58": 'R', 26998 "\u0158": 'R', 26999 "\u0210": 'R', 27000 "\u0212": 'R', 27001 "\u1E5A": 'R', 27002 "\u1E5C": 'R', 27003 "\u0156": 'R', 27004 "\u1E5E": 'R', 27005 "\u024C": 'R', 27006 "\u2C64": 'R', 27007 "\uA75A": 'R', 27008 "\uA7A6": 'R', 27009 "\uA782": 'R', 27010 "\u24C8": 'S', 27011 "\uFF33": 'S', 27012 "\u1E9E": 'S', 27013 "\u015A": 'S', 27014 "\u1E64": 'S', 27015 "\u015C": 'S', 27016 "\u1E60": 'S', 27017 "\u0160": 'S', 27018 "\u1E66": 'S', 27019 "\u1E62": 'S', 27020 "\u1E68": 'S', 27021 "\u0218": 'S', 27022 "\u015E": 'S', 27023 "\u2C7E": 'S', 27024 "\uA7A8": 'S', 27025 "\uA784": 'S', 27026 "\u24C9": 'T', 27027 "\uFF34": 'T', 27028 "\u1E6A": 'T', 27029 "\u0164": 'T', 27030 "\u1E6C": 'T', 27031 "\u021A": 'T', 27032 "\u0162": 'T', 27033 "\u1E70": 'T', 27034 "\u1E6E": 'T', 27035 "\u0166": 'T', 27036 "\u01AC": 'T', 27037 "\u01AE": 'T', 27038 "\u023E": 'T', 27039 "\uA786": 'T', 27040 "\uA728": 'TZ', 27041 "\u24CA": 'U', 27042 "\uFF35": 'U', 27043 "\xD9": 'U', 27044 "\xDA": 'U', 27045 "\xDB": 'U', 27046 "\u0168": 'U', 27047 "\u1E78": 'U', 27048 "\u016A": 'U', 27049 "\u1E7A": 'U', 27050 "\u016C": 'U', 27051 "\xDC": 'U', 27052 "\u01DB": 'U', 27053 "\u01D7": 'U', 27054 "\u01D5": 'U', 27055 "\u01D9": 'U', 27056 "\u1EE6": 'U', 27057 "\u016E": 'U', 27058 "\u0170": 'U', 27059 "\u01D3": 'U', 27060 "\u0214": 'U', 27061 "\u0216": 'U', 27062 "\u01AF": 'U', 27063 "\u1EEA": 'U', 27064 "\u1EE8": 'U', 27065 "\u1EEE": 'U', 27066 "\u1EEC": 'U', 27067 "\u1EF0": 'U', 27068 "\u1EE4": 'U', 27069 "\u1E72": 'U', 27070 "\u0172": 'U', 27071 "\u1E76": 'U', 27072 "\u1E74": 'U', 27073 "\u0244": 'U', 27074 "\u24CB": 'V', 27075 "\uFF36": 'V', 27076 "\u1E7C": 'V', 27077 "\u1E7E": 'V', 27078 "\u01B2": 'V', 27079 "\uA75E": 'V', 27080 "\u0245": 'V', 27081 "\uA760": 'VY', 27082 "\u24CC": 'W', 27083 "\uFF37": 'W', 27084 "\u1E80": 'W', 27085 "\u1E82": 'W', 27086 "\u0174": 'W', 27087 "\u1E86": 'W', 27088 "\u1E84": 'W', 27089 "\u1E88": 'W', 27090 "\u2C72": 'W', 27091 "\u24CD": 'X', 27092 "\uFF38": 'X', 27093 "\u1E8A": 'X', 27094 "\u1E8C": 'X', 27095 "\u24CE": 'Y', 27096 "\uFF39": 'Y', 27097 "\u1EF2": 'Y', 27098 "\xDD": 'Y', 27099 "\u0176": 'Y', 27100 "\u1EF8": 'Y', 27101 "\u0232": 'Y', 27102 "\u1E8E": 'Y', 27103 "\u0178": 'Y', 27104 "\u1EF6": 'Y', 27105 "\u1EF4": 'Y', 27106 "\u01B3": 'Y', 27107 "\u024E": 'Y', 27108 "\u1EFE": 'Y', 27109 "\u24CF": 'Z', 27110 "\uFF3A": 'Z', 27111 "\u0179": 'Z', 27112 "\u1E90": 'Z', 27113 "\u017B": 'Z', 27114 "\u017D": 'Z', 27115 "\u1E92": 'Z', 27116 "\u1E94": 'Z', 27117 "\u01B5": 'Z', 27118 "\u0224": 'Z', 27119 "\u2C7F": 'Z', 27120 "\u2C6B": 'Z', 27121 "\uA762": 'Z', 27122 "\u24D0": 'a', 27123 "\uFF41": 'a', 27124 "\u1E9A": 'a', 27125 "\xE0": 'a', 27126 "\xE1": 'a', 27127 "\xE2": 'a', 27128 "\u1EA7": 'a', 27129 "\u1EA5": 'a', 27130 "\u1EAB": 'a', 27131 "\u1EA9": 'a', 27132 "\xE3": 'a', 27133 "\u0101": 'a', 27134 "\u0103": 'a', 27135 "\u1EB1": 'a', 27136 "\u1EAF": 'a', 27137 "\u1EB5": 'a', 27138 "\u1EB3": 'a', 27139 "\u0227": 'a', 27140 "\u01E1": 'a', 27141 "\xE4": 'a', 27142 "\u01DF": 'a', 27143 "\u1EA3": 'a', 27144 "\xE5": 'a', 27145 "\u01FB": 'a', 27146 "\u01CE": 'a', 27147 "\u0201": 'a', 27148 "\u0203": 'a', 27149 "\u1EA1": 'a', 27150 "\u1EAD": 'a', 27151 "\u1EB7": 'a', 27152 "\u1E01": 'a', 27153 "\u0105": 'a', 27154 "\u2C65": 'a', 27155 "\u0250": 'a', 27156 "\uA733": 'aa', 27157 "\xE6": 'ae', 27158 "\u01FD": 'ae', 27159 "\u01E3": 'ae', 27160 "\uA735": 'ao', 27161 "\uA737": 'au', 27162 "\uA739": 'av', 27163 "\uA73B": 'av', 27164 "\uA73D": 'ay', 27165 "\u24D1": 'b', 27166 "\uFF42": 'b', 27167 "\u1E03": 'b', 27168 "\u1E05": 'b', 27169 "\u1E07": 'b', 27170 "\u0180": 'b', 27171 "\u0183": 'b', 27172 "\u0253": 'b', 27173 "\u24D2": 'c', 27174 "\uFF43": 'c', 27175 "\u0107": 'c', 27176 "\u0109": 'c', 27177 "\u010B": 'c', 27178 "\u010D": 'c', 27179 "\xE7": 'c', 27180 "\u1E09": 'c', 27181 "\u0188": 'c', 27182 "\u023C": 'c', 27183 "\uA73F": 'c', 27184 "\u2184": 'c', 27185 "\u24D3": 'd', 27186 "\uFF44": 'd', 27187 "\u1E0B": 'd', 27188 "\u010F": 'd', 27189 "\u1E0D": 'd', 27190 "\u1E11": 'd', 27191 "\u1E13": 'd', 27192 "\u1E0F": 'd', 27193 "\u0111": 'd', 27194 "\u018C": 'd', 27195 "\u0256": 'd', 27196 "\u0257": 'd', 27197 "\uA77A": 'd', 27198 "\u01F3": 'dz', 27199 "\u01C6": 'dz', 27200 "\u24D4": 'e', 27201 "\uFF45": 'e', 27202 "\xE8": 'e', 27203 "\xE9": 'e', 27204 "\xEA": 'e', 27205 "\u1EC1": 'e', 27206 "\u1EBF": 'e', 27207 "\u1EC5": 'e', 27208 "\u1EC3": 'e', 27209 "\u1EBD": 'e', 27210 "\u0113": 'e', 27211 "\u1E15": 'e', 27212 "\u1E17": 'e', 27213 "\u0115": 'e', 27214 "\u0117": 'e', 27215 "\xEB": 'e', 27216 "\u1EBB": 'e', 27217 "\u011B": 'e', 27218 "\u0205": 'e', 27219 "\u0207": 'e', 27220 "\u1EB9": 'e', 27221 "\u1EC7": 'e', 27222 "\u0229": 'e', 27223 "\u1E1D": 'e', 27224 "\u0119": 'e', 27225 "\u1E19": 'e', 27226 "\u1E1B": 'e', 27227 "\u0247": 'e', 27228 "\u025B": 'e', 27229 "\u01DD": 'e', 27230 "\u24D5": 'f', 27231 "\uFF46": 'f', 27232 "\u1E1F": 'f', 27233 "\u0192": 'f', 27234 "\uA77C": 'f', 27235 "\u24D6": 'g', 27236 "\uFF47": 'g', 27237 "\u01F5": 'g', 27238 "\u011D": 'g', 27239 "\u1E21": 'g', 27240 "\u011F": 'g', 27241 "\u0121": 'g', 27242 "\u01E7": 'g', 27243 "\u0123": 'g', 27244 "\u01E5": 'g', 27245 "\u0260": 'g', 27246 "\uA7A1": 'g', 27247 "\u1D79": 'g', 27248 "\uA77F": 'g', 27249 "\u24D7": 'h', 27250 "\uFF48": 'h', 27251 "\u0125": 'h', 27252 "\u1E23": 'h', 27253 "\u1E27": 'h', 27254 "\u021F": 'h', 27255 "\u1E25": 'h', 27256 "\u1E29": 'h', 27257 "\u1E2B": 'h', 27258 "\u1E96": 'h', 27259 "\u0127": 'h', 27260 "\u2C68": 'h', 27261 "\u2C76": 'h', 27262 "\u0265": 'h', 27263 "\u0195": 'hv', 27264 "\u24D8": 'i', 27265 "\uFF49": 'i', 27266 "\xEC": 'i', 27267 "\xED": 'i', 27268 "\xEE": 'i', 27269 "\u0129": 'i', 27270 "\u012B": 'i', 27271 "\u012D": 'i', 27272 "\xEF": 'i', 27273 "\u1E2F": 'i', 27274 "\u1EC9": 'i', 27275 "\u01D0": 'i', 27276 "\u0209": 'i', 27277 "\u020B": 'i', 27278 "\u1ECB": 'i', 27279 "\u012F": 'i', 27280 "\u1E2D": 'i', 27281 "\u0268": 'i', 27282 "\u0131": 'i',
vendor: 33,072 bytes, lines 27283-28442
27283 "\u24D9": 'j', 27284 "\uFF4A": 'j', 27285 "\u0135": 'j', 27286 "\u01F0": 'j', 27287 "\u0249": 'j', 27288 "\u24DA": 'k', 27289 "\uFF4B": 'k', 27290 "\u1E31": 'k', 27291 "\u01E9": 'k', 27292 "\u1E33": 'k', 27293 "\u0137": 'k', 27294 "\u1E35": 'k', 27295 "\u0199": 'k', 27296 "\u2C6A": 'k', 27297 "\uA741": 'k', 27298 "\uA743": 'k', 27299 "\uA745": 'k', 27300 "\uA7A3": 'k', 27301 "\u24DB": 'l', 27302 "\uFF4C": 'l', 27303 "\u0140": 'l', 27304 "\u013A": 'l', 27305 "\u013E": 'l', 27306 "\u1E37": 'l', 27307 "\u1E39": 'l', 27308 "\u013C": 'l', 27309 "\u1E3D": 'l', 27310 "\u1E3B": 'l', 27311 "\u017F": 'l', 27312 "\u0142": 'l', 27313 "\u019A": 'l', 27314 "\u026B": 'l', 27315 "\u2C61": 'l', 27316 "\uA749": 'l', 27317 "\uA781": 'l', 27318 "\uA747": 'l', 27319 "\u01C9": 'lj', 27320 "\u24DC": 'm', 27321 "\uFF4D": 'm', 27322 "\u1E3F": 'm', 27323 "\u1E41": 'm', 27324 "\u1E43": 'm', 27325 "\u0271": 'm', 27326 "\u026F": 'm', 27327 "\u24DD": 'n', 27328 "\uFF4E": 'n', 27329 "\u01F9": 'n', 27330 "\u0144": 'n', 27331 "\xF1": 'n', 27332 "\u1E45": 'n', 27333 "\u0148": 'n', 27334 "\u1E47": 'n', 27335 "\u0146": 'n', 27336 "\u1E4B": 'n', 27337 "\u1E49": 'n', 27338 "\u019E": 'n', 27339 "\u0272": 'n', 27340 "\u0149": 'n', 27341 "\uA791": 'n', 27342 "\uA7A5": 'n', 27343 "\u01CC": 'nj', 27344 "\u24DE": 'o', 27345 "\uFF4F": 'o', 27346 "\xF2": 'o', 27347 "\xF3": 'o', 27348 "\xF4": 'o', 27349 "\u1ED3": 'o', 27350 "\u1ED1": 'o', 27351 "\u1ED7": 'o', 27352 "\u1ED5": 'o', 27353 "\xF5": 'o', 27354 "\u1E4D": 'o', 27355 "\u022D": 'o', 27356 "\u1E4F": 'o', 27357 "\u014D": 'o', 27358 "\u1E51": 'o', 27359 "\u1E53": 'o', 27360 "\u014F": 'o', 27361 "\u022F": 'o', 27362 "\u0231": 'o', 27363 "\xF6": 'o', 27364 "\u022B": 'o', 27365 "\u1ECF": 'o', 27366 "\u0151": 'o', 27367 "\u01D2": 'o', 27368 "\u020D": 'o', 27369 "\u020F": 'o', 27370 "\u01A1": 'o', 27371 "\u1EDD": 'o', 27372 "\u1EDB": 'o', 27373 "\u1EE1": 'o', 27374 "\u1EDF": 'o', 27375 "\u1EE3": 'o', 27376 "\u1ECD": 'o', 27377 "\u1ED9": 'o', 27378 "\u01EB": 'o', 27379 "\u01ED": 'o', 27380 "\xF8": 'o', 27381 "\u01FF": 'o', 27382 "\u0254": 'o', 27383 "\uA74B": 'o', 27384 "\uA74D": 'o', 27385 "\u0275": 'o', 27386 "\u0153": 'oe', 27387 "\u01A3": 'oi', 27388 "\u0223": 'ou', 27389 "\uA74F": 'oo', 27390 "\u24DF": 'p', 27391 "\uFF50": 'p', 27392 "\u1E55": 'p', 27393 "\u1E57": 'p', 27394 "\u01A5": 'p', 27395 "\u1D7D": 'p', 27396 "\uA751": 'p', 27397 "\uA753": 'p', 27398 "\uA755": 'p', 27399 "\u24E0": 'q', 27400 "\uFF51": 'q', 27401 "\u024B": 'q', 27402 "\uA757": 'q', 27403 "\uA759": 'q', 27404 "\u24E1": 'r', 27405 "\uFF52": 'r', 27406 "\u0155": 'r', 27407 "\u1E59": 'r', 27408 "\u0159": 'r', 27409 "\u0211": 'r', 27410 "\u0213": 'r', 27411 "\u1E5B": 'r', 27412 "\u1E5D": 'r', 27413 "\u0157": 'r', 27414 "\u1E5F": 'r', 27415 "\u024D": 'r', 27416 "\u027D": 'r', 27417 "\uA75B": 'r', 27418 "\uA7A7": 'r', 27419 "\uA783": 'r', 27420 "\u24E2": 's', 27421 "\uFF53": 's', 27422 "\xDF": 's', 27423 "\u015B": 's', 27424 "\u1E65": 's', 27425 "\u015D": 's', 27426 "\u1E61": 's', 27427 "\u0161": 's', 27428 "\u1E67": 's', 27429 "\u1E63": 's', 27430 "\u1E69": 's', 27431 "\u0219": 's', 27432 "\u015F": 's', 27433 "\u023F": 's', 27434 "\uA7A9": 's', 27435 "\uA785": 's', 27436 "\u1E9B": 's', 27437 "\u24E3": 't', 27438 "\uFF54": 't', 27439 "\u1E6B": 't', 27440 "\u1E97": 't', 27441 "\u0165": 't', 27442 "\u1E6D": 't', 27443 "\u021B": 't', 27444 "\u0163": 't', 27445 "\u1E71": 't', 27446 "\u1E6F": 't', 27447 "\u0167": 't', 27448 "\u01AD": 't', 27449 "\u0288": 't', 27450 "\u2C66": 't', 27451 "\uA787": 't', 27452 "\uA729": 'tz', 27453 "\u24E4": 'u', 27454 "\uFF55": 'u', 27455 "\xF9": 'u', 27456 "\xFA": 'u', 27457 "\xFB": 'u', 27458 "\u0169": 'u', 27459 "\u1E79": 'u', 27460 "\u016B": 'u', 27461 "\u1E7B": 'u', 27462 "\u016D": 'u', 27463 "\xFC": 'u', 27464 "\u01DC": 'u', 27465 "\u01D8": 'u', 27466 "\u01D6": 'u', 27467 "\u01DA": 'u', 27468 "\u1EE7": 'u', 27469 "\u016F": 'u', 27470 "\u0171": 'u', 27471 "\u01D4": 'u', 27472 "\u0215": 'u', 27473 "\u0217": 'u', 27474 "\u01B0": 'u', 27475 "\u1EEB": 'u', 27476 "\u1EE9": 'u', 27477 "\u1EEF": 'u', 27478 "\u1EED": 'u', 27479 "\u1EF1": 'u', 27480 "\u1EE5": 'u', 27481 "\u1E73": 'u', 27482 "\u0173": 'u', 27483 "\u1E77": 'u', 27484 "\u1E75": 'u', 27485 "\u0289": 'u', 27486 "\u24E5": 'v', 27487 "\uFF56": 'v', 27488 "\u1E7D": 'v', 27489 "\u1E7F": 'v', 27490 "\u028B": 'v', 27491 "\uA75F": 'v', 27492 "\u028C": 'v', 27493 "\uA761": 'vy', 27494 "\u24E6": 'w', 27495 "\uFF57": 'w', 27496 "\u1E81": 'w', 27497 "\u1E83": 'w', 27498 "\u0175": 'w', 27499 "\u1E87": 'w', 27500 "\u1E85": 'w', 27501 "\u1E98": 'w', 27502 "\u1E89": 'w', 27503 "\u2C73": 'w', 27504 "\u24E7": 'x', 27505 "\uFF58": 'x', 27506 "\u1E8B": 'x', 27507 "\u1E8D": 'x', 27508 "\u24E8": 'y', 27509 "\uFF59": 'y', 27510 "\u1EF3": 'y', 27511 "\xFD": 'y', 27512 "\u0177": 'y', 27513 "\u1EF9": 'y', 27514 "\u0233": 'y', 27515 "\u1E8F": 'y', 27516 "\xFF": 'y', 27517 "\u1EF7": 'y', 27518 "\u1E99": 'y', 27519 "\u1EF5": 'y', 27520 "\u01B4": 'y', 27521 "\u024F": 'y', 27522 "\u1EFF": 'y', 27523 "\u24E9": 'z', 27524 "\uFF5A": 'z', 27525 "\u017A": 'z', 27526 "\u1E91": 'z', 27527 "\u017C": 'z', 27528 "\u017E": 'z', 27529 "\u1E93": 'z', 27530 "\u1E95": 'z', 27531 "\u01B6": 'z', 27532 "\u0225": 'z', 27533 "\u0240": 'z', 27534 "\u2C6C": 'z', 27535 "\uA763": 'z', 27536 "\u0386": "\u0391", 27537 "\u0388": "\u0395", 27538 "\u0389": "\u0397", 27539 "\u038A": "\u0399", 27540 "\u03AA": "\u0399", 27541 "\u038C": "\u039F", 27542 "\u038E": "\u03A5", 27543 "\u03AB": "\u03A5", 27544 "\u038F": "\u03A9", 27545 "\u03AC": "\u03B1", 27546 "\u03AD": "\u03B5", 27547 "\u03AE": "\u03B7", 27548 "\u03AF": "\u03B9", 27549 "\u03CA": "\u03B9", 27550 "\u0390": "\u03B9", 27551 "\u03CC": "\u03BF", 27552 "\u03CD": "\u03C5", 27553 "\u03CB": "\u03C5", 27554 "\u03B0": "\u03C5", 27555 "\u03CE": "\u03C9", 27556 "\u03C2": "\u03C3", 27557 "\u2019": '\'' 27558 }; 27559 return diacritics; 27560 }); 27561 S2.define('select2/data/base', ['../utils'], function (Utils) { 27562 function BaseAdapter($element, options) { 27563 BaseAdapter.__super__.constructor.call(this); 27564 } 27565 27566 Utils.Extend(BaseAdapter, Utils.Observable); 27567 27568 BaseAdapter.prototype.current = function (callback) { 27569 throw new Error('The `current` method must be defined in child classes.'); 27570 }; 27571 27572 BaseAdapter.prototype.query = function (params, callback) { 27573 throw new Error('The `query` method must be defined in child classes.'); 27574 }; 27575 27576 BaseAdapter.prototype.bind = function (container, $container) {// Can be implemented in subclasses 27577 }; 27578 27579 BaseAdapter.prototype.destroy = function () {// Can be implemented in subclasses 27580 }; 27581 27582 BaseAdapter.prototype.generateResultId = function (container, data) { 27583 var id = container.id + '-result-'; 27584 id += Utils.generateChars(4); 27585 27586 if (data.id != null) { 27587 id += '-' + data.id.toString(); 27588 } else { 27589 id += '-' + Utils.generateChars(4); 27590 } 27591 27592 return id; 27593 }; 27594 27595 return BaseAdapter; 27596 }); 27597 S2.define('select2/data/select', ['./base', '../utils', 'jquery'], function (BaseAdapter, Utils, $) { 27598 function SelectAdapter($element, options) { 27599 this.$element = $element; 27600 this.options = options; 27601 27602 SelectAdapter.__super__.constructor.call(this); 27603 } 27604 27605 Utils.Extend(SelectAdapter, BaseAdapter); 27606 27607 SelectAdapter.prototype.current = function (callback) { 27608 var data = []; 27609 var self = this; 27610 this.$element.find(':selected').each(function () { 27611 var $option = $(this); 27612 var option = self.item($option); 27613 data.push(option); 27614 }); 27615 callback(data); 27616 }; 27617 27618 SelectAdapter.prototype.select = function (data) { 27619 var self = this; 27620 data.selected = true; // If data.element is a DOM node, use it instead 27621 27622 if ($(data.element).is('option')) { 27623 data.element.selected = true; 27624 this.$element.trigger('input').trigger('change'); 27625 return; 27626 } 27627 27628 if (this.$element.prop('multiple')) { 27629 this.current(function (currentData) { 27630 var val = []; 27631 data = [data]; 27632 data.push.apply(data, currentData); 27633 27634 for (var d = 0; d < data.length; d++) { 27635 var id = data[d].id; 27636 27637 if ($.inArray(id, val) === -1) { 27638 val.push(id); 27639 } 27640 } 27641 27642 self.$element.val(val); 27643 self.$element.trigger('input').trigger('change'); 27644 }); 27645 } else { 27646 var val = data.id; 27647 this.$element.val(val); 27648 this.$element.trigger('input').trigger('change'); 27649 } 27650 }; 27651 27652 SelectAdapter.prototype.unselect = function (data) { 27653 var self = this; 27654 27655 if (!this.$element.prop('multiple')) { 27656 return; 27657 } 27658 27659 data.selected = false; 27660 27661 if ($(data.element).is('option')) { 27662 data.element.selected = false; 27663 this.$element.trigger('input').trigger('change'); 27664 return; 27665 } 27666 27667 this.current(function (currentData) { 27668 var val = []; 27669 27670 for (var d = 0; d < currentData.length; d++) { 27671 var id = currentData[d].id; 27672 27673 if (id !== data.id && $.inArray(id, val) === -1) { 27674 val.push(id); 27675 } 27676 } 27677 27678 self.$element.val(val); 27679 self.$element.trigger('input').trigger('change'); 27680 }); 27681 }; 27682 27683 SelectAdapter.prototype.bind = function (container, $container) { 27684 var self = this; 27685 this.container = container; 27686 container.on('select', function (params) { 27687 self.select(params.data); 27688 }); 27689 container.on('unselect', function (params) { 27690 self.unselect(params.data); 27691 }); 27692 }; 27693 27694 SelectAdapter.prototype.destroy = function () { 27695 // Remove anything added to child elements 27696 this.$element.find('*').each(function () { 27697 // Remove any custom data set by Select2 27698 Utils.RemoveData(this); 27699 }); 27700 }; 27701 27702 SelectAdapter.prototype.query = function (params, callback) { 27703 var data = []; 27704 var self = this; 27705 var $options = this.$element.children(); 27706 $options.each(function () { 27707 var $option = $(this); 27708 27709 if (!$option.is('option') && !$option.is('optgroup')) { 27710 return; 27711 } 27712 27713 var option = self.item($option); 27714 var matches = self.matches(params, option); 27715 27716 if (matches !== null) { 27717 data.push(matches); 27718 } 27719 }); 27720 callback({ 27721 results: data 27722 }); 27723 }; 27724 27725 SelectAdapter.prototype.addOptions = function ($options) { 27726 Utils.appendMany(this.$element, $options); 27727 }; 27728 27729 SelectAdapter.prototype.option = function (data) { 27730 var option; 27731 27732 if (data.children) { 27733 option = document.createElement('optgroup'); 27734 option.label = data.text; 27735 } else { 27736 option = document.createElement('option'); 27737 27738 if (option.textContent !== undefined) { 27739 option.textContent = data.text; 27740 } else { 27741 option.innerText = data.text; 27742 } 27743 } 27744 27745 if (data.id !== undefined) { 27746 option.value = data.id; 27747 } 27748 27749 if (data.disabled) { 27750 option.disabled = true; 27751 } 27752 27753 if (data.selected) { 27754 option.selected = true; 27755 } 27756 27757 if (data.title) { 27758 option.title = data.title; 27759 } 27760 27761 var $option = $(option); 27762 27763 var normalizedData = this._normalizeItem(data); 27764 27765 normalizedData.element = option; // Override the option's data with the combined data 27766 27767 Utils.StoreData(option, 'data', normalizedData); 27768 return $option; 27769 }; 27770 27771 SelectAdapter.prototype.item = function ($option) { 27772 var data = {}; 27773 data = Utils.GetData($option[0], 'data'); 27774 27775 if (data != null) { 27776 return data; 27777 } 27778 27779 if ($option.is('option')) { 27780 data = { 27781 id: $option.val(), 27782 text: $option.text(), 27783 disabled: $option.prop('disabled'), 27784 selected: $option.prop('selected'), 27785 title: $option.prop('title') 27786 }; 27787 } else if ($option.is('optgroup')) { 27788 data = { 27789 text: $option.prop('label'), 27790 children: [], 27791 title: $option.prop('title') 27792 }; 27793 var $children = $option.children('option'); 27794 var children = []; 27795 27796 for (var c = 0; c < $children.length; c++) { 27797 var $child = $($children[c]); 27798 var child = this.item($child); 27799 children.push(child); 27800 } 27801 27802 data.children = children; 27803 } 27804 27805 data = this._normalizeItem(data); 27806 data.element = $option[0]; 27807 Utils.StoreData($option[0], 'data', data); 27808 return data; 27809 }; 27810 27811 SelectAdapter.prototype._normalizeItem = function (item) { 27812 if (item !== Object(item)) { 27813 item = { 27814 id: item, 27815 text: item 27816 }; 27817 } 27818 27819 item = $.extend({}, { 27820 text: '' 27821 }, item); 27822 var defaults = { 27823 selected: false, 27824 disabled: false 27825 }; 27826 27827 if (item.id != null) { 27828 item.id = item.id.toString(); 27829 } 27830 27831 if (item.text != null) { 27832 item.text = item.text.toString(); 27833 } 27834 27835 if (item._resultId == null && item.id && this.container != null) { 27836 item._resultId = this.generateResultId(this.container, item); 27837 } 27838 27839 return $.extend({}, defaults, item); 27840 }; 27841 27842 SelectAdapter.prototype.matches = function (params, data) { 27843 var matcher = this.options.get('matcher'); 27844 return matcher(params, data); 27845 }; 27846 27847 return SelectAdapter; 27848 }); 27849 S2.define('select2/data/array', ['./select', '../utils', 'jquery'], function (SelectAdapter, Utils, $) { 27850 function ArrayAdapter($element, options) { 27851 this._dataToConvert = options.get('data') || []; 27852 27853 ArrayAdapter.__super__.constructor.call(this, $element, options); 27854 } 27855 27856 Utils.Extend(ArrayAdapter, SelectAdapter); 27857 27858 ArrayAdapter.prototype.bind = function (container, $container) { 27859 ArrayAdapter.__super__.bind.call(this, container, $container); 27860 27861 this.addOptions(this.convertToOptions(this._dataToConvert)); 27862 }; 27863 27864 ArrayAdapter.prototype.select = function (data) { 27865 var $option = this.$element.find('option').filter(function (i, elm) { 27866 return elm.value == data.id.toString(); 27867 }); 27868 27869 if ($option.length === 0) { 27870 $option = this.option(data); 27871 this.addOptions($option); 27872 } 27873 27874 ArrayAdapter.__super__.select.call(this, data); 27875 }; 27876 27877 ArrayAdapter.prototype.convertToOptions = function (data) { 27878 var self = this; 27879 var $existing = this.$element.find('option'); 27880 var existingIds = $existing.map(function () { 27881 return self.item($(this)).id; 27882 }).get(); 27883 var $options = []; // Filter out all items except for the one passed in the argument 27884 27885 function onlyItem(item) { 27886 return function () { 27887 return $(this).val() == item.id; 27888 }; 27889 } 27890 27891 for (var d = 0; d < data.length; d++) { 27892 var item = this._normalizeItem(data[d]); // Skip items which were pre-loaded, only merge the data 27893 27894 27895 if ($.inArray(item.id, existingIds) >= 0) { 27896 var $existingOption = $existing.filter(onlyItem(item)); 27897 var existingData = this.item($existingOption); 27898 var newData = $.extend(true, {}, item, existingData); 27899 var $newOption = this.option(newData); 27900 $existingOption.replaceWith($newOption); 27901 continue; 27902 } 27903 27904 var $option = this.option(item); 27905 27906 if (item.children) { 27907 var $children = this.convertToOptions(item.children); 27908 Utils.appendMany($option, $children); 27909 } 27910 27911 $options.push($option); 27912 } 27913 27914 return $options; 27915 }; 27916 27917 return ArrayAdapter; 27918 }); 27919 S2.define('select2/data/ajax', ['./array', '../utils', 'jquery'], function (ArrayAdapter, Utils, $) { 27920 function AjaxAdapter($element, options) { 27921 this.ajaxOptions = this._applyDefaults(options.get('ajax')); 27922 27923 if (this.ajaxOptions.processResults != null) { 27924 this.processResults = this.ajaxOptions.processResults; 27925 } 27926 27927 AjaxAdapter.__super__.constructor.call(this, $element, options); 27928 } 27929 27930 Utils.Extend(AjaxAdapter, ArrayAdapter); 27931 27932 AjaxAdapter.prototype._applyDefaults = function (options) { 27933 var defaults = { 27934 data: function data(params) { 27935 return $.extend({}, params, { 27936 q: params.term 27937 }); 27938 }, 27939 transport: function transport(params, success, failure) { 27940 var $request = $.ajax(params); 27941 $request.then(success); 27942 $request.fail(failure); 27943 return $request; 27944 } 27945 }; 27946 return $.extend({}, defaults, options, true); 27947 }; 27948 27949 AjaxAdapter.prototype.processResults = function (results) { 27950 return results; 27951 }; 27952 27953 AjaxAdapter.prototype.query = function (params, callback) { 27954 var matches = []; 27955 var self = this; 27956 27957 if (this._request != null) { 27958 // JSONP requests cannot always be aborted 27959 if ($.isFunction(this._request.abort)) { 27960 this._request.abort(); 27961 } 27962 27963 this._request = null; 27964 } 27965 27966 var options = $.extend({ 27967 type: 'GET' 27968 }, this.ajaxOptions); 27969 27970 if (typeof options.url === 'function') { 27971 options.url = options.url.call(this.$element, params); 27972 } 27973 27974 if (typeof options.data === 'function') { 27975 options.data = options.data.call(this.$element, params); 27976 } 27977 27978 function request() { 27979 var $request = options.transport(options, function (data) { 27980 var results = self.processResults(data, params); 27981 27982 if (self.options.get('debug') && window.console && console.error) { 27983 // Check to make sure that the response included a `results` key. 27984 if (!results || !results.results || !$.isArray(results.results)) { 27985 console.error('Select2: The AJAX results did not return an array in the ' + '`results` key of the response.'); 27986 } 27987 } 27988 27989 callback(results); 27990 }, function () { 27991 // Attempt to detect if a request was aborted 27992 // Only works if the transport exposes a status property 27993 if ('status' in $request && ($request.status === 0 || $request.status === '0')) { 27994 return; 27995 } 27996 27997 self.trigger('results:message', { 27998 message: 'errorLoading' 27999 }); 28000 }); 28001 self._request = $request; 28002 } 28003 28004 if (this.ajaxOptions.delay && params.term != null) { 28005 if (this._queryTimeout) { 28006 window.clearTimeout(this._queryTimeout); 28007 } 28008 28009 this._queryTimeout = window.setTimeout(request, this.ajaxOptions.delay); 28010 } else { 28011 request(); 28012 } 28013 }; 28014 28015 return AjaxAdapter; 28016 }); 28017 S2.define('select2/data/tags', ['jquery'], function ($) { 28018 function Tags(decorated, $element, options) { 28019 var tags = options.get('tags'); 28020 var createTag = options.get('createTag'); 28021 28022 if (createTag !== undefined) { 28023 this.createTag = createTag; 28024 } 28025 28026 var insertTag = options.get('insertTag'); 28027 28028 if (insertTag !== undefined) { 28029 this.insertTag = insertTag; 28030 } 28031 28032 decorated.call(this, $element, options); 28033 28034 if ($.isArray(tags)) { 28035 for (var t = 0; t < tags.length; t++) { 28036 var tag = tags[t]; 28037 28038 var item = this._normalizeItem(tag); 28039 28040 var $option = this.option(item); 28041 this.$element.append($option); 28042 } 28043 } 28044 } 28045 28046 Tags.prototype.query = function (decorated, params, callback) { 28047 var self = this; 28048 28049 this._removeOldTags(); 28050 28051 if (params.term == null || params.page != null) { 28052 decorated.call(this, params, callback); 28053 return; 28054 } 28055 28056 function wrapper(obj, child) { 28057 var data = obj.results; 28058 28059 for (var i = 0; i < data.length; i++) { 28060 var option = data[i]; 28061 var checkChildren = option.children != null && !wrapper({ 28062 results: option.children 28063 }, true); 28064 var optionText = (option.text || '').toUpperCase(); 28065 var paramsTerm = (params.term || '').toUpperCase(); 28066 var checkText = optionText === paramsTerm; 28067 28068 if (checkText || checkChildren) { 28069 if (child) { 28070 return false; 28071 } 28072 28073 obj.data = data; 28074 callback(obj); 28075 return; 28076 } 28077 } 28078 28079 if (child) { 28080 return true; 28081 } 28082 28083 var tag = self.createTag(params); 28084 28085 if (tag != null) { 28086 var $option = self.option(tag); 28087 $option.attr('data-select2-tag', true); 28088 self.addOptions([$option]); 28089 self.insertTag(data, tag); 28090 } 28091 28092 obj.results = data; 28093 callback(obj); 28094 } 28095 28096 decorated.call(this, params, wrapper); 28097 }; 28098 28099 Tags.prototype.createTag = function (decorated, params) { 28100 var term = $.trim(params.term); 28101 28102 if (term === '') { 28103 return null; 28104 } 28105 28106 return { 28107 id: term, 28108 text: term 28109 }; 28110 }; 28111 28112 Tags.prototype.insertTag = function (_, data, tag) { 28113 data.unshift(tag); 28114 }; 28115 28116 Tags.prototype._removeOldTags = function (_) { 28117 var $options = this.$element.find('option[data-select2-tag]'); 28118 $options.each(function () { 28119 if (this.selected) { 28120 return; 28121 } 28122 28123 $(this).remove(); 28124 }); 28125 }; 28126 28127 return Tags; 28128 }); 28129 S2.define('select2/data/tokenizer', ['jquery'], function ($) { 28130 function Tokenizer(decorated, $element, options) { 28131 var tokenizer = options.get('tokenizer'); 28132 28133 if (tokenizer !== undefined) { 28134 this.tokenizer = tokenizer; 28135 } 28136 28137 decorated.call(this, $element, options); 28138 } 28139 28140 Tokenizer.prototype.bind = function (decorated, container, $container) { 28141 decorated.call(this, container, $container); 28142 this.$search = container.dropdown.$search || container.selection.$search || $container.find('.select2-search__field'); 28143 }; 28144 28145 Tokenizer.prototype.query = function (decorated, params, callback) { 28146 var self = this; 28147 28148 function createAndSelect(data) { 28149 // Normalize the data object so we can use it for checks 28150 var item = self._normalizeItem(data); // Check if the data object already exists as a tag 28151 // Select it if it doesn't 28152 28153 28154 var $existingOptions = self.$element.find('option').filter(function () { 28155 return $(this).val() === item.id; 28156 }); // If an existing option wasn't found for it, create the option 28157 28158 if (!$existingOptions.length) { 28159 var $option = self.option(item); 28160 $option.attr('data-select2-tag', true); 28161 28162 self._removeOldTags(); 28163 28164 self.addOptions([$option]); 28165 } // Select the item, now that we know there is an option for it 28166 28167 28168 select(item); 28169 } 28170 28171 function select(data) { 28172 self.trigger('select', { 28173 data: data 28174 }); 28175 } 28176 28177 params.term = params.term || ''; 28178 var tokenData = this.tokenizer(params, this.options, createAndSelect); 28179 28180 if (tokenData.term !== params.term) { 28181 // Replace the search term if we have the search box 28182 if (this.$search.length) { 28183 this.$search.val(tokenData.term); 28184 this.$search.trigger('focus'); 28185 } 28186 28187 params.term = tokenData.term; 28188 } 28189 28190 decorated.call(this, params, callback); 28191 }; 28192 28193 Tokenizer.prototype.tokenizer = function (_, params, options, callback) { 28194 var separators = options.get('tokenSeparators') || []; 28195 var term = params.term; 28196 var i = 0; 28197 28198 var createTag = this.createTag || function (params) { 28199 return { 28200 id: params.term, 28201 text: params.term 28202 }; 28203 }; 28204 28205 while (i < term.length) { 28206 var termChar = term[i]; 28207 28208 if ($.inArray(termChar, separators) === -1) { 28209 i++; 28210 continue; 28211 } 28212 28213 var part = term.substr(0, i); 28214 var partParams = $.extend({}, params, { 28215 term: part 28216 }); 28217 var data = createTag(partParams); 28218 28219 if (data == null) { 28220 i++; 28221 continue; 28222 } 28223 28224 callback(data); // Reset the term to not include the tokenized portion 28225 28226 term = term.substr(i + 1) || ''; 28227 i = 0; 28228 } 28229 28230 return { 28231 term: term 28232 }; 28233 }; 28234 28235 return Tokenizer; 28236 }); 28237 S2.define('select2/data/minimumInputLength', [], function () { 28238 function MinimumInputLength(decorated, $e, options) { 28239 this.minimumInputLength = options.get('minimumInputLength'); 28240 decorated.call(this, $e, options); 28241 } 28242 28243 MinimumInputLength.prototype.query = function (decorated, params, callback) { 28244 params.term = params.term || ''; 28245 28246 if (params.term.length < this.minimumInputLength) { 28247 this.trigger('results:message', { 28248 message: 'inputTooShort', 28249 args: { 28250 minimum: this.minimumInputLength, 28251 input: params.term, 28252 params: params 28253 } 28254 }); 28255 return; 28256 } 28257 28258 decorated.call(this, params, callback); 28259 }; 28260 28261 return MinimumInputLength; 28262 }); 28263 S2.define('select2/data/maximumInputLength', [], function () { 28264 function MaximumInputLength(decorated, $e, options) { 28265 this.maximumInputLength = options.get('maximumInputLength'); 28266 decorated.call(this, $e, options); 28267 } 28268 28269 MaximumInputLength.prototype.query = function (decorated, params, callback) { 28270 params.term = params.term || ''; 28271 28272 if (this.maximumInputLength > 0 && params.term.length > this.maximumInputLength) { 28273 this.trigger('results:message', { 28274 message: 'inputTooLong', 28275 args: { 28276 maximum: this.maximumInputLength, 28277 input: params.term, 28278 params: params 28279 } 28280 }); 28281 return; 28282 } 28283 28284 decorated.call(this, params, callback); 28285 }; 28286 28287 return MaximumInputLength; 28288 }); 28289 S2.define('select2/data/maximumSelectionLength', [], function () { 28290 function MaximumSelectionLength(decorated, $e, options) { 28291 this.maximumSelectionLength = options.get('maximumSelectionLength'); 28292 decorated.call(this, $e, options); 28293 } 28294 28295 MaximumSelectionLength.prototype.bind = function (decorated, container, $container) { 28296 var self = this; 28297 decorated.call(this, container, $container); 28298 container.on('select', function () { 28299 self._checkIfMaximumSelected(); 28300 }); 28301 }; 28302 28303 MaximumSelectionLength.prototype.query = function (decorated, params, callback) { 28304 var self = this; 28305 28306 this._checkIfMaximumSelected(function () { 28307 decorated.call(self, params, callback); 28308 }); 28309 }; 28310 28311 MaximumSelectionLength.prototype._checkIfMaximumSelected = function (_, successCallback) { 28312 var self = this; 28313 this.current(function (currentData) { 28314 var count = currentData != null ? currentData.length : 0; 28315 28316 if (self.maximumSelectionLength > 0 && count >= self.maximumSelectionLength) { 28317 self.trigger('results:message', { 28318 message: 'maximumSelected', 28319 args: { 28320 maximum: self.maximumSelectionLength 28321 } 28322 }); 28323 return; 28324 } 28325 28326 if (successCallback) { 28327 successCallback(); 28328 } 28329 }); 28330 }; 28331 28332 return MaximumSelectionLength; 28333 }); 28334 S2.define('select2/dropdown', ['jquery', './utils'], function ($, Utils) { 28335 function Dropdown($element, options) { 28336 this.$element = $element; 28337 this.options = options; 28338 28339 Dropdown.__super__.constructor.call(this); 28340 } 28341 28342 Utils.Extend(Dropdown, Utils.Observable); 28343 28344 Dropdown.prototype.render = function () { 28345 var $dropdown = $('<span class="select2-dropdown">' + '<span class="select2-results"></span>' + '</span>'); 28346 $dropdown.attr('dir', this.options.get('dir')); 28347 this.$dropdown = $dropdown; 28348 return $dropdown; 28349 }; 28350 28351 Dropdown.prototype.bind = function () {// Should be implemented in subclasses 28352 }; 28353 28354 Dropdown.prototype.position = function ($dropdown, $container) {// Should be implemented in subclasses 28355 }; 28356 28357 Dropdown.prototype.destroy = function () { 28358 // Remove the dropdown from the DOM 28359 this.$dropdown.remove(); 28360 }; 28361 28362 return Dropdown; 28363 }); 28364 S2.define('select2/dropdown/search', ['jquery', '../utils'], function ($, Utils) { 28365 function Search() {} 28366 28367 Search.prototype.render = function (decorated) { 28368 var $rendered = decorated.call(this); 28369 var $search = $('<span class="select2-search select2-search--dropdown">' + '<input class="select2-search__field" type="search" tabindex="-1"' + ' autocomplete="off" autocorrect="off" autocapitalize="none"' + ' spellcheck="false" role="searchbox" aria-autocomplete="list" />' + '</span>'); 28370 this.$searchContainer = $search; 28371 this.$search = $search.find('input'); 28372 $rendered.prepend($search); 28373 return $rendered; 28374 }; 28375 28376 Search.prototype.bind = function (decorated, container, $container) { 28377 var self = this; 28378 var resultsId = container.id + '-results'; 28379 decorated.call(this, container, $container); 28380 this.$search.on('keydown', function (evt) { 28381 self.trigger('keypress', evt); 28382 self._keyUpPrevented = evt.isDefaultPrevented(); 28383 }); // Workaround for browsers which do not support the `input` event 28384 // This will prevent double-triggering of events for browsers which support 28385 // both the `keyup` and `input` events. 28386 28387 this.$search.on('input', function (evt) { 28388 // Unbind the duplicated `keyup` event 28389 $(this).off('keyup'); 28390 }); 28391 this.$search.on('keyup input', function (evt) { 28392 self.handleSearch(evt); 28393 }); 28394 container.on('open', function () { 28395 self.$search.attr('tabindex', 0); 28396 self.$search.attr('aria-controls', resultsId); 28397 self.$search.trigger('focus'); 28398 window.setTimeout(function () { 28399 self.$search.trigger('focus'); 28400 }, 0); 28401 }); 28402 container.on('close', function () { 28403 self.$search.attr('tabindex', -1); 28404 self.$search.removeAttr('aria-controls'); 28405 self.$search.removeAttr('aria-activedescendant'); 28406 self.$search.val(''); 28407 self.$search.trigger('blur'); 28408 }); 28409 container.on('focus', function () { 28410 if (!container.isOpen()) { 28411 self.$search.trigger('focus'); 28412 } 28413 }); 28414 container.on('results:all', function (params) { 28415 if (params.query.term == null || params.query.term === '') { 28416 var showSearch = self.showSearch(params); 28417 28418 if (showSearch) { 28419 self.$searchContainer.removeClass('select2-search--hide'); 28420 } else { 28421 self.$searchContainer.addClass('select2-search--hide'); 28422 } 28423 } 28424 }); 28425 container.on('results:focus', function (params) { 28426 if (params.data._resultId) { 28427 self.$search.attr('aria-activedescendant', params.data._resultId); 28428 } else { 28429 self.$search.removeAttr('aria-activedescendant'); 28430 } 28431 }); 28432 }; 28433 28434 Search.prototype.handleSearch = function (evt) { 28435 if (!this._keyUpPrevented) { 28436 var input = this.$search.val(); 28437 this.trigger('query', { 28438 term: input 28439 }); 28440 } 28441 28442 this._keyUpPrevented = false;
vendor: 12,192 bytes, lines 28443-28802
28443 }; 28444 28445 Search.prototype.showSearch = function (_, params) { 28446 return true; 28447 }; 28448 28449 return Search; 28450 }); 28451 S2.define('select2/dropdown/hidePlaceholder', [], function () { 28452 function HidePlaceholder(decorated, $element, options, dataAdapter) { 28453 this.placeholder = this.normalizePlaceholder(options.get('placeholder')); 28454 decorated.call(this, $element, options, dataAdapter); 28455 } 28456 28457 HidePlaceholder.prototype.append = function (decorated, data) { 28458 data.results = this.removePlaceholder(data.results); 28459 decorated.call(this, data); 28460 }; 28461 28462 HidePlaceholder.prototype.normalizePlaceholder = function (_, placeholder) { 28463 if (typeof placeholder === 'string') { 28464 placeholder = { 28465 id: '', 28466 text: placeholder 28467 }; 28468 } 28469 28470 return placeholder; 28471 }; 28472 28473 HidePlaceholder.prototype.removePlaceholder = function (_, data) { 28474 var modifiedData = data.slice(0); 28475 28476 for (var d = data.length - 1; d >= 0; d--) { 28477 var item = data[d]; 28478 28479 if (this.placeholder.id === item.id) { 28480 modifiedData.splice(d, 1); 28481 } 28482 } 28483 28484 return modifiedData; 28485 }; 28486 28487 return HidePlaceholder; 28488 }); 28489 S2.define('select2/dropdown/infiniteScroll', ['jquery'], function ($) { 28490 function InfiniteScroll(decorated, $element, options, dataAdapter) { 28491 this.lastParams = {}; 28492 decorated.call(this, $element, options, dataAdapter); 28493 this.$loadingMore = this.createLoadingMore(); 28494 this.loading = false; 28495 } 28496 28497 InfiniteScroll.prototype.append = function (decorated, data) { 28498 this.$loadingMore.remove(); 28499 this.loading = false; 28500 decorated.call(this, data); 28501 28502 if (this.showLoadingMore(data)) { 28503 this.$results.append(this.$loadingMore); 28504 this.loadMoreIfNeeded(); 28505 } 28506 }; 28507 28508 InfiniteScroll.prototype.bind = function (decorated, container, $container) { 28509 var self = this; 28510 decorated.call(this, container, $container); 28511 container.on('query', function (params) { 28512 self.lastParams = params; 28513 self.loading = true; 28514 }); 28515 container.on('query:append', function (params) { 28516 self.lastParams = params; 28517 self.loading = true; 28518 }); 28519 this.$results.on('scroll', this.loadMoreIfNeeded.bind(this)); 28520 }; 28521 28522 InfiniteScroll.prototype.loadMoreIfNeeded = function () { 28523 var isLoadMoreVisible = $.contains(document.documentElement, this.$loadingMore[0]); 28524 28525 if (this.loading || !isLoadMoreVisible) { 28526 return; 28527 } 28528 28529 var currentOffset = this.$results.offset().top + this.$results.outerHeight(false); 28530 var loadingMoreOffset = this.$loadingMore.offset().top + this.$loadingMore.outerHeight(false); 28531 28532 if (currentOffset + 50 >= loadingMoreOffset) { 28533 this.loadMore(); 28534 } 28535 }; 28536 28537 InfiniteScroll.prototype.loadMore = function () { 28538 this.loading = true; 28539 var params = $.extend({}, { 28540 page: 1 28541 }, this.lastParams); 28542 params.page++; 28543 this.trigger('query:append', params); 28544 }; 28545 28546 InfiniteScroll.prototype.showLoadingMore = function (_, data) { 28547 return data.pagination && data.pagination.more; 28548 }; 28549 28550 InfiniteScroll.prototype.createLoadingMore = function () { 28551 var $option = $('<li ' + 'class="select2-results__option select2-results__option--load-more"' + 'role="option" aria-disabled="true"></li>'); 28552 var message = this.options.get('translations').get('loadingMore'); 28553 $option.html(message(this.lastParams)); 28554 return $option; 28555 }; 28556 28557 return InfiniteScroll; 28558 }); 28559 S2.define('select2/dropdown/attachBody', ['jquery', '../utils'], function ($, Utils) { 28560 function AttachBody(decorated, $element, options) { 28561 this.$dropdownParent = $(options.get('dropdownParent') || document.body); 28562 decorated.call(this, $element, options); 28563 } 28564 28565 AttachBody.prototype.bind = function (decorated, container, $container) { 28566 var self = this; 28567 decorated.call(this, container, $container); 28568 container.on('open', function () { 28569 self._showDropdown(); 28570 28571 self._attachPositioningHandler(container); // Must bind after the results handlers to ensure correct sizing 28572 28573 28574 self._bindContainerResultHandlers(container); 28575 }); 28576 container.on('close', function () { 28577 self._hideDropdown(); 28578 28579 self._detachPositioningHandler(container); 28580 }); 28581 this.$dropdownContainer.on('mousedown', function (evt) { 28582 evt.stopPropagation(); 28583 }); 28584 }; 28585 28586 AttachBody.prototype.destroy = function (decorated) { 28587 decorated.call(this); 28588 this.$dropdownContainer.remove(); 28589 }; 28590 28591 AttachBody.prototype.position = function (decorated, $dropdown, $container) { 28592 // Clone all of the container classes 28593 $dropdown.attr('class', $container.attr('class')); 28594 $dropdown.removeClass('select2'); 28595 $dropdown.addClass('select2-container--open'); 28596 $dropdown.css({ 28597 position: 'absolute', 28598 top: -999999 28599 }); 28600 this.$container = $container; 28601 }; 28602 28603 AttachBody.prototype.render = function (decorated) { 28604 var $container = $('<span></span>'); 28605 var $dropdown = decorated.call(this); 28606 $container.append($dropdown); 28607 this.$dropdownContainer = $container; 28608 return $container; 28609 }; 28610 28611 AttachBody.prototype._hideDropdown = function (decorated) { 28612 this.$dropdownContainer.detach(); 28613 }; 28614 28615 AttachBody.prototype._bindContainerResultHandlers = function (decorated, container) { 28616 // These should only be bound once 28617 if (this._containerResultsHandlersBound) { 28618 return; 28619 } 28620 28621 var self = this; 28622 container.on('results:all', function () { 28623 self._positionDropdown(); 28624 28625 self._resizeDropdown(); 28626 }); 28627 container.on('results:append', function () { 28628 self._positionDropdown(); 28629 28630 self._resizeDropdown(); 28631 }); 28632 container.on('results:message', function () { 28633 self._positionDropdown(); 28634 28635 self._resizeDropdown(); 28636 }); 28637 container.on('select', function () { 28638 self._positionDropdown(); 28639 28640 self._resizeDropdown(); 28641 }); 28642 container.on('unselect', function () { 28643 self._positionDropdown(); 28644 28645 self._resizeDropdown(); 28646 }); 28647 this._containerResultsHandlersBound = true; 28648 }; 28649 28650 AttachBody.prototype._attachPositioningHandler = function (decorated, container) { 28651 var self = this; 28652 var scrollEvent = 'scroll.select2.' + container.id; 28653 var resizeEvent = 'resize.select2.' + container.id; 28654 var orientationEvent = 'orientationchange.select2.' + container.id; 28655 var $watchers = this.$container.parents().filter(Utils.hasScroll); 28656 $watchers.each(function () { 28657 Utils.StoreData(this, 'select2-scroll-position', { 28658 x: $(this).scrollLeft(), 28659 y: $(this).scrollTop() 28660 }); 28661 }); 28662 $watchers.on(scrollEvent, function (ev) { 28663 var position = Utils.GetData(this, 'select2-scroll-position'); 28664 $(this).scrollTop(position.y); 28665 }); 28666 $(window).on(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent, function (e) { 28667 self._positionDropdown(); 28668 28669 self._resizeDropdown(); 28670 }); 28671 }; 28672 28673 AttachBody.prototype._detachPositioningHandler = function (decorated, container) { 28674 var scrollEvent = 'scroll.select2.' + container.id; 28675 var resizeEvent = 'resize.select2.' + container.id; 28676 var orientationEvent = 'orientationchange.select2.' + container.id; 28677 var $watchers = this.$container.parents().filter(Utils.hasScroll); 28678 $watchers.off(scrollEvent); 28679 $(window).off(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent); 28680 }; 28681 28682 AttachBody.prototype._positionDropdown = function () { 28683 var $window = $(window); 28684 var isCurrentlyAbove = this.$dropdown.hasClass('select2-dropdown--above'); 28685 var isCurrentlyBelow = this.$dropdown.hasClass('select2-dropdown--below'); 28686 var newDirection = null; 28687 var offset = this.$container.offset(); 28688 offset.bottom = offset.top + this.$container.outerHeight(false); 28689 var container = { 28690 height: this.$container.outerHeight(false) 28691 }; 28692 container.top = offset.top; 28693 container.bottom = offset.top + container.height; 28694 var dropdown = { 28695 height: this.$dropdown.outerHeight(false) 28696 }; 28697 var viewport = { 28698 top: $window.scrollTop(), 28699 bottom: $window.scrollTop() + $window.height() 28700 }; 28701 var enoughRoomAbove = viewport.top < offset.top - dropdown.height; 28702 var enoughRoomBelow = viewport.bottom > offset.bottom + dropdown.height; 28703 var css = { 28704 left: offset.left, 28705 top: container.bottom 28706 }; // Determine what the parent element is to use for calculating the offset 28707 28708 var $offsetParent = this.$dropdownParent; // For statically positioned elements, we need to get the element 28709 // that is determining the offset 28710 28711 if ($offsetParent.css('position') === 'static') { 28712 $offsetParent = $offsetParent.offsetParent(); 28713 } 28714 28715 var parentOffset = { 28716 top: 0, 28717 left: 0 28718 }; 28719 28720 if ($.contains(document.body, $offsetParent[0]) || $offsetParent[0].isConnected) { 28721 parentOffset = $offsetParent.offset(); 28722 } 28723 28724 css.top -= parentOffset.top; 28725 css.left -= parentOffset.left; 28726 28727 if (!isCurrentlyAbove && !isCurrentlyBelow) { 28728 newDirection = 'below'; 28729 } 28730 28731 if (!enoughRoomBelow && enoughRoomAbove && !isCurrentlyAbove) { 28732 newDirection = 'above'; 28733 } else if (!enoughRoomAbove && enoughRoomBelow && isCurrentlyAbove) { 28734 newDirection = 'below'; 28735 } 28736 28737 if (newDirection == 'above' || isCurrentlyAbove && newDirection !== 'below') { 28738 css.top = container.top - parentOffset.top - dropdown.height; 28739 } 28740 28741 if (newDirection != null) { 28742 this.$dropdown.removeClass('select2-dropdown--below select2-dropdown--above').addClass('select2-dropdown--' + newDirection); 28743 this.$container.removeClass('select2-container--below select2-container--above').addClass('select2-container--' + newDirection); 28744 } 28745 28746 this.$dropdownContainer.css(css); 28747 }; 28748 28749 AttachBody.prototype._resizeDropdown = function () { 28750 var css = { 28751 width: this.$container.outerWidth(false) + 'px' 28752 }; 28753 28754 if (this.options.get('dropdownAutoWidth')) { 28755 css.minWidth = css.width; 28756 css.position = 'relative'; 28757 css.width = 'auto'; 28758 } 28759 28760 this.$dropdown.css(css); 28761 }; 28762 28763 AttachBody.prototype._showDropdown = function (decorated) { 28764 this.$dropdownContainer.appendTo(this.$dropdownParent); 28765 28766 this._positionDropdown(); 28767 28768 this._resizeDropdown(); 28769 }; 28770 28771 return AttachBody; 28772 }); 28773 S2.define('select2/dropdown/minimumResultsForSearch', [], function () { 28774 function countResults(data) { 28775 var count = 0; 28776 28777 for (var d = 0; d < data.length; d++) { 28778 var item = data[d]; 28779 28780 if (item.children) { 28781 count += countResults(item.children); 28782 } else { 28783 count++; 28784 } 28785 } 28786 28787 return count; 28788 } 28789 28790 function MinimumResultsForSearch(decorated, $element, options, dataAdapter) { 28791 this.minimumResultsForSearch = options.get('minimumResultsForSearch'); 28792 28793 if (this.minimumResultsForSearch < 0) { 28794 this.minimumResultsForSearch = Infinity; 28795 } 28796 28797 decorated.call(this, $element, options, dataAdapter); 28798 } 28799 28800 MinimumResultsForSearch.prototype.showSearch = function (decorated, params) { 28801 if (countResults(params.data.results) < this.minimumResultsForSearch) { 28802 return false;
vendor: 7,152 bytes, lines 28803-28992
28803 } 28804 28805 return decorated.call(this, params); 28806 }; 28807 28808 return MinimumResultsForSearch; 28809 }); 28810 S2.define('select2/dropdown/selectOnClose', ['../utils'], function (Utils) { 28811 function SelectOnClose() {} 28812 28813 SelectOnClose.prototype.bind = function (decorated, container, $container) { 28814 var self = this; 28815 decorated.call(this, container, $container); 28816 container.on('close', function (params) { 28817 self._handleSelectOnClose(params); 28818 }); 28819 }; 28820 28821 SelectOnClose.prototype._handleSelectOnClose = function (_, params) { 28822 if (params && params.originalSelect2Event != null) { 28823 var event = params.originalSelect2Event; // Don't select an item if the close event was triggered from a select or 28824 // unselect event 28825 28826 if (event._type === 'select' || event._type === 'unselect') { 28827 return; 28828 } 28829 } 28830 28831 var $highlightedResults = this.getHighlightedResults(); // Only select highlighted results 28832 28833 if ($highlightedResults.length < 1) { 28834 return; 28835 } 28836 28837 var data = Utils.GetData($highlightedResults[0], 'data'); // Don't re-select already selected resulte 28838 28839 if (data.element != null && data.element.selected || data.element == null && data.selected) { 28840 return; 28841 } 28842 28843 this.trigger('select', { 28844 data: data 28845 }); 28846 }; 28847 28848 return SelectOnClose; 28849 }); 28850 S2.define('select2/dropdown/closeOnSelect', [], function () { 28851 function CloseOnSelect() {} 28852 28853 CloseOnSelect.prototype.bind = function (decorated, container, $container) { 28854 var self = this; 28855 decorated.call(this, container, $container); 28856 container.on('select', function (evt) { 28857 self._selectTriggered(evt); 28858 }); 28859 container.on('unselect', function (evt) { 28860 self._selectTriggered(evt); 28861 }); 28862 }; 28863 28864 CloseOnSelect.prototype._selectTriggered = function (_, evt) { 28865 var originalEvent = evt.originalEvent; // Don't close if the control key is being held 28866 28867 if (originalEvent && (originalEvent.ctrlKey || originalEvent.metaKey)) { 28868 return; 28869 } 28870 28871 this.trigger('close', { 28872 originalEvent: originalEvent, 28873 originalSelect2Event: evt 28874 }); 28875 }; 28876 28877 return CloseOnSelect; 28878 }); 28879 S2.define('select2/i18n/en', [], function () { 28880 // English 28881 return { 28882 errorLoading: function errorLoading() { 28883 return 'The results could not be loaded.'; 28884 }, 28885 inputTooLong: function inputTooLong(args) { 28886 var overChars = args.input.length - args.maximum; 28887 var message = 'Please delete ' + overChars + ' character'; 28888 28889 if (overChars != 1) { 28890 message += 's'; 28891 } 28892 28893 return message; 28894 }, 28895 inputTooShort: function inputTooShort(args) { 28896 var remainingChars = args.minimum - args.input.length; 28897 var message = 'Please enter ' + remainingChars + ' or more characters'; 28898 return message; 28899 }, 28900 loadingMore: function loadingMore() { 28901 return 'Loading more resultsâ¦'; 28902 }, 28903 maximumSelected: function maximumSelected(args) { 28904 var message = 'You can only select ' + args.maximum + ' item'; 28905 28906 if (args.maximum != 1) { 28907 message += 's'; 28908 } 28909 28910 return message; 28911 }, 28912 noResults: function noResults() { 28913 return 'No results found'; 28914 }, 28915 searching: function searching() { 28916 return 'Searchingâ¦'; 28917 }, 28918 removeAllItems: function removeAllItems() { 28919 return 'Remove all items'; 28920 } 28921 }; 28922 }); 28923 S2.define('select2/defaults', ['jquery', 'require', './results', './selection/single', './selection/multiple', './selection/placeholder', './selection/allowClear', './selection/search', './selection/eventRelay', './utils', './translation', './diacritics', './data/select', './data/array', './data/ajax', './data/tags', './data/tokenizer', './data/minimumInputLength', './data/maximumInputLength', './data/maximumSelectionLength', './dropdown', './dropdown/search', './dropdown/hidePlaceholder', './dropdown/infiniteScroll', './dropdown/attachBody', './dropdown/minimumResultsForSearch', './dropdown/selectOnClose', './dropdown/closeOnSelect', './i18n/en'], function ($, require, ResultsList, SingleSelection, MultipleSelection, Placeholder, AllowClear, SelectionSearch, EventRelay, Utils, Translation, DIACRITICS, SelectData, ArrayData, AjaxData, Tags, Tokenizer, MinimumInputLength, MaximumInputLength, MaximumSelectionLength, Dropdown, DropdownSearch, HidePlaceholder, InfiniteScroll, AttachBody, MinimumResultsForSearch, SelectOnClose, CloseOnSelect, EnglishTranslation) { 28924 function Defaults() { 28925 this.reset(); 28926 } 28927 28928 Defaults.prototype.apply = function (options) { 28929 options = $.extend(true, {}, this.defaults, options); 28930 28931 if (options.dataAdapter == null) { 28932 if (options.ajax != null) { 28933 options.dataAdapter = AjaxData; 28934 } else if (options.data != null) { 28935 options.dataAdapter = ArrayData; 28936 } else { 28937 options.dataAdapter = SelectData; 28938 } 28939 28940 if (options.minimumInputLength > 0) { 28941 options.dataAdapter = Utils.Decorate(options.dataAdapter, MinimumInputLength); 28942 } 28943 28944 if (options.maximumInputLength > 0) { 28945 options.dataAdapter = Utils.Decorate(options.dataAdapter, MaximumInputLength); 28946 } 28947 28948 if (options.maximumSelectionLength > 0) { 28949 options.dataAdapter = Utils.Decorate(options.dataAdapter, MaximumSelectionLength); 28950 } 28951 28952 if (options.tags) { 28953 options.dataAdapter = Utils.Decorate(options.dataAdapter, Tags); 28954 } 28955 28956 if (options.tokenSeparators != null || options.tokenizer != null) { 28957 options.dataAdapter = Utils.Decorate(options.dataAdapter, Tokenizer); 28958 } 28959 28960 if (options.query != null) { 28961 var Query = require(options.amdBase + 'compat/query'); 28962 28963 options.dataAdapter = Utils.Decorate(options.dataAdapter, Query); 28964 } 28965 28966 if (options.initSelection != null) { 28967 var InitSelection = require(options.amdBase + 'compat/initSelection'); 28968 28969 options.dataAdapter = Utils.Decorate(options.dataAdapter, InitSelection); 28970 } 28971 } 28972 28973 if (options.resultsAdapter == null) { 28974 options.resultsAdapter = ResultsList; 28975 28976 if (options.ajax != null) { 28977 options.resultsAdapter = Utils.Decorate(options.resultsAdapter, InfiniteScroll); 28978 } 28979 28980 if (options.placeholder != null) { 28981 options.resultsAdapter = Utils.Decorate(options.resultsAdapter, HidePlaceholder); 28982 } 28983 28984 if (options.selectOnClose) { 28985 options.resultsAdapter = Utils.Decorate(options.resultsAdapter, SelectOnClose); 28986 } 28987 } 28988 28989 if (options.dropdownAdapter == null) { 28990 if (options.multiple) { 28991 options.dropdownAdapter = Dropdown; 28992 } else {
28993 var SearchableDropdown = Utils.Decorate(Dropdown, DropdownSearch); 28994 options.dropdownAdapter = SearchableDropdown; 28995 } 28996 28997 if (options.minimumResultsForSearch !== 0) { 28998 options.dropdownAdapter = Utils.Decorate(options.dropdownAdapter, MinimumResultsForSearch); 28999 } 29000 29001 if (options.closeOnSelect) { 29002 options.dropdownAdapter = Utils.Decorate(options.dropdownAdapter, CloseOnSelect); 29003 } 29004 29005 if (options.dropdownCssClass != null || options.dropdownCss != null || options.adaptDropdownCssClass != null) { 29006 var DropdownCSS = require(options.amdBase + 'compat/dropdownCss'); 29007 29008 options.dropdownAdapter = Utils.Decorate(options.dropdownAdapter, DropdownCSS); 29009 } 29010 29011 options.dropdownAdapter = Utils.Decorate(options.dropdownAdapter, AttachBody); 29012 } 29013 29014 if (options.selectionAdapter == null) { 29015 if (options.multiple) { 29016 options.selectionAdapter = MultipleSelection; 29017 } else { 29018 options.selectionAdapter = SingleSelection; 29019 } // Add the placeholder mixin if a placeholder was specified 29020 29021 29022 if (options.placeholder != null) { 29023 options.selectionAdapter = Utils.Decorate(options.selectionAdapter, Placeholder); 29024 } 29025 29026 if (options.allowClear) { 29027 options.selectionAdapter = Utils.Decorate(options.selectionAdapter, AllowClear); 29028 } 29029 29030 if (options.multiple) { 29031 options.selectionAdapter = Utils.Decorate(options.selectionAdapter, SelectionSearch); 29032 } 29033 29034 if (options.containerCssClass != null || options.containerCss != null || options.adaptContainerCssClass != null) { 29035 var ContainerCSS = require(options.amdBase + 'compat/containerCss'); 29036 29037 options.selectionAdapter = Utils.Decorate(options.selectionAdapter, ContainerCSS); 29038 } 29039 29040 options.selectionAdapter = Utils.Decorate(options.selectionAdapter, EventRelay); 29041 } // If the defaults were not previously applied from an element, it is 29042 // possible for the language option to have not been resolved 29043 29044 29045 options.language = this._resolveLanguage(options.language); // Always fall back to English since it will always be complete 29046 29047 options.language.push('en'); 29048 var uniqueLanguages = []; 29049 29050 for (var l = 0; l < options.language.length; l++) { 29051 var language = options.language[l]; 29052 29053 if (uniqueLanguages.indexOf(language) === -1) { 29054 uniqueLanguages.push(language); 29055 } 29056 } 29057 29058 options.language = uniqueLanguages; 29059 options.translations = this._processTranslations(options.language, options.debug); 29060 return options; 29061 }; 29062 29063 Defaults.prototype.reset = function () { 29064 function stripDiacritics(text) { 29065 // Used 'uni range + named function' from http://jsperf.com/diacritics/18 29066 function match(a) { 29067 return DIACRITICS[a] || a; 29068 } 29069
vendor: 16,384 bytes, lines 29070-29554
29070 return text.replace(/[^\u0000-\u007E]/g, match); 29071 } 29072 29073 function matcher(params, data) { 29074 // Always return the object if there is nothing to compare 29075 if ($.trim(params.term) === '') { 29076 return data; 29077 } // Do a recursive check for options with children 29078 29079 29080 if (data.children && data.children.length > 0) { 29081 // Clone the data object if there are children 29082 // This is required as we modify the object to remove any non-matches 29083 var match = $.extend(true, {}, data); // Check each child of the option 29084 29085 for (var c = data.children.length - 1; c >= 0; c--) { 29086 var child = data.children[c]; 29087 var matches = matcher(params, child); // If there wasn't a match, remove the object in the array 29088 29089 if (matches == null) { 29090 match.children.splice(c, 1); 29091 } 29092 } // If any children matched, return the new object 29093 29094 29095 if (match.children.length > 0) { 29096 return match; 29097 } // If there were no matching children, check just the plain object 29098 29099 29100 return matcher(params, match); 29101 } 29102 29103 var original = stripDiacritics(data.text).toUpperCase(); 29104 var term = stripDiacritics(params.term).toUpperCase(); // Check if the text contains the term 29105 29106 if (original.indexOf(term) > -1) { 29107 return data; 29108 } // If it doesn't contain the term, don't return anything 29109 29110 29111 return null; 29112 } 29113 29114 this.defaults = { 29115 amdBase: './', 29116 amdLanguageBase: './i18n/', 29117 closeOnSelect: true, 29118 debug: false, 29119 dropdownAutoWidth: false, 29120 escapeMarkup: Utils.escapeMarkup, 29121 language: {}, 29122 matcher: matcher, 29123 minimumInputLength: 0, 29124 maximumInputLength: 0, 29125 maximumSelectionLength: 0, 29126 minimumResultsForSearch: 0, 29127 selectOnClose: false, 29128 scrollAfterSelect: false, 29129 sorter: function sorter(data) { 29130 return data; 29131 }, 29132 templateResult: function templateResult(result) { 29133 return result.text; 29134 }, 29135 templateSelection: function templateSelection(selection) { 29136 return selection.text; 29137 }, 29138 theme: 'default', 29139 width: 'resolve' 29140 }; 29141 }; 29142 29143 Defaults.prototype.applyFromElement = function (options, $element) { 29144 var optionLanguage = options.language; 29145 var defaultLanguage = this.defaults.language; 29146 var elementLanguage = $element.prop('lang'); 29147 var parentLanguage = $element.closest('[lang]').prop('lang'); 29148 var languages = Array.prototype.concat.call(this._resolveLanguage(elementLanguage), this._resolveLanguage(optionLanguage), this._resolveLanguage(defaultLanguage), this._resolveLanguage(parentLanguage)); 29149 options.language = languages; 29150 return options; 29151 }; 29152 29153 Defaults.prototype._resolveLanguage = function (language) { 29154 if (!language) { 29155 return []; 29156 } 29157 29158 if ($.isEmptyObject(language)) { 29159 return []; 29160 } 29161 29162 if ($.isPlainObject(language)) { 29163 return [language]; 29164 } 29165 29166 var languages; 29167 29168 if (!$.isArray(language)) { 29169 languages = [language]; 29170 } else { 29171 languages = language; 29172 } 29173 29174 var resolvedLanguages = []; 29175 29176 for (var l = 0; l < languages.length; l++) { 29177 resolvedLanguages.push(languages[l]); 29178 29179 if (typeof languages[l] === 'string' && languages[l].indexOf('-') > 0) { 29180 // Extract the region information if it is included 29181 var languageParts = languages[l].split('-'); 29182 var baseLanguage = languageParts[0]; 29183 resolvedLanguages.push(baseLanguage); 29184 } 29185 } 29186 29187 return resolvedLanguages; 29188 }; 29189 29190 Defaults.prototype._processTranslations = function (languages, debug) { 29191 var translations = new Translation(); 29192 29193 for (var l = 0; l < languages.length; l++) { 29194 var languageData = new Translation(); 29195 var language = languages[l]; 29196 29197 if (typeof language === 'string') { 29198 try { 29199 // Try to load it with the original name 29200 languageData = Translation.loadPath(language); 29201 } catch (e) { 29202 try { 29203 // If we couldn't load it, check if it wasn't the full path 29204 language = this.defaults.amdLanguageBase + language; 29205 languageData = Translation.loadPath(language); 29206 } catch (ex) { 29207 // The translation could not be loaded at all. Sometimes this is 29208 // because of a configuration problem, other times this can be 29209 // because of how Select2 helps load all possible translation files 29210 if (debug && window.console && console.warn) { 29211 console.warn('Select2: The language file for "' + language + '" could ' + 'not be automatically loaded. A fallback will be used instead.'); 29212 } 29213 } 29214 } 29215 } else if ($.isPlainObject(language)) { 29216 languageData = new Translation(language); 29217 } else { 29218 languageData = language; 29219 } 29220 29221 translations.extend(languageData); 29222 } 29223 29224 return translations; 29225 }; 29226 29227 Defaults.prototype.set = function (key, value) { 29228 var camelKey = $.camelCase(key); 29229 var data = {}; 29230 data[camelKey] = value; 29231 29232 var convertedData = Utils._convertData(data); 29233 29234 $.extend(true, this.defaults, convertedData); 29235 }; 29236 29237 var defaults = new Defaults(); 29238 return defaults; 29239 }); 29240 S2.define('select2/options', ['require', 'jquery', './defaults', './utils'], function (require, $, Defaults, Utils) { 29241 function Options(options, $element) { 29242 this.options = options; 29243 29244 if ($element != null) { 29245 this.fromElement($element); 29246 } 29247 29248 if ($element != null) { 29249 this.options = Defaults.applyFromElement(this.options, $element); 29250 } 29251 29252 this.options = Defaults.apply(this.options); 29253 29254 if ($element && $element.is('input')) { 29255 var InputCompat = require(this.get('amdBase') + 'compat/inputData'); 29256 29257 this.options.dataAdapter = Utils.Decorate(this.options.dataAdapter, InputCompat); 29258 } 29259 } 29260 29261 Options.prototype.fromElement = function ($e) { 29262 var excludedData = ['select2']; 29263 29264 if (this.options.multiple == null) { 29265 this.options.multiple = $e.prop('multiple'); 29266 } 29267 29268 if (this.options.disabled == null) { 29269 this.options.disabled = $e.prop('disabled'); 29270 } 29271 29272 if (this.options.dir == null) { 29273 if ($e.prop('dir')) { 29274 this.options.dir = $e.prop('dir'); 29275 } else if ($e.closest('[dir]').prop('dir')) { 29276 this.options.dir = $e.closest('[dir]').prop('dir'); 29277 } else { 29278 this.options.dir = 'ltr'; 29279 } 29280 } 29281 29282 $e.prop('disabled', this.options.disabled); 29283 $e.prop('multiple', this.options.multiple); 29284 29285 if (Utils.GetData($e[0], 'select2Tags')) { 29286 if (this.options.debug && window.console && console.warn) { 29287 console.warn('Select2: The `data-select2-tags` attribute has been changed to ' + 'use the `data-data` and `data-tags="true"` attributes and will be ' + 'removed in future versions of Select2.'); 29288 } 29289 29290 Utils.StoreData($e[0], 'data', Utils.GetData($e[0], 'select2Tags')); 29291 Utils.StoreData($e[0], 'tags', true); 29292 } 29293 29294 if (Utils.GetData($e[0], 'ajaxUrl')) { 29295 if (this.options.debug && window.console && console.warn) { 29296 console.warn('Select2: The `data-ajax-url` attribute has been changed to ' + '`data-ajax--url` and support for the old attribute will be removed' + ' in future versions of Select2.'); 29297 } 29298 29299 $e.attr('ajax--url', Utils.GetData($e[0], 'ajaxUrl')); 29300 Utils.StoreData($e[0], 'ajax-Url', Utils.GetData($e[0], 'ajaxUrl')); 29301 } 29302 29303 var dataset = {}; 29304 29305 function upperCaseLetter(_, letter) { 29306 return letter.toUpperCase(); 29307 } // Pre-load all of the attributes which are prefixed with `data-` 29308 29309 29310 for (var attr = 0; attr < $e[0].attributes.length; attr++) { 29311 var attributeName = $e[0].attributes[attr].name; 29312 var prefix = 'data-'; 29313 29314 if (attributeName.substr(0, prefix.length) == prefix) { 29315 // Get the contents of the attribute after `data-` 29316 var dataName = attributeName.substring(prefix.length); // Get the data contents from the consistent source 29317 // This is more than likely the jQuery data helper 29318 29319 var dataValue = Utils.GetData($e[0], dataName); // camelCase the attribute name to match the spec 29320 29321 var camelDataName = dataName.replace(/-([a-z])/g, upperCaseLetter); // Store the data attribute contents into the dataset since 29322 29323 dataset[camelDataName] = dataValue; 29324 } 29325 } // Prefer the element's `dataset` attribute if it exists 29326 // jQuery 1.x does not correctly handle data attributes with multiple dashes 29327 29328 29329 if ($.fn.jquery && $.fn.jquery.substr(0, 2) == '1.' && $e[0].dataset) { 29330 dataset = $.extend(true, {}, $e[0].dataset, dataset); 29331 } // Prefer our internal data cache if it exists 29332 29333 29334 var data = $.extend(true, {}, Utils.GetData($e[0]), dataset); 29335 data = Utils._convertData(data); 29336 29337 for (var key in data) { 29338 if ($.inArray(key, excludedData) > -1) { 29339 continue; 29340 } 29341 29342 if ($.isPlainObject(this.options[key])) { 29343 $.extend(this.options[key], data[key]); 29344 } else { 29345 this.options[key] = data[key]; 29346 } 29347 } 29348 29349 return this; 29350 }; 29351 29352 Options.prototype.get = function (key) { 29353 return this.options[key]; 29354 }; 29355 29356 Options.prototype.set = function (key, val) { 29357 this.options[key] = val; 29358 }; 29359 29360 return Options; 29361 }); 29362 S2.define('select2/core', ['jquery', './options', './utils', './keys'], function ($, Options, Utils, KEYS) { 29363 var Select2 = function Select2($element, options) { 29364 if (Utils.GetData($element[0], 'select2') != null) { 29365 Utils.GetData($element[0], 'select2').destroy(); 29366 } 29367 29368 this.$element = $element; 29369 this.id = this._generateId($element); 29370 options = options || {}; 29371 this.options = new Options(options, $element); 29372 29373 Select2.__super__.constructor.call(this); // Set up the tabindex 29374 29375 29376 var tabindex = $element.attr('tabindex') || 0; 29377 Utils.StoreData($element[0], 'old-tabindex', tabindex); 29378 $element.attr('tabindex', '-1'); // Set up containers and adapters 29379 29380 var DataAdapter = this.options.get('dataAdapter'); 29381 this.dataAdapter = new DataAdapter($element, this.options); 29382 var $container = this.render(); 29383 29384 this._placeContainer($container); 29385 29386 var SelectionAdapter = this.options.get('selectionAdapter'); 29387 this.selection = new SelectionAdapter($element, this.options); 29388 this.$selection = this.selection.render(); 29389 this.selection.position(this.$selection, $container); 29390 var DropdownAdapter = this.options.get('dropdownAdapter'); 29391 this.dropdown = new DropdownAdapter($element, this.options); 29392 this.$dropdown = this.dropdown.render(); 29393 this.dropdown.position(this.$dropdown, $container); 29394 var ResultsAdapter = this.options.get('resultsAdapter'); 29395 this.results = new ResultsAdapter($element, this.options, this.dataAdapter); 29396 this.$results = this.results.render(); 29397 this.results.position(this.$results, this.$dropdown); // Bind events 29398 29399 var self = this; // Bind the container to all of the adapters 29400 29401 this._bindAdapters(); // Register any DOM event handlers 29402 29403 29404 this._registerDomEvents(); // Register any internal event handlers 29405 29406 29407 this._registerDataEvents(); 29408 29409 this._registerSelectionEvents(); 29410 29411 this._registerDropdownEvents(); 29412 29413 this._registerResultsEvents(); 29414 29415 this._registerEvents(); // Set the initial state 29416 29417 29418 this.dataAdapter.current(function (initialData) { 29419 self.trigger('selection:update', { 29420 data: initialData 29421 }); 29422 }); // Hide the original select 29423 29424 $element.addClass('select2-hidden-accessible'); 29425 $element.attr('aria-hidden', 'true'); // Synchronize any monitored attributes 29426 29427 this._syncAttributes(); 29428 29429 Utils.StoreData($element[0], 'select2', this); // Ensure backwards compatibility with $element.data('select2'). 29430 29431 $element.data('select2', this); 29432 }; 29433 29434 Utils.Extend(Select2, Utils.Observable); 29435 29436 Select2.prototype._generateId = function ($element) { 29437 var id = ''; 29438 29439 if ($element.attr('id') != null) { 29440 id = $element.attr('id'); 29441 } else if ($element.attr('name') != null) { 29442 id = $element.attr('name') + '-' + Utils.generateChars(2); 29443 } else { 29444 id = Utils.generateChars(4); 29445 } 29446 29447 id = id.replace(/(:|\.|\[|\]|,)/g, ''); 29448 id = 'select2-' + id; 29449 return id; 29450 }; 29451 29452 Select2.prototype._placeContainer = function ($container) { 29453 $container.insertAfter(this.$element); 29454 29455 var width = this._resolveWidth(this.$element, this.options.get('width')); 29456 29457 if (width != null) { 29458 $container.css('width', width); 29459 } 29460 }; 29461 29462 Select2.prototype._resolveWidth = function ($element, method) { 29463 var WIDTH = /^width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/i; 29464 29465 if (method == 'resolve') { 29466 var styleWidth = this._resolveWidth($element, 'style'); 29467 29468 if (styleWidth != null) { 29469 return styleWidth; 29470 } 29471 29472 return this._resolveWidth($element, 'element'); 29473 } 29474 29475 if (method == 'element') { 29476 var elementWidth = $element.outerWidth(false); 29477 29478 if (elementWidth <= 0) { 29479 return 'auto'; 29480 } 29481 29482 return elementWidth + 'px'; 29483 } 29484 29485 if (method == 'style') { 29486 var style = $element.attr('style'); 29487 29488 if (typeof style !== 'string') { 29489 return null; 29490 } 29491 29492 var attrs = style.split(';'); 29493 29494 for (var i = 0, l = attrs.length; i < l; i = i + 1) { 29495 var attr = attrs[i].replace(/\s/g, ''); 29496 var matches = attr.match(WIDTH); 29497 29498 if (matches !== null && matches.length >= 1) { 29499 return matches[1]; 29500 } 29501 } 29502 29503 return null; 29504 } 29505 29506 if (method == 'computedstyle') { 29507 var computedStyle = window.getComputedStyle($element[0]); 29508 return computedStyle.width; 29509 } 29510 29511 return method; 29512 }; 29513 29514 Select2.prototype._bindAdapters = function () { 29515 this.dataAdapter.bind(this, this.$container); 29516 this.selection.bind(this, this.$container); 29517 this.dropdown.bind(this, this.$container); 29518 this.results.bind(this, this.$container); 29519 }; 29520 29521 Select2.prototype._registerDomEvents = function () { 29522 var self = this; 29523 this.$element.on('change.select2', function () { 29524 self.dataAdapter.current(function (data) { 29525 self.trigger('selection:update', { 29526 data: data 29527 }); 29528 }); 29529 }); 29530 this.$element.on('focus.select2', function (evt) { 29531 self.trigger('focus', evt); 29532 }); 29533 this._syncA = Utils.bind(this._syncAttributes, this); 29534 this._syncS = Utils.bind(this._syncSubtree, this); 29535 29536 if (this.$element[0].attachEvent) { 29537 this.$element[0].attachEvent('onpropertychange', this._syncA); 29538 } 29539 29540 var observer = window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver; 29541 29542 if (observer != null) { 29543 this._observer = new observer(function (mutations) { 29544 self._syncA(); 29545 29546 self._syncS(null, mutations); 29547 }); 29548 29549 this._observer.observe(this.$element[0], { 29550 attributes: true, 29551 childList: true, 29552 subtree: false 29553 }); 29554 } else
29554if (this.$element[0].addEventListener) { 29555 this.$element[0].addEventListener('DOMAttrModified', self._syncA, false); 29556 this.$element[0].addEventListener('DOMNodeInserted', self._syncS, false); 29557 this.$element[0].addEventListener('DOMNodeRemoved', self._syncS, false); 29558 } 29559 }; 29560 29561 Select2.prototype._registerDataEvents = function () { 29562 var self = this; 29563 this.dataAdapter.on('*', function (name, params) { 29564 self.trigger(name, params); 29565 }); 29566 }; 29567 29568 Select2.prototype._registerSelectionEvents = function () { 29569 var self = this; 29570 var nonRelayEvents = ['toggle', 'focus']; 29571 this.selection.on('toggle', function () { 29572 self.toggleDropdown(); 29573 }); 29574 this.selection.on('focus', function (params) { 29575 self.focus(params); 29576 }); 29577 this.selection.on('*', function (name, params) { 29578 if ($.inArray(name, nonRelayEvents) !== -1) { 29579 return; 29580 } 29581 29582 self.trigger(name, params); 29583 }); 29584 }; 29585 29586 Select2.prototype._registerDropdownEvents = function () { 29587 var self = this; 29588 this.dropdown.on('*', function (name, params) { 29589 self.trigger(name, params); 29590 }); 29591 }; 29592 29593 Select2.prototype._registerResultsEvents = function () { 29594 var self = this; 29595 this.results.on('*', function (name, params) { 29596 self.trigger(name, params); 29597 }); 29598 }; 29599 29600 Select2.prototype._registerEvents = function () { 29601 var self = this; 29602 this.on('open', function () { 29603 self.$container.addClass('select2-container--open'); 29604 }); 29605 this.on('close', function () { 29606 self.$container.removeClass('select2-container--open'); 29607 }); 29608 this.on('enable', function () { 29609 self.$container.removeClass('select2-container--disabled'); 29610 }); 29611 this.on('disable', function () { 29612 self.$container.addClass('select2-container--disabled'); 29613 }); 29614 this.on('blur', function () { 29615 self.$container.removeClass('select2-container--focus'); 29616 }); 29617 this.on('query', function (params) { 29618 if (!self.isOpen()) { 29619 self.trigger('open', {}); 29620 } 29621 29622 this.dataAdapter.query(params, function (data) { 29623 self.trigger('results:all', { 29624 data: data, 29625 query: params 29626 }); 29627 }); 29628 }); 29629 this.on('query:append', function (params) { 29630 this.dataAdapter.query(params, function (data) { 29631 self.trigger('results:append', { 29632 data: data, 29633 query: params 29634 }); 29635 }); 29636 }); 29637 this.on('keypress', function (evt) { 29638 var key = evt.which; 29639 29640 if (self.isOpen()) { 29641 if (key === KEYS.ESC || key === KEYS.TAB || key === KEYS.UP && evt.altKey) { 29642 self.close(evt); 29643 evt.preventDefault(); 29644 } else if (key === KEYS.ENTER) { 29645 self.trigger('results:select', {}); 29646 evt.preventDefault(); 29647 } else if (key === KEYS.SPACE && evt.ctrlKey) { 29648 self.trigger('results:toggle', {}); 29649 evt.preventDefault(); 29650 } else if (key === KEYS.UP) { 29651 self.trigger('results:previous', {}); 29652 evt.preventDefault(); 29653 } else if (key === KEYS.DOWN) { 29654 self.trigger('results:next', {}); 29655 evt.preventDefault(); 29656 } 29657 } else { 29658 if (key === KEYS.ENTER || key === KEYS.SPACE || key === KEYS.DOWN && evt.altKey) { 29659 self.open(); 29660 evt.preventDefault(); 29661 } 29662 } 29663 }); 29664 }; 29665 29666 Select2.prototype._syncAttributes = function () { 29667 this.options.set('disabled', this.$element.prop('disabled')); 29668 29669 if (this.isDisabled()) { 29670 if (this.isOpen()) { 29671 this.close(); 29672 } 29673 29674 this.trigger('disable', {}); 29675 } else { 29676 this.trigger('enable', {}); 29677 } 29678 }; 29679 29680 Select2.prototype._isChangeMutation = function (evt, mutations) { 29681 var changed = false;
29682 var self = this; // Ignore any mutation events raised for elements that aren't options or 29683 // optgroups. This handles the case when the select element is destroyed 29684 29685 if (evt && evt.target && evt.target.nodeName !== 'OPTION' && evt.target.nodeName !== 'OPTGROUP') { 29686 return; 29687 } 29688 29689 if (!mutations) { 29690 // If mutation events aren't supported, then we can only assume that the 29691 // change affected the selections 29692 changed = true; 29693 } else if (mutations.addedNodes && mutations.addedNodes.length > 0) { 29694 for (var n = 0; n < mutations.addedNodes.length; n++) { 29695 var node = mutations.addedNodes[n]; 29696 29697 if (node.selected) { 29698 changed = true; 29699 } 29700 } 29701 } else if (mutations.removedNodes && mutations.removedNodes.length > 0) { 29702 changed = true; 29703 } else if ($.isArray(mutations)) { 29704 $.each(mutations, function (evt, mutation) { 29705 if (self._isChangeMutation(evt, mutation)) { 29706 // We've found a change mutation. 29707 // Let's escape from the loop and continue 29708 changed = true; 29709 return false; 29710 } 29711 }); 29712 } 29713 29714 return changed; 29715 }; 29716 29717 Select2.prototype._syncSubtree = function (evt, mutations) { 29718 var changed = this._isChangeMutation(evt, mutations); 29719 29720 var self = this; // Only re-pull the data if we think there is a change 29721 29722 if (changed) { 29723 this.dataAdapter.current(function (currentData) { 29724 self.trigger('selection:update', { 29725 data: currentData 29726 }); 29727 }); 29728 } 29729 }; 29730 /** 29731 * Override the trigger method to automatically trigger pre-events when 29732 * there are events that can be prevented. 29733 */ 29734 29735 29736 Select2.prototype.trigger = function (name, args) { 29737 var actualTrigger = Select2.__super__.trigger; 29738 var preTriggerMap = { 29739 'open': 'opening', 29740 'close': 'closing', 29741 'select': 'selecting', 29742 'unselect': 'unselecting', 29743 'clear': 'clearing' 29744 }; 29745 29746 if (args === undefined) { 29747 args = {}; 29748 } 29749 29750 if (name in preTriggerMap) { 29751 var preTriggerName = preTriggerMap[name]; 29752 var preTriggerArgs = { 29753 prevented: false, 29754 name: name, 29755 args: args 29756 }; 29757 actualTrigger.call(this, preTriggerName, preTriggerArgs); 29758 29759 if (preTriggerArgs.prevented) { 29760 args.prevented = true; 29761 return; 29762 } 29763 } 29764 29765 actualTrigger.call(this, name, args); 29766 }; 29767 29768 Select2.prototype.toggleDropdown = function () { 29769 if (this.isDisabled()) { 29770 return; 29771 } 29772 29773 if (this.isOpen()) { 29774 this.close(); 29775 } else { 29776 this.open(); 29777 } 29778 }; 29779 29780 Select2.prototype.open = function () { 29781 if (this.isOpen()) { 29782 return; 29783 } 29784 29785 if (this.isDisabled()) { 29786 return; 29787 } 29788 29789 this.trigger('query', {}); 29790 }; 29791 29792 Select2.prototype.close = function (evt) { 29793 if (!this.isOpen()) { 29794 return; 29795 } 29796 29797 this.trigger('close', { 29798 originalEvent: evt 29799 }); 29800 }; 29801 /** 29802 * Helper method to abstract the "enabled" (not "disabled") state of this 29803 * object. 29804 * 29805 * @return {true} if the instance is not disabled. 29806 * @return {false} if the instance is disabled. 29807 */ 29808 29809 29810 Select2.prototype.isEnabled = function () { 29811 return !this.isDisabled(); 29812 }; 29813 /** 29814 * Helper method to abstract the "disabled" state of this object. 29815 * 29816 * @return {true} if the disabled option is true. 29817 * @return {false} if the disabled option is false. 29818 */ 29819 29820 29821 Select2.prototype.isDisabled = function () { 29822 return this.options.get('disabled'); 29823 }; 29824 29825 Select2.prototype.isOpen = function () { 29826 return this.$container.hasClass('select2-container--open'); 29827 }; 29828 29829 Select2.prototype.hasFocus = function () { 29830 return this.$container.hasClass('select2-container--focus'); 29831 }; 29832
vendor: 7,022 bytes, lines 29833-30025
29833 Select2.prototype.focus = function (data) { 29834 // No need to re-trigger focus events if we are already focused 29835 if (this.hasFocus()) { 29836 return; 29837 } 29838 29839 this.$container.addClass('select2-container--focus'); 29840 this.trigger('focus', {}); 29841 }; 29842 29843 Select2.prototype.enable = function (args) { 29844 if (this.options.get('debug') && window.console && console.warn) { 29845 console.warn('Select2: The `select2("enable")` method has been deprecated and will' + ' be removed in later Select2 versions. Use $element.prop("disabled")' + ' instead.'); 29846 } 29847 29848 if (args == null || args.length === 0) { 29849 args = [true]; 29850 } 29851 29852 var disabled = !args[0]; 29853 this.$element.prop('disabled', disabled); 29854 }; 29855 29856 Select2.prototype.data = function () { 29857 if (this.options.get('debug') && arguments.length > 0 && window.console && console.warn) { 29858 console.warn('Select2: Data can no longer be set using `select2("data")`. You ' + 'should consider setting the value instead using `$element.val()`.'); 29859 } 29860 29861 var data = []; 29862 this.dataAdapter.current(function (currentData) { 29863 data = currentData; 29864 }); 29865 return data; 29866 }; 29867 29868 Select2.prototype.val = function (args) { 29869 if (this.options.get('debug') && window.console && console.warn) { 29870 console.warn('Select2: The `select2("val")` method has been deprecated and will be' + ' removed in later Select2 versions. Use $element.val() instead.'); 29871 } 29872 29873 if (args == null || args.length === 0) { 29874 return this.$element.val(); 29875 } 29876 29877 var newVal = args[0]; 29878 29879 if ($.isArray(newVal)) { 29880 newVal = $.map(newVal, function (obj) { 29881 return obj.toString(); 29882 }); 29883 } 29884 29885 this.$element.val(newVal).trigger('input').trigger('change'); 29886 }; 29887 29888 Select2.prototype.destroy = function () { 29889 this.$container.remove(); 29890 29891 if (this.$element[0].detachEvent) { 29892 this.$element[0].detachEvent('onpropertychange', this._syncA); 29893 } 29894 29895 if (this._observer != null) { 29896 this._observer.disconnect(); 29897 29898 this._observer = null; 29899 } else if (this.$element[0].removeEventListener) { 29900 this.$element[0].removeEventListener('DOMAttrModified', this._syncA, false); 29901 this.$element[0].removeEventListener('DOMNodeInserted', this._syncS, false); 29902 this.$element[0].removeEventListener('DOMNodeRemoved', this._syncS, false); 29903 } 29904 29905 this._syncA = null; 29906 this._syncS = null; 29907 this.$element.off('.select2'); 29908 this.$element.attr('tabindex', Utils.GetData(this.$element[0], 'old-tabindex')); 29909 this.$element.removeClass('select2-hidden-accessible'); 29910 this.$element.attr('aria-hidden', 'false'); 29911 Utils.RemoveData(this.$element[0]); 29912 this.$element.removeData('select2'); 29913 this.dataAdapter.destroy(); 29914 this.selection.destroy(); 29915 this.dropdown.destroy(); 29916 this.results.destroy(); 29917 this.dataAdapter = null; 29918 this.selection = null; 29919 this.dropdown = null; 29920 this.results = null; 29921 }; 29922 29923 Select2.prototype.render = function () { 29924 var $container = $('<span class="select2 select2-container">' + '<span class="selection"></span>' + '<span class="dropdown-wrapper" aria-hidden="true"></span>' + '</span>'); 29925 $container.attr('dir', this.options.get('dir')); 29926 this.$container = $container; 29927 this.$container.addClass('select2-container--' + this.options.get('theme')); 29928 Utils.StoreData($container[0], 'element', this.$element); 29929 return $container; 29930 }; 29931 29932 return Select2; 29933 }); 29934 S2.define('jquery-mousewheel', ['jquery'], function ($) { 29935 // Used to shim jQuery.mousewheel for non-full builds. 29936 return $; 29937 }); 29938 S2.define('jquery.select2', ['jquery', 'jquery-mousewheel', './select2/core', './select2/defaults', './select2/utils'], function ($, _, Select2, Defaults, Utils) { 29939 if ($.fn.select2 == null) { 29940 // All methods that should return the element 29941 var thisMethods = ['open', 'close', 'destroy']; 29942 29943 $.fn.select2 = function (options) { 29944 options = options || {}; 29945 29946 if (_typeof(options) === 'object') { 29947 this.each(function () { 29948 var instanceOptions = $.extend(true, {}, options); 29949 var instance = new Select2($(this), instanceOptions); 29950 }); 29951 return this; 29952 } else if (typeof options === 'string') { 29953 var ret; 29954 var args = Array.prototype.slice.call(arguments, 1); 29955 this.each(function () { 29956 var instance = Utils.GetData(this, 'select2'); 29957 29958 if (instance == null && window.console && console.error) { 29959 console.error('The select2(\'' + options + '\') method was called on an ' + 'element that is not using Select2.'); 29960 } 29961 29962 ret = instance[options].apply(instance, args); 29963 }); // Check if we should be returning `this` 29964 29965 if ($.inArray(options, thisMethods) > -1) { 29966 return this; 29967 } 29968 29969 return ret; 29970 } else { 29971 throw new Error('Invalid arguments for Select2: ' + options); 29972 } 29973 }; 29974 } 29975 29976 if ($.fn.select2.defaults == null) { 29977 $.fn.select2.defaults = Defaults; 29978 } 29979 29980 return Select2; 29981 }); // Return the AMD loader configuration so it can be used outside of this file 29982 29983 return { 29984 define: S2.define, 29985 require: S2.require 29986 }; 29987 }(); // Autoload the jQuery bindings 29988 // We know that all of the modules exist above this, so we're safe 29989 29990 29991 var select2 = S2.require('jquery.select2'); // Hold the AMD module references on the jQuery function that was just loaded 29992 // This allows Select2 to use the internal loader outside of this file, such 29993 // as in the language files. 29994 29995 29996 jQuery.fn.select2.amd = S2; // Return the Select2 instance for anyone who is importing it. 29997 29998 return select2; 29999}); 30000 30001/***/ }) 30002 30003/******/ }); 30004/************************************************************************/ 30005/******/ // The module cache 30006/******/ var __webpack_module_cache__ = {}; 30007/******/ 30008/******/ // The require function 30009/******/ function __webpack_require__(moduleId) { 30010/******/ // Check if module is in cache 30011/******/ var cachedModule = __webpack_module_cache__[moduleId]; 30012/******/ if (cachedModule !== undefined) { 30013/******/ return cachedModule.exports; 30014/******/ } 30015/******/ // Create a new module (and put it into the cache) 30016/******/ var module = __webpack_module_cache__[moduleId] = { 30017/******/ id: moduleId, 30018/******/ loaded: false, 30019/******/ exports: {} 30020/******/ }; 30021/******/ 30022/******/ // Execute the module function 30023/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__); 30024/******/ 30025/******/ // Flag the module as loaded
30026/******/ module.loaded = true; 30027/******/ 30028/******/ // Return the exports of the module 30029/******/ return module.exports; 30030/******/ } 30031/******/ 30032/************************************************************************/ 30033/******/ /* webpack/runtime/compat get default export */ 30034/******/ (() => { 30035/******/ // getDefaultExport function for compatibility with non-harmony modules 30036/******/ __webpack_require__.n = (module) => { 30037/******/ var getter = module && module.__esModule ? 30038/******/ () => (module['default']) : 30039/******/ () => (module); 30040/******/ __webpack_require__.d(getter, { a: getter }); 30041/******/ return getter; 30042/******/ }; 30043/******/ })(); 30044/******/ 30045/******/ /* webpack/runtime/define property getters */ 30046/******/ (() => { 30047/******/ // define getter functions for harmony exports 30048/******/ __webpack_require__.d = (exports, definition) => { 30049/******/ for(var key in definition) { 30050/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 30051/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 30052/******/ } 30053/******/ } 30054/******/ }; 30055/******/ })(); 30056/******/ 30057/******/ /* webpack/runtime/global */ 30058/******/ (() => { 30059/******/ __webpack_require__.g = (function() { 30060/******/ if (typeof globalThis === 'object') return globalThis; 30061/******/ try { 30062/******/ return this || new Function('return this')(); 30063/******/ } catch (e) { 30064/******/ if (typeof window === 'object') return window; 30065/******/ } 30066/******/ })(); 30067/******/ })(); 30068/******/ 30069/******/ /* webpack/runtime/hasOwnProperty shorthand */ 30070/******/ (() => { 30071/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 30072/******/ })(); 30073/******/ 30074/******/ /* webpack/runtime/make namespace object */ 30075/******/ (() => { 30076/******/ // define __esModule on exports 30077/******/ __webpack_require__.r = (exports) => { 30078/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 30079/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 30080/******/ } 30081/******/ Object.defineProperty(exports, '__esModule', { value: true }); 30082/******/ }; 30083/******/ })(); 30084/******/ 30085/******/ /* webpack/runtime/node module decorator */ 30086/******/ (() => { 30087/******/ __webpack_require__.nmd = (module) => { 30088/******/ module.paths = []; 30089/******/ if (!module.children) module.children = []; 30090/******/ return module; 30091/******/ }; 30092/******/ })(); 30093/******/ 30094/************************************************************************/ 30095var __webpack_exports__ = {}; 30096window.jQuery = __webpack_require__(4540); 30097window.$ = __webpack_require__(4540); 30098 30099var processInclude = __webpack_require__(7199); 30100 30101var utils = __webpack_require__(4443); //require("@sfra/thirdParty/bootstrap"); 30102 30103 30104__webpack_require__(8433); 30105 30106__webpack_require__(9906); 30107 30108__webpack_require__(365); 30109 30110__webpack_require__(1719); 30111 30112__webpack_require__(9073); 30113 30114__webpack_require__(8150); 30115 30116__webpack_require__(8777); 30117 30118__webpack_require__(9642); 30119 30120__webpack_require__(3523); 30121 30122__webpack_require__(8593); 30123 30124__webpack_require__(4226); 30125 30126__webpack_require__(8558); 30127 30128(__webpack_require__(2385).init)(); 30129 30130$(document).ready(function () { 30131 processInclude(__webpack_require__(1917)); 30132 processInclude(__webpack_require__(8759)); 30133 30134 if (utils.isMobile()) { 30135 processInclude(__webpack_require__(6277)); 30136 } else { 30137 processInclude(__webpack_require__(6087)); 30138 } 30139 30140 processInclude(__webpack_require__(5284)); 30141 processInclude(__webpack_require__(8851)); 30142 processInclude(__webpack_require__(8269)); 30143 processInclude(__webpack_require__(9063)); 30144 processInclude(__webpack_require__(2739)); 30145 processInclude(__webpack_require__(6074)); 30146 processInclude(__webpack_require__(6837)); 30147 processInclude(__webpack_require__(5863)); 30148 processInclude(__webpack_require__(3567)); 30149 processInclude(__webpack_require__(383)); 30150 processInclude(__webpack_require__(4664)); 30151 processInclude(__webpack_require__(1640)); 30152 processInclude(__webpack_require__(1825)); 30153 30154 if ($(".pd-carousel").length) { 30155 processInclude(__webpack_require__(4990)); 30156 } 30157 30158 if (utils.isSafari()) { 30159 $("body").addClass("is-safari"); 30160 } 30161}); 30162 30163(__webpack_require__(8959).init)(); 30164 30165(__webpack_require__(4039).init)(); 30166 30167(__webpack_require__(3119).init)(); // TODO - remove - only for styleguide page 30168 30169 30170$(".trigger-loader").on("click", function () { 30171 $.spinner().start(); 30172 setTimeout(function () { 30173 $.spinner().stop(); 30174 }, 5000); 30175}); 30176/******/ })() 30177;
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.