1(function (global, factory) { 2 typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('jquery')) : 3 typeof define === 'function' && define.amd ? define(['jquery'], factory) : 4 (global = global || self, factory(global.jQuery)); 5}(this, function ($) { 'use strict'; 6 7 $ = $ && $.hasOwnProperty('default') ? $['default'] : $; 8 9 var toString = {}.toString; 10 11 var classofRaw = function (it) { 12 return toString.call(it).slice(8, -1); 13 }; 14 15 // `IsArray` abstract operation 16 // https://tc39.github.io/ecma262/#sec-isarray 17 var isArray = Array.isArray || function isArray(arg) { 18 return classofRaw(arg) == 'Array'; 19 }; 20 21 var isObject = function (it) { 22 return typeof it === 'object' ? it !== null : typeof it === 'function'; 23 }; 24 25 // `RequireObjectCoercible` abstract operation 26 // https://tc39.github.io/ecma262/#sec-requireobjectcoercible 27 var requireObjectCoercible = function (it) { 28 if (it == undefined) throw TypeError("Can't call method on " + it); 29 return it; 30 }; 31 32 // `ToObject` abstract operation 33 // https://tc39.github.io/ecma262/#sec-toobject 34 var toObject = function (argument) { 35 return Object(requireObjectCoercible(argument)); 36 }; 37 38 var ceil = Math.ceil; 39 var floor = Math.floor; 40 41 // `ToInteger` abstract operation 42 // https://tc39.github.io/ecma262/#sec-tointeger 43 var toInteger = function (argument) { 44 return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument); 45 }; 46 47 var min = Math.min; 48 49 // `ToLength` abstract operation 50 // https://tc39.github.io/ecma262/#sec-tolength 51 var toLength = function (argument) { 52 return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 53 }; 54 55 // 7.1.1 ToPrimitive(input [, PreferredType]) 56 57 // instead of the ES6 spec version, we didn't implement @@toPrimitive case 58 // and the second argument - flag - preferred type is a string 59 var toPrimitive = function (it, S) { 60 if (!isObject(it)) return it; 61 var fn, val; 62 if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; 63 if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val; 64 if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; 65 throw TypeError("Can't convert object to primitive value"); 66 }; 67 68 var fails = function (exec) { 69 try { 70 return !!exec(); 71 } catch (error) { 72 return true; 73 } 74 }; 75 76 // Thank's IE8 for his funny defineProperty 77 var descriptors = !fails(function () { 78 return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7; 79 }); 80 81 // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 82 var global = typeof window == 'object' && window && window.Math == Math ? window 83 : typeof self == 'object' && self && self.Math == Math ? self 84 // eslint-disable-next-line no-new-func 85 : Function('return this')(); 86 87 var document = global.document; 88 // typeof document.createElement is 'object' in old IE 89 var exist = isObject(document) && isObject(document.createElement); 90 91 var documentCreateElement = function (it) { 92 return exist ? document.createElement(it) : {}; 93 }; 94 95 // Thank's IE8 for his funny defineProperty 96 var ie8DomDefine = !descriptors && !fails(function () { 97 return Object.defineProperty(documentCreateElement('div'), 'a', { 98 get: function () { return 7; } 99 }).a != 7; 100 }); 101 102 var anObject = function (it) { 103 if (!isObject(it)) { 104 throw TypeError(String(it) + ' is not an object'); 105 } return it; 106 }; 107 108 var nativeDefineProperty = Object.defineProperty; 109 110 var f = descriptors ? nativeDefineProperty : function defineProperty(O, P, Attributes) { 111 anObject(O); 112 P = toPrimitive(P, true); 113 anObject(Attributes); 114 if (ie8DomDefine) try { 115 return nativeDefineProperty(O, P, Attributes); 116 } catch (error) { /* empty */ } 117 if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported'); 118 if ('value' in Attributes) O[P] = Attributes.value; 119 return O; 120 }; 121 122 var objectDefineProperty = { 123 f: f 124 }; 125 126 var createPropertyDescriptor = function (bitmap, value) { 127 return { 128 enumerable: !(bitmap & 1), 129 configurable: !(bitmap & 2), 130 writable: !(bitmap & 4), 131 value: value 132 }; 133 }; 134 135 var createProperty = function (object, key, value) { 136 var propertyKey = toPrimitive(key); 137 if (propertyKey in object) objectDefineProperty.f(object, propertyKey, createPropertyDescriptor(0, value)); 138 else object[propertyKey] = value; 139 }; 140 141 function createCommonjsModule(fn, module) { 142 return module = { exports: {} }, fn(module, module.exports), module.exports; 143 } 144 145 var hide = descriptors ? function (object, key, value) { 146 return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value)); 147 } : function (object, key, value) { 148 object[key] = value; 149 return object; 150 }; 151 152 var setGlobal = function (key, value) { 153 try { 154 hide(global, key, value); 155 } catch (error) { 156 global[key] = value; 157 } return value; 158 }; 159 160 var shared = createCommonjsModule(function (module) {
161 var SHARED = '__core-js_shared__'; 162 var store = global[SHARED] || setGlobal(SHARED, {}); 163 164 (module.exports = function (key, value) { 165 return store[key] || (store[key] = value !== undefined ? value : {}); 166 })('versions', []).push({ 167 version: '3.0.1', 168 mode: 'global', 169 copyright: '© 2019 Denis Pushkarev (zloirock.ru)' 170 }); 171 }); 172 173 var id = 0; 174 var postfix = Math.random(); 175 176 var uid = function (key) { 177 return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + postfix).toString(36)); 178 }; 179 180 // Chrome 38 Symbol has incorrect toString conversion 181 var nativeSymbol = !fails(function () { 182 // eslint-disable-next-line no-undef 183 return !String(Symbol()); 184 }); 185 186 var store = shared('wks'); 187 188 var Symbol$1 = global.Symbol; 189 190 191 var wellKnownSymbol = function (name) { 192 return store[name] || (store[name] = nativeSymbol && Symbol$1[name] 193 || (nativeSymbol ? Symbol$1 : uid)('Symbol.' + name)); 194 }; 195 196 var SPECIES = wellKnownSymbol('species'); 197 198 // `ArraySpeciesCreate` abstract operation 199 // https://tc39.github.io/ecma262/#sec-arrayspeciescreate 200 var arraySpeciesCreate = function (originalArray, length) { 201 var C; 202 if (isArray(originalArray)) { 203 C = originalArray.constructor; 204 // cross-realm fallback 205 if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; 206 else if (isObject(C)) { 207 C = C[SPECIES]; 208 if (C === null) C = undefined; 209 } 210 } return new (C === undefined ? Array : C)(length === 0 ? 0 : length); 211 }; 212 213 var SPECIES$1 = wellKnownSymbol('species'); 214 215 var arrayMethodHasSpeciesSupport = function (METHOD_NAME) { 216 return !fails(function () { 217 var array = []; 218 var constructor = array.constructor = {}; 219 constructor[SPECIES$1] = function () { 220 return { foo: 1 }; 221 }; 222 return array[METHOD_NAME](Boolean).foo !== 1; 223 }); 224 }; 225 226 var nativePropertyIsEnumerable = {}.propertyIsEnumerable; 227 var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 228 229 // Nashorn ~ JDK8 bug 230 var NASHORN_BUG = nativeGetOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1); 231 232 var f$1 = NASHORN_BUG ? function propertyIsEnumerable(V) { 233 var descriptor = nativeGetOwnPropertyDescriptor(this, V); 234 return !!descriptor && descriptor.enumerable; 235 } : nativePropertyIsEnumerable; 236 237 var objectPropertyIsEnumerable = { 238 f: f$1 239 }; 240 241 // fallback for non-array-like ES3 and non-enumerable old V8 strings 242 243 244 var split = ''.split; 245 246 var indexedObject = fails(function () { 247 // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 248 // eslint-disable-next-line no-prototype-builtins 249 return !Object('z').propertyIsEnumerable(0); 250 }) ? function (it) { 251 return classofRaw(it) == 'String' ? split.call(it, '') : Object(it); 252 } : Object; 253 254 // toObject with fallback for non-array-like ES3 strings 255 256 257 258 var toIndexedObject = function (it) { 259 return indexedObject(requireObjectCoercible(it)); 260 }; 261 262 var hasOwnProperty = {}.hasOwnProperty; 263 264 var has = function (it, key) { 265 return hasOwnProperty.call(it, key); 266 }; 267 268 var nativeGetOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; 269 270 var f$2 = descriptors ? nativeGetOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) { 271 O = toIndexedObject(O); 272 P = toPrimitive(P, true); 273 if (ie8DomDefine) try { 274 return nativeGetOwnPropertyDescriptor$1(O, P); 275 } catch (error) { /* empty */ } 276 if (has(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]); 277 }; 278 279 var objectGetOwnPropertyDescriptor = { 280 f: f$2 281 }; 282 283 var functionToString = shared('native-function-to-string', Function.toString); 284 285 var WeakMap = global.WeakMap; 286 287 var nativeWeakMap = typeof WeakMap === 'function' && /native code/.test(functionToString.call(WeakMap)); 288 289 var shared$1 = shared('keys'); 290 291 292 var sharedKey = function (key) {
vendor: 6,913 bytes, lines 293-518
293 return shared$1[key] || (shared$1[key] = uid(key)); 294 }; 295 296 var hiddenKeys = {}; 297 298 var WeakMap$1 = global.WeakMap; 299 var set, get, has$1; 300 301 var enforce = function (it) { 302 return has$1(it) ? get(it) : set(it, {}); 303 }; 304 305 var getterFor = function (TYPE) { 306 return function (it) { 307 var state; 308 if (!isObject(it) || (state = get(it)).type !== TYPE) { 309 throw TypeError('Incompatible receiver, ' + TYPE + ' required'); 310 } return state; 311 }; 312 }; 313 314 if (nativeWeakMap) { 315 var store$1 = new WeakMap$1(); 316 var wmget = store$1.get; 317 var wmhas = store$1.has; 318 var wmset = store$1.set; 319 set = function (it, metadata) { 320 wmset.call(store$1, it, metadata); 321 return metadata; 322 }; 323 get = function (it) { 324 return wmget.call(store$1, it) || {}; 325 }; 326 has$1 = function (it) { 327 return wmhas.call(store$1, it); 328 }; 329 } else { 330 var STATE = sharedKey('state'); 331 hiddenKeys[STATE] = true; 332 set = function (it, metadata) { 333 hide(it, STATE, metadata); 334 return metadata; 335 }; 336 get = function (it) { 337 return has(it, STATE) ? it[STATE] : {}; 338 }; 339 has$1 = function (it) { 340 return has(it, STATE); 341 }; 342 } 343 344 var internalState = { 345 set: set, 346 get: get, 347 has: has$1, 348 enforce: enforce, 349 getterFor: getterFor 350 }; 351 352 var redefine = createCommonjsModule(function (module) { 353 var getInternalState = internalState.get; 354 var enforceInternalState = internalState.enforce; 355 var TEMPLATE = String(functionToString).split('toString'); 356 357 shared('inspectSource', function (it) { 358 return functionToString.call(it); 359 }); 360 361 (module.exports = function (O, key, value, options) { 362 var unsafe = options ? !!options.unsafe : false; 363 var simple = options ? !!options.enumerable : false; 364 var noTargetGet = options ? !!options.noTargetGet : false; 365 if (typeof value == 'function') { 366 if (typeof key == 'string' && !has(value, 'name')) hide(value, 'name', key); 367 enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : ''); 368 } 369 if (O === global) { 370 if (simple) O[key] = value; 371 else setGlobal(key, value); 372 return; 373 } else if (!unsafe) { 374 delete O[key]; 375 } else if (!noTargetGet && O[key]) { 376 simple = true; 377 } 378 if (simple) O[key] = value; 379 else hide(O, key, value); 380 // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative 381 })(Function.prototype, 'toString', function toString() { 382 return typeof this == 'function' && getInternalState(this).source || functionToString.call(this); 383 }); 384 }); 385 386 var max = Math.max; 387 var min$1 = Math.min; 388 389 // Helper for a popular repeating case of the spec: 390 // Let integer be ? ToInteger(index). 391 // If integer < 0, let result be max((length + integer), 0); else let result be min(length, length). 392 var toAbsoluteIndex = function (index, length) { 393 var integer = toInteger(index); 394 return integer < 0 ? max(integer + length, 0) : min$1(integer, length); 395 }; 396 397 // `Array.prototype.{ indexOf, includes }` methods implementation 398 // false -> Array#indexOf 399 // https://tc39.github.io/ecma262/#sec-array.prototype.indexof 400 // true -> Array#includes 401 // https://tc39.github.io/ecma262/#sec-array.prototype.includes 402 var arrayIncludes = function (IS_INCLUDES) { 403 return function ($this, el, fromIndex) { 404 var O = toIndexedObject($this); 405 var length = toLength(O.length); 406 var index = toAbsoluteIndex(fromIndex, length); 407 var value; 408 // Array#includes uses SameValueZero equality algorithm 409 // eslint-disable-next-line no-self-compare 410 if (IS_INCLUDES && el != el) while (length > index) { 411 value = O[index++]; 412 // eslint-disable-next-line no-self-compare 413 if (value != value) return true; 414 // Array#indexOf ignores holes, Array#includes - not 415 } else for (;length > index; index++) if (IS_INCLUDES || index in O) { 416 if (O[index] === el) return IS_INCLUDES || index || 0; 417 } return !IS_INCLUDES && -1; 418 }; 419 }; 420 421 var arrayIndexOf = arrayIncludes(false); 422 423 424 var objectKeysInternal = function (object, names) { 425 var O = toIndexedObject(object); 426 var i = 0; 427 var result = []; 428 var key; 429 for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key); 430 // Don't enum bug & hidden keys 431 while (names.length > i) if (has(O, key = names[i++])) { 432 ~arrayIndexOf(result, key) || result.push(key); 433 } 434 return result; 435 }; 436 437 // IE8- don't enum bug keys 438 var enumBugKeys = [ 439 'constructor', 440 'hasOwnProperty', 441 'isPrototypeOf', 442 'propertyIsEnumerable', 443 'toLocaleString', 444 'toString', 445 'valueOf' 446 ]; 447 448 // 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O) 449 450 var hiddenKeys$1 = enumBugKeys.concat('length', 'prototype'); 451 452 var f$3 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { 453 return objectKeysInternal(O, hiddenKeys$1); 454 }; 455 456 var objectGetOwnPropertyNames = { 457 f: f$3 458 }; 459 460 var f$4 = Object.getOwnPropertySymbols; 461 462 var objectGetOwnPropertySymbols = { 463 f: f$4 464 }; 465 466 var Reflect = global.Reflect; 467 468 // all object keys, includes non-enumerable and symbols 469 var ownKeys = Reflect && Reflect.ownKeys || function ownKeys(it) { 470 var keys = objectGetOwnPropertyNames.f(anObject(it)); 471 var getOwnPropertySymbols = objectGetOwnPropertySymbols.f; 472 return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; 473 }; 474 475 var copyConstructorProperties = function (target, source) { 476 var keys = ownKeys(source); 477 var defineProperty = objectDefineProperty.f; 478 var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; 479 for (var i = 0; i < keys.length; i++) { 480 var key = keys[i]; 481 if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); 482 } 483 }; 484 485 var replacement = /#|\.prototype\./; 486 487 var isForced = function (feature, detection) { 488 var value = data[normalize(feature)]; 489 return value == POLYFILL ? true 490 : value == NATIVE ? false 491 : typeof detection == 'function' ? fails(detection) 492 : !!detection; 493 }; 494 495 var normalize = isForced.normalize = function (string) { 496 return String(string).replace(replacement, '.').toLowerCase(); 497 }; 498 499 var data = isForced.data = {}; 500 var NATIVE = isForced.NATIVE = 'N'; 501 var POLYFILL = isForced.POLYFILL = 'P'; 502 503 var isForced_1 = isForced; 504 505 var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; 506 507 508 509 510 511 512 /* 513 options.target - name of the target object 514 options.global - target is the global object 515 options.stat - export as static methods of target 516 options.proto - export as prototype methods of target 517 options.real - real prototype method for the `pure` version 518 options.forced - export even if the native feature is available
vendor: 4,139 bytes, lines 519-632
519 options.bind - bind methods to the target, required for the `pure` version 520 options.wrap - wrap constructors to preventing global pollution, required for the `pure` version 521 options.unsafe - use the simple assignment of property instead of delete + defineProperty 522 options.sham - add a flag to not completely full polyfills 523 options.enumerable - export as enumerable property 524 options.noTargetGet - prevent calling a getter on target 525 */ 526 var _export = function (options, source) { 527 var TARGET = options.target; 528 var GLOBAL = options.global; 529 var STATIC = options.stat; 530 var FORCED, target, key, targetProperty, sourceProperty, descriptor; 531 if (GLOBAL) { 532 target = global; 533 } else if (STATIC) { 534 target = global[TARGET] || setGlobal(TARGET, {}); 535 } else { 536 target = (global[TARGET] || {}).prototype; 537 } 538 if (target) for (key in source) { 539 sourceProperty = source[key]; 540 if (options.noTargetGet) { 541 descriptor = getOwnPropertyDescriptor(target, key); 542 targetProperty = descriptor && descriptor.value; 543 } else targetProperty = target[key]; 544 FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); 545 // contained in target 546 if (!FORCED && targetProperty !== undefined) { 547 if (typeof sourceProperty === typeof targetProperty) continue; 548 copyConstructorProperties(sourceProperty, targetProperty); 549 } 550 // add a flag to not completely full polyfills 551 if (options.sham || (targetProperty && targetProperty.sham)) { 552 hide(sourceProperty, 'sham', true); 553 } 554 // extend global 555 redefine(target, key, sourceProperty, options); 556 } 557 }; 558 559 var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable'); 560 var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; 561 var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded'; 562 563 var IS_CONCAT_SPREADABLE_SUPPORT = !fails(function () { 564 var array = []; 565 array[IS_CONCAT_SPREADABLE] = false; 566 return array.concat()[0] !== array; 567 }); 568 569 var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat'); 570 571 var isConcatSpreadable = function (O) { 572 if (!isObject(O)) return false; 573 var spreadable = O[IS_CONCAT_SPREADABLE]; 574 return spreadable !== undefined ? !!spreadable : isArray(O); 575 }; 576 577 var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT; 578 579 // `Array.prototype.concat` method 580 // https://tc39.github.io/ecma262/#sec-array.prototype.concat 581 // with adding support of @@isConcatSpreadable and @@species 582 _export({ target: 'Array', proto: true, forced: FORCED }, { 583 concat: function concat(arg) { // eslint-disable-line no-unused-vars 584 var O = toObject(this); 585 var A = arraySpeciesCreate(O, 0); 586 var n = 0; 587 var i, k, length, len, E; 588 for (i = -1, length = arguments.length; i < length; i++) { 589 E = i === -1 ? O : arguments[i]; 590 if (isConcatSpreadable(E)) { 591 len = toLength(E.length); 592 if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); 593 for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]); 594 } else { 595 if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); 596 createProperty(A, n++, E); 597 } 598 } 599 A.length = n; 600 return A; 601 } 602 }); 603 604 var aFunction = function (it) { 605 if (typeof it != 'function') { 606 throw TypeError(String(it) + ' is not a function'); 607 } return it; 608 }; 609 610 // optional / simple context binding 611 var bindContext = function (fn, that, length) { 612 aFunction(fn); 613 if (that === undefined) return fn; 614 switch (length) { 615 case 0: return function () { 616 return fn.call(that); 617 }; 618 case 1: return function (a) { 619 return fn.call(that, a); 620 }; 621 case 2: return function (a, b) { 622 return fn.call(that, a, b); 623 }; 624 case 3: return function (a, b, c) { 625 return fn.call(that, a, b, c); 626 }; 627 } 628 return function (/* ...args */) { 629 return fn.apply(that, arguments); 630 }; 631 }; 632
vendor: 5,846 bytes, lines 633-803
633 // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation 634 // 0 -> Array#forEach 635 // https://tc39.github.io/ecma262/#sec-array.prototype.foreach 636 // 1 -> Array#map 637 // https://tc39.github.io/ecma262/#sec-array.prototype.map 638 // 2 -> Array#filter 639 // https://tc39.github.io/ecma262/#sec-array.prototype.filter 640 // 3 -> Array#some 641 // https://tc39.github.io/ecma262/#sec-array.prototype.some 642 // 4 -> Array#every 643 // https://tc39.github.io/ecma262/#sec-array.prototype.every 644 // 5 -> Array#find 645 // https://tc39.github.io/ecma262/#sec-array.prototype.find 646 // 6 -> Array#findIndex 647 // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex 648 var arrayMethods = function (TYPE, specificCreate) { 649 var IS_MAP = TYPE == 1; 650 var IS_FILTER = TYPE == 2; 651 var IS_SOME = TYPE == 3; 652 var IS_EVERY = TYPE == 4; 653 var IS_FIND_INDEX = TYPE == 6; 654 var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; 655 var create = specificCreate || arraySpeciesCreate; 656 return function ($this, callbackfn, that) { 657 var O = toObject($this); 658 var self = indexedObject(O); 659 var boundFunction = bindContext(callbackfn, that, 3); 660 var length = toLength(self.length); 661 var index = 0; 662 var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined; 663 var value, result; 664 for (;length > index; index++) if (NO_HOLES || index in self) { 665 value = self[index]; 666 result = boundFunction(value, index, O); 667 if (TYPE) { 668 if (IS_MAP) target[index] = result; // map 669 else if (result) switch (TYPE) { 670 case 3: return true; // some 671 case 5: return value; // find 672 case 6: return index; // findIndex 673 case 2: target.push(value); // filter 674 } else if (IS_EVERY) return false; // every 675 } 676 } 677 return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; 678 }; 679 }; 680 681 // 19.1.2.14 / 15.2.3.14 Object.keys(O) 682 683 684 685 var objectKeys = Object.keys || function keys(O) { 686 return objectKeysInternal(O, enumBugKeys); 687 }; 688 689 var objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) { 690 anObject(O); 691 var keys = objectKeys(Properties); 692 var length = keys.length; 693 var i = 0; 694 var key; 695 while (length > i) objectDefineProperty.f(O, key = keys[i++], Properties[key]); 696 return O; 697 }; 698 699 var document$1 = global.document; 700 701 var html = document$1 && document$1.documentElement; 702 703 // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) 704 705 706 707 708 709 var IE_PROTO = sharedKey('IE_PROTO'); 710 var PROTOTYPE = 'prototype'; 711 var Empty = function () { /* empty */ }; 712 713 // Create object with fake `null` prototype: use iframe Object with cleared prototype 714 var createDict = function () { 715 // Thrash, waste and sodomy: IE GC bug 716 var iframe = documentCreateElement('iframe'); 717 var length = enumBugKeys.length; 718 var lt = '<'; 719 var script = 'script'; 720 var gt = '>'; 721 var js = 'java' + script + ':'; 722 var iframeDocument; 723 iframe.style.display = 'none'; 724 html.appendChild(iframe); 725 iframe.src = String(js); 726 iframeDocument = iframe.contentWindow.document; 727 iframeDocument.open(); 728 iframeDocument.write(lt + script + gt + 'document.F=Object' + lt + '/' + script + gt); 729 iframeDocument.close(); 730 createDict = iframeDocument.F; 731 while (length--) delete createDict[PROTOTYPE][enumBugKeys[length]]; 732 return createDict(); 733 }; 734 735 var objectCreate = Object.create || function create(O, Properties) { 736 var result; 737 if (O !== null) { 738 Empty[PROTOTYPE] = anObject(O); 739 result = new Empty(); 740 Empty[PROTOTYPE] = null; 741 // add "__proto__" for Object.getPrototypeOf polyfill 742 result[IE_PROTO] = O; 743 } else result = createDict(); 744 return Properties === undefined ? result : objectDefineProperties(result, Properties); 745 }; 746 747 hiddenKeys[IE_PROTO] = true; 748 749 var UNSCOPABLES = wellKnownSymbol('unscopables'); 750 751 752 var ArrayPrototype = Array.prototype; 753 754 // Array.prototype[@@unscopables] 755 // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables 756 if (ArrayPrototype[UNSCOPABLES] == undefined) { 757 hide(ArrayPrototype, UNSCOPABLES, objectCreate(null)); 758 } 759 760 // add a key to Array.prototype[@@unscopables] 761 var addToUnscopables = function (key) { 762 ArrayPrototype[UNSCOPABLES][key] = true; 763 }; 764 765 var internalFind = arrayMethods(5); 766 var FIND = 'find'; 767 var SKIPS_HOLES = true; 768 769 // Shouldn't skip holes 770 if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; }); 771 772 // `Array.prototype.find` method 773 // https://tc39.github.io/ecma262/#sec-array.prototype.find 774 _export({ target: 'Array', proto: true, forced: SKIPS_HOLES }, { 775 find: function find(callbackfn /* , that = undefined */) { 776 return internalFind(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); 777 } 778 }); 779 780 // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables 781 addToUnscopables(FIND); 782 783 var sloppyArrayMethod = function (METHOD_NAME, argument) { 784 var method = [][METHOD_NAME]; 785 return !method || !fails(function () { 786 // eslint-disable-next-line no-useless-call,no-throw-literal 787 method.call(null, argument || function () { throw 1; }, 1); 788 }); 789 }; 790 791 var nativeJoin = [].join; 792 793 var ES3_STRINGS = indexedObject != Object; 794 var SLOPPY_METHOD = sloppyArrayMethod('join', ','); 795 796 // `Array.prototype.join` method 797 // https://tc39.github.io/ecma262/#sec-array.prototype.join 798 _export({ target: 'Array', proto: true, forced: ES3_STRINGS || SLOPPY_METHOD }, { 799 join: function join(separator) { 800 return nativeJoin.call(toIndexedObject(this), separator === undefined ? ',' : separator); 801 } 802 }); 803
804 // a string of all valid unicode whitespaces 805 // eslint-disable-next-line max-len 806 var whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; 807 808 var whitespace = '[' + whitespaces + ']'; 809 var ltrim = RegExp('^' + whitespace + whitespace + '*'); 810 var rtrim = RegExp(whitespace + whitespace + '*$'); 811 812 // 1 -> String#trimStart 813 // 2 -> String#trimEnd 814 // 3 -> String#trim 815 var stringTrim = function (string, TYPE) { 816 string = String(requireObjectCoercible(string)); 817 if (TYPE & 1) string = string.replace(ltrim, ''); 818 if (TYPE & 2) string = string.replace(rtrim, ''); 819 return string; 820 }; 821 822 var nativeParseInt = global.parseInt; 823 824 825 var hex = /^[-+]?0[xX]/; 826 var FORCED$1 = nativeParseInt(whitespaces + '08') !== 8 || nativeParseInt(whitespaces + '0x16') !== 22; 827 828 var _parseInt = FORCED$1 ? function parseInt(str, radix) { 829 var string = stringTrim(String(str), 3); 830 return nativeParseInt(string, (radix >>> 0) || (hex.test(string) ? 16 : 10)); 831 } : nativeParseInt; 832 833 // `parseInt` method 834 // https://tc39.github.io/ecma262/#sec-parseint-string-radix 835 _export({ global: true, forced: parseInt != _parseInt }, { 836 parseInt: _parseInt 837 }); 838 839 // `RegExp.prototype.flags` getter implementation 840 // https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags 841 var regexpFlags = function () { 842 var that = anObject(this); 843 var result = ''; 844 if (that.global) result += 'g'; 845 if (that.ignoreCase) result += 'i'; 846 if (that.multiline) result += 'm'; 847 if (that.unicode) result += 'u'; 848 if (that.sticky) result += 'y'; 849 return result; 850 }; 851 852 var nativeExec = RegExp.prototype.exec; 853 // This always refers to the native implementation, because the 854 // String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js, 855 // which loads this file before patching the method. 856 var nativeReplace = String.prototype.replace; 857 858 var patchedExec = nativeExec; 859 860 var UPDATES_LAST_INDEX_WRONG = (function () { 861 var re1 = /a/; 862 var re2 = /b*/g; 863 nativeExec.call(re1, 'a'); 864 nativeExec.call(re2, 'a'); 865 return re1.lastIndex !== 0 || re2.lastIndex !== 0; 866 })(); 867 868 // nonparticipating capturing group, copied from es5-shim's String#split patch. 869 var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; 870 871 var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED; 872 873 if (PATCH) { 874 patchedExec = function exec(str) { 875 var re = this; 876 var lastIndex, reCopy, match, i; 877 878 if (NPCG_INCLUDED) { 879 reCopy = new RegExp('^' + re.source + '$(?!\\s)', regexpFlags.call(re)); 880 } 881 if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex; 882 883 match = nativeExec.call(re, str); 884 885 if (UPDATES_LAST_INDEX_WRONG && match) { 886 re.lastIndex = re.global ? match.index + match[0].length : lastIndex; 887 } 888 if (NPCG_INCLUDED && match && match.length > 1) { 889 // Fix browsers whose `exec` methods don't consistently return `undefined` 890 // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/ 891 nativeReplace.call(match[0], reCopy, function () { 892 for (i = 1; i < arguments.length - 2; i++) { 893 if (arguments[i] === undefined) match[i] = undefined; 894 } 895 }); 896 } 897 898 return match; 899 }; 900 } 901 902 var regexpExec = patchedExec; 903 904 _export({ target: 'RegExp', proto: true, forced: /./.exec !== regexpExec }, { 905 exec: regexpExec 906 }); 907 908 // CONVERT_TO_STRING: true -> String#at 909 // CONVERT_TO_STRING: false -> String#codePointAt 910 var stringAt = function (that, pos, CONVERT_TO_STRING) { 911 var S = String(requireObjectCoercible(that)); 912 var position = toInteger(pos); 913 var size = S.length; 914 var first, second; 915 if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; 916 first = S.charCodeAt(position); 917 return first < 0xD800 || first > 0xDBFF || position + 1 === size 918 || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF 919 ? CONVERT_TO_STRING ? S.charAt(position) : first 920 : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; 921 }; 922 923 // `AdvanceStringIndex` abstract operation 924 // https://tc39.github.io/ecma262/#sec-advancestringindex 925 var advanceStringIndex = function (S, index, unicode) { 926 return index + (unicode ? stringAt(S, index, true).length : 1); 927 }; 928 929 // `RegExpExec` abstract operation 930 // https://tc39.github.io/ecma262/#sec-regexpexec 931 var regexpExecAbstract = function (R, S) { 932 var exec = R.exec; 933 if (typeof exec === 'function') { 934 var result = exec.call(R, S); 935 if (typeof result !== 'object') { 936 throw TypeError('RegExp exec method returned something other than an Object or null'); 937 } 938 return result; 939 } 940 941 if (classofRaw(R) !== 'RegExp') { 942 throw TypeError('RegExp#exec called on incompatible receiver'); 943 } 944 945 return regexpExec.call(R, S); 946 }; 947 948 var SPECIES$2 = wellKnownSymbol('species'); 949 950 var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
vendor: 5,168 bytes, lines 951-1086
951 // #replace needs built-in support for named groups. 952 // #match works fine because it just return the exec results, even if it has 953 // a "grops" property. 954 var re = /./; 955 re.exec = function () { 956 var result = []; 957 result.groups = { a: '7' }; 958 return result; 959 }; 960 return ''.replace(re, '$<a>') !== '7'; 961 }); 962 963 // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec 964 // Weex JS has frozen built-in prototypes, so use try / catch wrapper 965 var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () { 966 var re = /(?:)/; 967 var originalExec = re.exec; 968 re.exec = function () { return originalExec.apply(this, arguments); }; 969 var result = 'ab'.split(re); 970 return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b'; 971 }); 972 973 var fixRegexpWellKnownSymbolLogic = function (KEY, length, exec, sham) { 974 var SYMBOL = wellKnownSymbol(KEY); 975 976 var DELEGATES_TO_SYMBOL = !fails(function () { 977 // String methods call symbol-named RegEp methods 978 var O = {}; 979 O[SYMBOL] = function () { return 7; }; 980 return ''[KEY](O) != 7; 981 }); 982 983 var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () { 984 // Symbol-named RegExp methods call .exec 985 var execCalled = false; 986 var re = /a/; 987 re.exec = function () { execCalled = true; return null; }; 988 989 if (KEY === 'split') { 990 // RegExp[@@split] doesn't call the regex's exec method, but first creates 991 // a new one. We need to return the patched regex when creating the new one. 992 re.constructor = {}; 993 re.constructor[SPECIES$2] = function () { return re; }; 994 } 995 996 re[SYMBOL](''); 997 return !execCalled; 998 }); 999 1000 if ( 1001 !DELEGATES_TO_SYMBOL || 1002 !DELEGATES_TO_EXEC || 1003 (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) || 1004 (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC) 1005 ) { 1006 var nativeRegExpMethod = /./[SYMBOL]; 1007 var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { 1008 if (regexp.exec === regexpExec) { 1009 if (DELEGATES_TO_SYMBOL && !forceStringMethod) { 1010 // The native String method already delegates to @@method (this 1011 // polyfilled function), leasing to infinite recursion. 1012 // We avoid it by directly calling the native @@method method. 1013 return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) }; 1014 } 1015 return { done: true, value: nativeMethod.call(str, regexp, arg2) }; 1016 } 1017 return { done: false }; 1018 }); 1019 var stringMethod = methods[0]; 1020 var regexMethod = methods[1]; 1021 1022 redefine(String.prototype, KEY, stringMethod); 1023 redefine(RegExp.prototype, SYMBOL, length == 2 1024 // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue) 1025 // 21.2.5.11 RegExp.prototype[@@split](string, limit) 1026 ? function (string, arg) { return regexMethod.call(string, this, arg); } 1027 // 21.2.5.6 RegExp.prototype[@@match](string) 1028 // 21.2.5.9 RegExp.prototype[@@search](string) 1029 : function (string) { return regexMethod.call(string, this); } 1030 ); 1031 if (sham) hide(RegExp.prototype[SYMBOL], 'sham', true); 1032 } 1033 }; 1034 1035 var max$1 = Math.max; 1036 var min$2 = Math.min; 1037 var floor$1 = Math.floor; 1038 var SUBSTITUTION_SYMBOLS = /\$([$&`']|\d\d?|<[^>]*>)/g; 1039 var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&`']|\d\d?)/g; 1040 1041 var maybeToString = function (it) { 1042 return it === undefined ? it : String(it); 1043 }; 1044 1045 // @@replace logic 1046 fixRegexpWellKnownSymbolLogic( 1047 'replace', 1048 2, 1049 function (REPLACE, nativeReplace, maybeCallNative) { 1050 return [ 1051 // `String.prototype.replace` method 1052 // https://tc39.github.io/ecma262/#sec-string.prototype.replace 1053 function replace(searchValue, replaceValue) { 1054 var O = requireObjectCoercible(this); 1055 var replacer = searchValue == undefined ? undefined : searchValue[REPLACE]; 1056 return replacer !== undefined 1057 ? replacer.call(searchValue, O, replaceValue) 1058 : nativeReplace.call(String(O), searchValue, replaceValue); 1059 }, 1060 // `RegExp.prototype[@@replace]` method 1061 // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace 1062 function (regexp, replaceValue) { 1063 var res = maybeCallNative(nativeReplace, regexp, this, replaceValue); 1064 if (res.done) return res.value; 1065 1066 var rx = anObject(regexp); 1067 var S = String(this); 1068 1069 var functionalReplace = typeof replaceValue === 'function'; 1070 if (!functionalReplace) replaceValue = String(replaceValue); 1071 1072 var global = rx.global; 1073 if (global) { 1074 var fullUnicode = rx.unicode; 1075 rx.lastIndex = 0; 1076 } 1077 var results = []; 1078 while (true) { 1079 var result = regexpExecAbstract(rx, S); 1080 if (result === null) break; 1081 1082 results.push(result); 1083 if (!global) break; 1084 1085 var matchStr = String(result[0]); 1086 if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLe
1086ngth(rx.lastIndex), fullUnicode); 1087 } 1088 1089 var accumulatedResult = ''; 1090 var nextSourcePosition = 0; 1091 for (var i = 0; i < results.length; i++) { 1092 result = results[i]; 1093 1094 var matched = String(result[0]); 1095 var position = max$1(min$2(toInteger(result.index), S.length), 0); 1096 var captures = []; 1097 // NOTE: This is equivalent to 1098 // captures = result.slice(1).map(maybeToString) 1099 // but for some reason `nativeSlice.call(result, 1, result.length)` (called in 1100 // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and 1101 // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. 1102 for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j])); 1103 var namedCaptures = result.groups; 1104 if (functionalReplace) { 1105 var replacerArgs = [matched].concat(captures, position, S); 1106 if (namedCaptures !== undefined) replacerArgs.push(namedCaptures); 1107 var replacement = String(replaceValue.apply(undefined, replacerArgs)); 1108 } else { 1109 replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); 1110 } 1111 if (position >= nextSourcePosition) { 1112 accumulatedResult += S.slice(nextSourcePosition, position) + replacement; 1113 nextSourcePosition = position + matched.length; 1114 } 1115 } 1116 return accumulatedResult + S.slice(nextSourcePosition); 1117 } 1118 ]; 1119 1120 // https://tc39.github.io/ecma262/#sec-getsubstitution 1121 function getSubstitution(matched, str, position, captures, namedCaptures, replacement) { 1122 var tailPos = position + matched.length; 1123 var m = captures.length; 1124 var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; 1125 if (namedCaptures !== undefined) { 1126 namedCaptures = toObject(namedCaptures); 1127 symbols = SUBSTITUTION_SYMBOLS; 1128 } 1129 return nativeReplace.call(replacement, symbols, function (match, ch) { 1130 var capture; 1131 switch (ch.charAt(0)) { 1132 case '$': return '$'; 1133 case '&': return matched; 1134 case '`': return str.slice(0, position); 1135 case "'": return str.slice(tailPos); 1136 case '<': 1137 capture = namedCaptures[ch.slice(1, -1)]; 1138 break; 1139 default: // \d\d? 1140 var n = +ch; 1141 if (n === 0) return match; 1142 if (n > m) { 1143 var f = floor$1(n / 10); 1144 if (f === 0) return match; 1145 if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1); 1146 return match; 1147 } 1148 capture = captures[n - 1]; 1149 } 1150 return capture === undefined ? '' : capture; 1151 }); 1152 } 1153 } 1154 ); 1155 1156 function _typeof(obj) { 1157 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 1158 _typeof = function (obj) { 1159 return typeof obj; 1160 }; 1161 } else { 1162 _typeof = function (obj) { 1163 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 1164 }; 1165 } 1166 1167 return _typeof(obj); 1168 } 1169 1170 function _classCallCheck(instance, Constructor) { 1171 if (!(instance instanceof Constructor)) { 1172 throw new TypeError("Cannot call a class as a function"); 1173 } 1174 } 1175 1176 function _defineProperties(target, props) { 1177 for (var i = 0; i < props.length; i++) { 1178 var descriptor = props[i]; 1179 descriptor.enumerable = descriptor.enumerable || false; 1180 descriptor.configurable = true; 1181 if ("value" in descriptor) descriptor.writable = true; 1182 Object.defineProperty(target, descriptor.key, descriptor); 1183 } 1184 } 1185 1186 function _createClass(Constructor, protoProps, staticProps) { 1187 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 1188 if (staticProps) _defineProperties(Constructor, staticProps); 1189 return Constructor; 1190 } 1191 1192 /** 1193 * @author zhixin wen <[email protected]> 1194 * https://github.com/wenzhixin/bootstrap-show-password 1195 * version: 1.2.1 1196 */ 1197 1198 var bootstrapVersion = 4; 1199 1200 try { 1201 var rawVersion = $.fn.dropdown.Constructor.VERSION; // Only try to parse VERSION if is is defined. 1202 // It is undefined in older versions of Bootstrap (tested with 3.1.1). 1203 1204 if (rawVersion !== undefined) { 1205 bootstrapVersion = parseInt(rawVersion, 10); 1206 } 1207 } catch (e) {// ignore 1208 } 1209 1210 var Constants = { 1211 html: { 1212 inputGroups: { 1213 3: ['<span tabindex="100" class="add-on input-group-addon %s" title="%s">', '</span>'], 1214 4: ['<div class="%s"><button tabindex="100" title="%s" class="btn btn-outline-secondary" type="button">', '</button></div>'] 1215 }[bootstrapVersion] 1216 } // TOOLS DEFINITION 1217 // ====================== 1218 // it only does '%s', and return '' when arguments are undefined 1219 1220 }; 1221 1222 var sprintf = function sprintf(str) { 1223 var args = arguments; 1224 var flag = true; 1225 var i = 1; 1226 str = str.replace(/%s/g, function () { 1227 var arg = args[i++]; 1228 1229 if (typeof arg === 'undefined') { 1230 flag = false;
1231 return ''; 1232 } 1233 1234 return arg; 1235 }); 1236 1237 if (flag) { 1238 return str; 1239 } 1240 1241 return ''; 1242 }; 1243 1244 var Password = 1245 /*#__PURE__*/ 1246 function () { 1247 function Password(element, options) { 1248 _classCallCheck(this, Password); 1249 1250 this.options = options; 1251 this.$element = $(element); 1252 this.isShown = false; 1253 this.init(); 1254 } 1255 1256 _createClass(Password, [{ 1257 key: "init", 1258 value: function init() { 1259 var placementFuc; 1260 var inputClass; 1261 1262 if (this.options.placement === 'before') { 1263 placementFuc = 'insertBefore'; 1264 inputClass = 'input-group-prepend'; 1265 } else { 1266 this.options.placement = 'after'; // default to after 1267 1268 placementFuc = 'insertAfter'; 1269 inputClass = 'input-group-append'; 1270 } // Create the text, icon and assign 1271 1272 1273 this.$element.wrap("<div class=\"input-group".concat(sprintf(' input-group-%s', this.options.size), "\" />")); 1274 this.$text = $('<input type="text" />')[placementFuc](this.$element).attr('class', this.$element.attr('class')).attr('style', this.$element.attr('style')).attr('placeholder', this.$element.attr('placeholder')).attr('maxlength', this.$element.attr('maxlength')).attr('disabled', this.$element.attr('disabled')).css('display', this.$element.css('display')).val(this.$element.val()).hide(); // Copy readonly attribute if it's set 1275 1276 if (this.$element.prop('readonly')) this.$text.prop('readonly', true); 1277 this.$icon = $(["".concat(sprintf(Constants.html.inputGroups[0], inputClass, this.options.message), "\n <i class=\"icon-eye-open ").concat(this.options.eyeClass, " ").concat(this.options.eyeClassPositionInside ? '' : this.options.eyeOpenClass, "\">\n ").concat(this.options.eyeClassPositionInside ? this.options.eyeOpenClass : '', "\n </i>"), Constants.html.inputGroups[1]].join(''))[placementFuc](this.$text).css('cursor', 'pointer'); // events 1278 1279 this.$text.off('keyup').on('keyup', $.proxy(function () { 1280 if (!this.isShown) return; 1281 this.$element.val(this.$text.val()).trigger('change'); 1282 }, this)); 1283 this.$icon.off('click').on('click', $.proxy(function () { 1284 this.$text.val(this.$element.val()).trigger('change'); 1285 this.toggle(); 1286 }, this)); 1287 } 1288 }, { 1289 key: "toggle", 1290 value: function toggle(_relatedTarget) { 1291 this[!this.isShown ? 'show' : 'hide'](_relatedTarget); 1292 } 1293 }, { 1294 key: "show", 1295 value: function show(_relatedTarget) { 1296 var e = $.Event('show.bs.password', { 1297 relatedTarget: _relatedTarget 1298 }); 1299 this.$element.trigger(e); 1300 this.isShown = true; 1301 this.$element.hide(); 1302 this.$text.show(); 1303 1304 if (this.options.eyeClassPositionInside) { 1305 this.$icon.find('i,svg').removeClass('icon-eye-open').addClass('icon-eye-close').html(this.options.eyeCloseClass); 1306 } else { 1307 this.$icon.find('i,svg').removeClass("icon-eye-open ".concat(this.options.eyeOpenClass)).addClass("icon-eye-close ".concat(this.options.eyeCloseClass)); 1308 } 1309 1310 this.$text[this.options.placement](this.$element); 1311 } 1312 }, { 1313 key: "hide", 1314 value: function hide(_relatedTarget) { 1315 var e = $.Event('hide.bs.password', { 1316 relatedTarget: _relatedTarget 1317 }); 1318 this.$element.trigger(e); 1319 this.isShown = false; 1320 this.$element.show(); 1321 this.$text.hide(); 1322 1323 if (this.options.eyeClassPositionInside) { 1324 this.$icon.find('i,svg').removeClass('icon-eye-close').addClass('icon-eye-open').html(this.options.eyeOpenClass); 1325 } else { 1326 this.$icon.find('i,svg').removeClass("icon-eye-close ".concat(this.options.eyeCloseClass)).addClass("icon-eye-open ".concat(this.options.eyeOpenClass)); 1327 } 1328 1329 this.$element[this.options.placement](this.$text); 1330 } 1331 }, { 1332 key: "val", 1333 value: function val(value) { 1334 if (typeof value === 'undefined') { 1335 return this.$element.val(); 1336 } 1337 1338 this.$element.val(value).trigger('change'); 1339 this.$text.val(value); 1340 } 1341 }, {
1342 key: "focus", 1343 value: function focus() { 1344 this.$element.focus(); 1345 } 1346 }]); 1347 1348 return Password; 1349 }(); 1350 1351 Password.DEFAULTS = { 1352 placement: 'after', 1353 // 'before' or 'after' 1354 message: 'Click here to show/hide password', 1355 size: undefined, 1356 // '', 'sm', 'large' 1357 eyeClass: 'fa', 1358 // 'glyphicon', 1359 eyeOpenClass: 'fa-eye', 1360 // 'glyphicon-eye-open', 1361 eyeCloseClass: 'fa-eye-slash', 1362 // 'glyphicon-eye-close', 1363 eyeClassPositionInside: false // PASSWORD PLUGIN DEFINITION 1364 // ======================= 1365 1366 }; 1367 var old = $.fn.password; 1368 1369 $.fn.password = function () { 1370 var option = arguments[0]; // public function 1371 1372 var args = arguments; 1373 var value; 1374 var allowedMethods = ['show', 'hide', 'toggle', 'val', 'focus']; 1375 this.each(function () { 1376 var $this = $(this); 1377 var data = $this.data('bs.password'); 1378 var options = $.extend({}, Password.DEFAULTS, $this.data(), _typeof(option) === 'object' && option); 1379 1380 if (typeof option === 'string') { 1381 if ($.inArray(option, allowedMethods) < 0) { 1382 throw new Error("Unknown method: ".concat(option)); 1383 } 1384 1385 value = data[option](args[1]); 1386 } else { 1387 if (!data) { 1388 data = new Password($this, options); 1389 $this.data('bs.password', data); 1390 } else { 1391 data.init(options); 1392 } 1393 } 1394 }); 1395 return value ? value : this; 1396 }; 1397 1398 $.fn.password.Constructor = Password; // PASSWORD NO CONFLICT 1399 // ================= 1400 1401 $.fn.password.noConflict = function () { 1402 $.fn.password = old; 1403 return this; 1404 }; 1405 1406 $(function () { 1407 $('[data-toggle="password"]').password(); 1408 }); 1409 1410}));
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.