From f64e1260a7b00e22873352b3fc87df54192af68e Mon Sep 17 00:00:00 2001 From: kicap1992 Date: Wed, 22 Dec 2021 04:28:54 +0800 Subject: [PATCH] added few .html files --- admin/assets/dist/css/lightbox.css | 204 + admin/assets/dist/css/lightbox.min.css | 1 + admin/assets/dist/images/close.png | Bin 0 -> 280 bytes admin/assets/dist/images/loading.gif | Bin 0 -> 8476 bytes admin/assets/dist/images/next.png | Bin 0 -> 1350 bytes admin/assets/dist/images/prev.png | Bin 0 -> 1360 bytes admin/assets/dist/js/lightbox-plus-jquery.js | 11158 ++++++++++++++++ .../dist/js/lightbox-plus-jquery.min.js | 38 + .../dist/js/lightbox-plus-jquery.min.map | 1 + admin/assets/dist/js/lightbox.js | 559 + admin/assets/dist/js/lightbox.min.js | 15 + admin/assets/dist/js/lightbox.min.map | 1 + admin/assets/js/index.js | 8 +- admin/index.html | 324 +- admin/list_produk.html | 464 + admin/penambahan_produk.html | 262 + .../images/baju/contoh_baju.jpg | Bin 0 -> 19838 bytes .../images/baju/lightbox2-2.11.3.zip | Bin 0 -> 237610 bytes .../vendor/sweetalert/sweetalert-dev.js | 1285 -- .../vendor/sweetalert/sweetalert.css | 1543 +-- .../vendor/sweetalert/sweetalert.js | 1 + .../vendor/sweetalert/sweetalert.min.js | 542 +- 22 files changed, 13787 insertions(+), 2619 deletions(-) create mode 100644 admin/assets/dist/css/lightbox.css create mode 100644 admin/assets/dist/css/lightbox.min.css create mode 100644 admin/assets/dist/images/close.png create mode 100644 admin/assets/dist/images/loading.gif create mode 100644 admin/assets/dist/images/next.png create mode 100644 admin/assets/dist/images/prev.png create mode 100644 admin/assets/dist/js/lightbox-plus-jquery.js create mode 100644 admin/assets/dist/js/lightbox-plus-jquery.min.js create mode 100644 admin/assets/dist/js/lightbox-plus-jquery.min.map create mode 100644 admin/assets/dist/js/lightbox.js create mode 100644 admin/assets/dist/js/lightbox.min.js create mode 100644 admin/assets/dist/js/lightbox.min.map create mode 100644 admin/list_produk.html create mode 100644 admin/penambahan_produk.html create mode 100644 admin/template_assets/images/baju/contoh_baju.jpg create mode 100644 admin/template_assets/images/baju/lightbox2-2.11.3.zip delete mode 100644 admin/template_assets/vendor/sweetalert/sweetalert-dev.js create mode 100644 admin/template_assets/vendor/sweetalert/sweetalert.js diff --git a/admin/assets/dist/css/lightbox.css b/admin/assets/dist/css/lightbox.css new file mode 100644 index 0000000..b3b0beb --- /dev/null +++ b/admin/assets/dist/css/lightbox.css @@ -0,0 +1,204 @@ +body.lb-disable-scrolling { + overflow: hidden; +} + +.lightboxOverlay { + position: absolute; + top: 0; + left: 0; + z-index: 9999; + background-color: black; + filter: progid:DXImageTransform.Microsoft.Alpha(Opacity=80); + opacity: 0.8; + display: none; +} + +.lightbox { + position: absolute; + left: 0; + width: 100%; + z-index: 10000; + text-align: center; + line-height: 0; + font-weight: normal; + outline: none; +} + +.lightbox .lb-image { + display: block; + height: auto; + max-width: inherit; + max-height: none; + border-radius: 3px; + + /* Image border */ + border: 4px solid white; +} + +.lightbox a img { + border: none; +} + +.lb-outerContainer { + position: relative; + *zoom: 1; + width: 250px; + height: 250px; + margin: 0 auto; + border-radius: 4px; + + /* Background color behind image. + This is visible during transitions. */ + background-color: white; +} + +.lb-outerContainer:after { + content: ""; + display: table; + clear: both; +} + +.lb-loader { + position: absolute; + top: 43%; + left: 0; + height: 25%; + width: 100%; + text-align: center; + line-height: 0; +} + +.lb-cancel { + display: block; + width: 32px; + height: 32px; + margin: 0 auto; + background: url(../images/loading.gif) no-repeat; +} + +.lb-nav { + position: absolute; + top: 0; + left: 0; + height: 100%; + width: 100%; + z-index: 10; +} + +.lb-container > .nav { + left: 0; +} + +.lb-nav a { + outline: none; + background-image: url('data:image/gif;base64,R0lGODlhAQABAPAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw=='); +} + +.lb-prev, .lb-next { + height: 100%; + cursor: pointer; + display: block; +} + +.lb-nav a.lb-prev { + width: 34%; + left: 0; + float: left; + background: url(../images/prev.png) left 48% no-repeat; + filter: progid:DXImageTransform.Microsoft.Alpha(Opacity=0); + opacity: 0; + -webkit-transition: opacity 0.6s; + -moz-transition: opacity 0.6s; + -o-transition: opacity 0.6s; + transition: opacity 0.6s; +} + +.lb-nav a.lb-prev:hover { + filter: progid:DXImageTransform.Microsoft.Alpha(Opacity=100); + opacity: 1; +} + +.lb-nav a.lb-next { + width: 64%; + right: 0; + float: right; + background: url(../images/next.png) right 48% no-repeat; + filter: progid:DXImageTransform.Microsoft.Alpha(Opacity=0); + opacity: 0; + -webkit-transition: opacity 0.6s; + -moz-transition: opacity 0.6s; + -o-transition: opacity 0.6s; + transition: opacity 0.6s; +} + +.lb-nav a.lb-next:hover { + filter: progid:DXImageTransform.Microsoft.Alpha(Opacity=100); + opacity: 1; +} + +.lb-dataContainer { + margin: 0 auto; + padding-top: 5px; + *zoom: 1; + width: 100%; + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; +} + +.lb-dataContainer:after { + content: ""; + display: table; + clear: both; +} + +.lb-data { + padding: 0 4px; + color: #ccc; +} + +.lb-data .lb-details { + width: 85%; + float: left; + text-align: left; + line-height: 1.1em; +} + +.lb-data .lb-caption { + font-size: 13px; + font-weight: bold; + line-height: 1em; +} + +.lb-data .lb-caption a { + color: #4ae; +} + +.lb-data .lb-number { + display: block; + clear: left; + padding-bottom: 1em; + font-size: 12px; + color: #999999; +} + +.lb-data .lb-close { + display: block; + float: right; + width: 30px; + height: 30px; + background: url(../images/close.png) top right no-repeat; + text-align: right; + outline: none; + filter: progid:DXImageTransform.Microsoft.Alpha(Opacity=70); + opacity: 0.7; + -webkit-transition: opacity 0.2s; + -moz-transition: opacity 0.2s; + -o-transition: opacity 0.2s; + transition: opacity 0.2s; +} + +.lb-data .lb-close:hover { + cursor: pointer; + filter: progid:DXImageTransform.Microsoft.Alpha(Opacity=100); + opacity: 1; +} diff --git a/admin/assets/dist/css/lightbox.min.css b/admin/assets/dist/css/lightbox.min.css new file mode 100644 index 0000000..adbaa83 --- /dev/null +++ b/admin/assets/dist/css/lightbox.min.css @@ -0,0 +1 @@ +.lb-loader,.lightbox{text-align:center;line-height:0;position:absolute;left:0}body.lb-disable-scrolling{overflow:hidden}.lightboxOverlay{position:absolute;top:0;left:0;z-index:9999;background-color:#000;filter:alpha(Opacity=80);opacity:.8;display:none}.lightbox{width:100%;z-index:10000;font-weight:400;outline:0}.lightbox .lb-image{display:block;height:auto;max-width:inherit;max-height:none;border-radius:3px;border:4px solid #fff}.lightbox a img{border:none}.lb-outerContainer{position:relative;width:250px;height:250px;margin:0 auto;border-radius:4px;background-color:#fff}.lb-outerContainer:after{content:"";display:table;clear:both}.lb-loader{top:43%;height:25%;width:100%}.lb-cancel{display:block;width:32px;height:32px;margin:0 auto;background:url(../images/loading.gif) no-repeat}.lb-nav{position:absolute;top:0;left:0;height:100%;width:100%;z-index:10}.lb-container>.nav{left:0}.lb-nav a{outline:0;background-image:url(data:image/gif;base64,R0lGODlhAQABAPAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==)}.lb-next,.lb-prev{height:100%;cursor:pointer;display:block}.lb-nav a.lb-prev{width:34%;left:0;float:left;background:url(../images/prev.png) left 48% no-repeat;filter:alpha(Opacity=0);opacity:0;-webkit-transition:opacity .6s;-moz-transition:opacity .6s;-o-transition:opacity .6s;transition:opacity .6s}.lb-nav a.lb-prev:hover{filter:alpha(Opacity=100);opacity:1}.lb-nav a.lb-next{width:64%;right:0;float:right;background:url(../images/next.png) right 48% no-repeat;filter:alpha(Opacity=0);opacity:0;-webkit-transition:opacity .6s;-moz-transition:opacity .6s;-o-transition:opacity .6s;transition:opacity .6s}.lb-nav a.lb-next:hover{filter:alpha(Opacity=100);opacity:1}.lb-dataContainer{margin:0 auto;padding-top:5px;width:100%;border-bottom-left-radius:4px;border-bottom-right-radius:4px}.lb-dataContainer:after{content:"";display:table;clear:both}.lb-data{padding:0 4px;color:#ccc}.lb-data .lb-details{width:85%;float:left;text-align:left;line-height:1.1em}.lb-data .lb-caption{font-size:13px;font-weight:700;line-height:1em}.lb-data .lb-caption a{color:#4ae}.lb-data .lb-number{display:block;clear:left;padding-bottom:1em;font-size:12px;color:#999}.lb-data .lb-close{display:block;float:right;width:30px;height:30px;background:url(../images/close.png) top right no-repeat;text-align:right;outline:0;filter:alpha(Opacity=70);opacity:.7;-webkit-transition:opacity .2s;-moz-transition:opacity .2s;-o-transition:opacity .2s;transition:opacity .2s}.lb-data .lb-close:hover{cursor:pointer;filter:alpha(Opacity=100);opacity:1} \ No newline at end of file diff --git a/admin/assets/dist/images/close.png b/admin/assets/dist/images/close.png new file mode 100644 index 0000000000000000000000000000000000000000..20baa1db5fdf9e22655a0f851c4401d36b9e7ef9 GIT binary patch literal 280 zcmeAS@N?(olHy`uVBq!ia0vp^(jd&i3?z4Pv7`ejn*g5>*Z=?j1DSvS{%vY%YG`Nx zvLV3R+Z)1I1qQoz?eg;S^6>Bg3hv&$d*{xbK#iaC4$A=f!X-g|!3vbDHnnh5Xg#OL;K8su!;fw4MC7hH<+BPou~5EnOggc)I$z JtaD0e0ssdsYEA$E literal 0 HcmV?d00001 diff --git a/admin/assets/dist/images/loading.gif b/admin/assets/dist/images/loading.gif new file mode 100644 index 0000000000000000000000000000000000000000..5087c2a644223a95984baefdb74f39a287fdfd9a GIT binary patch literal 8476 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 S-YhKu0000 elements + // (i.e., `typeof document.createElement( "object" ) === "function"`). + // We don't want to classify *any* DOM node as a function. + return typeof obj === "function" && typeof obj.nodeType !== "number"; + }; + + +var isWindow = function isWindow( obj ) { + return obj != null && obj === obj.window; + }; + + + + + var preservedScriptAttributes = { + type: true, + src: true, + nonce: true, + noModule: true + }; + + function DOMEval( code, node, doc ) { + doc = doc || document; + + var i, val, + script = doc.createElement( "script" ); + + script.text = code; + if ( node ) { + for ( i in preservedScriptAttributes ) { + + // Support: Firefox 64+, Edge 18+ + // Some browsers don't support the "nonce" property on scripts. + // On the other hand, just using `getAttribute` is not enough as + // the `nonce` attribute is reset to an empty string whenever it + // becomes browsing-context connected. + // See https://github.com/whatwg/html/issues/2369 + // See https://html.spec.whatwg.org/#nonce-attributes + // The `node.getAttribute` check was added for the sake of + // `jQuery.globalEval` so that it can fake a nonce-containing node + // via an object. + val = node[ i ] || node.getAttribute && node.getAttribute( i ); + if ( val ) { + script.setAttribute( i, val ); + } + } + } + doc.head.appendChild( script ).parentNode.removeChild( script ); + } + + +function toType( obj ) { + if ( obj == null ) { + return obj + ""; + } + + // Support: Android <=2.3 only (functionish RegExp) + return typeof obj === "object" || typeof obj === "function" ? + class2type[ toString.call( obj ) ] || "object" : + typeof obj; +} +/* global Symbol */ +// Defining this global in .eslintrc.json would create a danger of using the global +// unguarded in another place, it seems safer to define global only for this module + + + +var + version = "3.4.1", + + // Define a local copy of jQuery + jQuery = function( selector, context ) { + + // The jQuery object is actually just the init constructor 'enhanced' + // Need init if jQuery is called (just allow error to be thrown if not included) + return new jQuery.fn.init( selector, context ); + }, + + // Support: Android <=4.0 only + // Make sure we trim BOM and NBSP + rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g; + +jQuery.fn = jQuery.prototype = { + + // The current version of jQuery being used + jquery: version, + + constructor: jQuery, + + // The default length of a jQuery object is 0 + length: 0, + + toArray: function() { + return slice.call( this ); + }, + + // Get the Nth element in the matched element set OR + // Get the whole matched element set as a clean array + get: function( num ) { + + // Return all the elements in a clean array + if ( num == null ) { + return slice.call( this ); + } + + // Return just the one element from the set + return num < 0 ? this[ num + this.length ] : this[ num ]; + }, + + // Take an array of elements and push it onto the stack + // (returning the new matched element set) + pushStack: function( elems ) { + + // Build a new jQuery matched element set + var ret = jQuery.merge( this.constructor(), elems ); + + // Add the old object onto the stack (as a reference) + ret.prevObject = this; + + // Return the newly-formed element set + return ret; + }, + + // Execute a callback for every element in the matched set. + each: function( callback ) { + return jQuery.each( this, callback ); + }, + + map: function( callback ) { + return this.pushStack( jQuery.map( this, function( elem, i ) { + return callback.call( elem, i, elem ); + } ) ); + }, + + slice: function() { + return this.pushStack( slice.apply( this, arguments ) ); + }, + + first: function() { + return this.eq( 0 ); + }, + + last: function() { + return this.eq( -1 ); + }, + + eq: function( i ) { + var len = this.length, + j = +i + ( i < 0 ? len : 0 ); + return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); + }, + + end: function() { + return this.prevObject || this.constructor(); + }, + + // For internal use only. + // Behaves like an Array's method, not like a jQuery method. + push: push, + sort: arr.sort, + splice: arr.splice +}; + +jQuery.extend = jQuery.fn.extend = function() { + var options, name, src, copy, copyIsArray, clone, + target = arguments[ 0 ] || {}, + i = 1, + length = arguments.length, + deep = false; + + // Handle a deep copy situation + if ( typeof target === "boolean" ) { + deep = target; + + // Skip the boolean and the target + target = arguments[ i ] || {}; + i++; + } + + // Handle case when target is a string or something (possible in deep copy) + if ( typeof target !== "object" && !isFunction( target ) ) { + target = {}; + } + + // Extend jQuery itself if only one argument is passed + if ( i === length ) { + target = this; + i--; + } + + for ( ; i < length; i++ ) { + + // Only deal with non-null/undefined values + if ( ( options = arguments[ i ] ) != null ) { + + // Extend the base object + for ( name in options ) { + copy = options[ name ]; + + // Prevent Object.prototype pollution + // Prevent never-ending loop + if ( name === "__proto__" || target === copy ) { + continue; + } + + // Recurse if we're merging plain objects or arrays + if ( deep && copy && ( jQuery.isPlainObject( copy ) || + ( copyIsArray = Array.isArray( copy ) ) ) ) { + src = target[ name ]; + + // Ensure proper type for the source value + if ( copyIsArray && !Array.isArray( src ) ) { + clone = []; + } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) { + clone = {}; + } else { + clone = src; + } + copyIsArray = false; + + // Never move original objects, clone them + target[ name ] = jQuery.extend( deep, clone, copy ); + + // Don't bring in undefined values + } else if ( copy !== undefined ) { + target[ name ] = copy; + } + } + } + } + + // Return the modified object + return target; +}; + +jQuery.extend( { + + // Unique for each copy of jQuery on the page + expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), + + // Assume jQuery is ready without the ready module + isReady: true, + + error: function( msg ) { + throw new Error( msg ); + }, + + noop: function() {}, + + isPlainObject: function( obj ) { + var proto, Ctor; + + // Detect obvious negatives + // Use toString instead of jQuery.type to catch host objects + if ( !obj || toString.call( obj ) !== "[object Object]" ) { + return false; + } + + proto = getProto( obj ); + + // Objects with no prototype (e.g., `Object.create( null )`) are plain + if ( !proto ) { + return true; + } + + // Objects with prototype are plain iff they were constructed by a global Object function + Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; + return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; + }, + + isEmptyObject: function( obj ) { + var name; + + for ( name in obj ) { + return false; + } + return true; + }, + + // Evaluates a script in a global context + globalEval: function( code, options ) { + DOMEval( code, { nonce: options && options.nonce } ); + }, + + each: function( obj, callback ) { + var length, i = 0; + + if ( isArrayLike( obj ) ) { + length = obj.length; + for ( ; i < length; i++ ) { + if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { + break; + } + } + } else { + for ( i in obj ) { + if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { + break; + } + } + } + + return obj; + }, + + // Support: Android <=4.0 only + trim: function( text ) { + return text == null ? + "" : + ( text + "" ).replace( rtrim, "" ); + }, + + // results is for internal usage only + makeArray: function( arr, results ) { + var ret = results || []; + + if ( arr != null ) { + if ( isArrayLike( Object( arr ) ) ) { + jQuery.merge( ret, + typeof arr === "string" ? + [ arr ] : arr + ); + } else { + push.call( ret, arr ); + } + } + + return ret; + }, + + inArray: function( elem, arr, i ) { + return arr == null ? -1 : indexOf.call( arr, elem, i ); + }, + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + merge: function( first, second ) { + var len = +second.length, + j = 0, + i = first.length; + + for ( ; j < len; j++ ) { + first[ i++ ] = second[ j ]; + } + + first.length = i; + + return first; + }, + + grep: function( elems, callback, invert ) { + var callbackInverse, + matches = [], + i = 0, + length = elems.length, + callbackExpect = !invert; + + // Go through the array, only saving the items + // that pass the validator function + for ( ; i < length; i++ ) { + callbackInverse = !callback( elems[ i ], i ); + if ( callbackInverse !== callbackExpect ) { + matches.push( elems[ i ] ); + } + } + + return matches; + }, + + // arg is for internal usage only + map: function( elems, callback, arg ) { + var length, value, + i = 0, + ret = []; + + // Go through the array, translating each of the items to their new values + if ( isArrayLike( elems ) ) { + length = elems.length; + for ( ; i < length; i++ ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret.push( value ); + } + } + + // Go through every key on the object, + } else { + for ( i in elems ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret.push( value ); + } + } + } + + // Flatten any nested arrays + return concat.apply( [], ret ); + }, + + // A global GUID counter for objects + guid: 1, + + // jQuery.support is not used in Core but other projects attach their + // properties to it so it needs to exist. + support: support +} ); + +if ( typeof Symbol === "function" ) { + jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; +} + +// Populate the class2type map +jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), +function( i, name ) { + class2type[ "[object " + name + "]" ] = name.toLowerCase(); +} ); + +function isArrayLike( obj ) { + + // Support: real iOS 8.2 only (not reproducible in simulator) + // `in` check used to prevent JIT error (gh-2145) + // hasOwn isn't used here due to false negatives + // regarding Nodelist length in IE + var length = !!obj && "length" in obj && obj.length, + type = toType( obj ); + + if ( isFunction( obj ) || isWindow( obj ) ) { + return false; + } + + return type === "array" || length === 0 || + typeof length === "number" && length > 0 && ( length - 1 ) in obj; +} +var Sizzle = +/*! + * Sizzle CSS Selector Engine v2.3.4 + * https://sizzlejs.com/ + * + * Copyright JS Foundation and other contributors + * Released under the MIT license + * https://js.foundation/ + * + * Date: 2019-04-08 + */ +(function( window ) { + +var i, + support, + Expr, + getText, + isXML, + tokenize, + compile, + select, + outermostContext, + sortInput, + hasDuplicate, + + // Local document vars + setDocument, + document, + docElem, + documentIsHTML, + rbuggyQSA, + rbuggyMatches, + matches, + contains, + + // Instance-specific data + expando = "sizzle" + 1 * new Date(), + preferredDoc = window.document, + dirruns = 0, + done = 0, + classCache = createCache(), + tokenCache = createCache(), + compilerCache = createCache(), + nonnativeSelectorCache = createCache(), + sortOrder = function( a, b ) { + if ( a === b ) { + hasDuplicate = true; + } + return 0; + }, + + // Instance methods + hasOwn = ({}).hasOwnProperty, + arr = [], + pop = arr.pop, + push_native = arr.push, + push = arr.push, + slice = arr.slice, + // Use a stripped-down indexOf as it's faster than native + // https://jsperf.com/thor-indexof-vs-for/5 + indexOf = function( list, elem ) { + var i = 0, + len = list.length; + for ( ; i < len; i++ ) { + if ( list[i] === elem ) { + return i; + } + } + return -1; + }, + + booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", + + // Regular expressions + + // http://www.w3.org/TR/css3-selectors/#whitespace + whitespace = "[\\x20\\t\\r\\n\\f]", + + // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier + identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+", + + // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors + attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + + // Operator (capture 2) + "*([*^$|!~]?=)" + whitespace + + // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + + "*\\]", + + pseudos = ":(" + identifier + ")(?:\\((" + + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: + // 1. quoted (capture 3; capture 4 or capture 5) + "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + + // 2. simple (capture 6) + "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + + // 3. anything else (capture 2) + ".*" + + ")\\)|)", + + // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter + rwhitespace = new RegExp( whitespace + "+", "g" ), + rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), + + rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), + rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), + rdescend = new RegExp( whitespace + "|>" ), + + rpseudo = new RegExp( pseudos ), + ridentifier = new RegExp( "^" + identifier + "$" ), + + matchExpr = { + "ID": new RegExp( "^#(" + identifier + ")" ), + "CLASS": new RegExp( "^\\.(" + identifier + ")" ), + "TAG": new RegExp( "^(" + identifier + "|[*])" ), + "ATTR": new RegExp( "^" + attributes ), + "PSEUDO": new RegExp( "^" + pseudos ), + "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), + "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), + // For use in libraries implementing .is() + // We use this for POS matching in `select` + "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) + }, + + rhtml = /HTML$/i, + rinputs = /^(?:input|select|textarea|button)$/i, + rheader = /^h\d$/i, + + rnative = /^[^{]+\{\s*\[native \w/, + + // Easily-parseable/retrievable ID or TAG or CLASS selectors + rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, + + rsibling = /[+~]/, + + // CSS escapes + // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters + runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), + funescape = function( _, escaped, escapedWhitespace ) { + var high = "0x" + escaped - 0x10000; + // NaN means non-codepoint + // Support: Firefox<24 + // Workaround erroneous numeric interpretation of +"0x" + return high !== high || escapedWhitespace ? + escaped : + high < 0 ? + // BMP codepoint + String.fromCharCode( high + 0x10000 ) : + // Supplemental Plane codepoint (surrogate pair) + String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); + }, + + // CSS string/identifier serialization + // https://drafts.csswg.org/cssom/#common-serializing-idioms + rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, + fcssescape = function( ch, asCodePoint ) { + if ( asCodePoint ) { + + // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER + if ( ch === "\0" ) { + return "\uFFFD"; + } + + // Control characters and (dependent upon position) numbers get escaped as code points + return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; + } + + // Other potentially-special ASCII characters get backslash-escaped + return "\\" + ch; + }, + + // Used for iframes + // See setDocument() + // Removing the function wrapper causes a "Permission Denied" + // error in IE + unloadHandler = function() { + setDocument(); + }, + + inDisabledFieldset = addCombinator( + function( elem ) { + return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset"; + }, + { dir: "parentNode", next: "legend" } + ); + +// Optimize for push.apply( _, NodeList ) +try { + push.apply( + (arr = slice.call( preferredDoc.childNodes )), + preferredDoc.childNodes + ); + // Support: Android<4.0 + // Detect silently failing push.apply + arr[ preferredDoc.childNodes.length ].nodeType; +} catch ( e ) { + push = { apply: arr.length ? + + // Leverage slice if possible + function( target, els ) { + push_native.apply( target, slice.call(els) ); + } : + + // Support: IE<9 + // Otherwise append directly + function( target, els ) { + var j = target.length, + i = 0; + // Can't trust NodeList.length + while ( (target[j++] = els[i++]) ) {} + target.length = j - 1; + } + }; +} + +function Sizzle( selector, context, results, seed ) { + var m, i, elem, nid, match, groups, newSelector, + newContext = context && context.ownerDocument, + + // nodeType defaults to 9, since context defaults to document + nodeType = context ? context.nodeType : 9; + + results = results || []; + + // Return early from calls with invalid selector or context + if ( typeof selector !== "string" || !selector || + nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { + + return results; + } + + // Try to shortcut find operations (as opposed to filters) in HTML documents + if ( !seed ) { + + if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { + setDocument( context ); + } + context = context || document; + + if ( documentIsHTML ) { + + // If the selector is sufficiently simple, try using a "get*By*" DOM method + // (excepting DocumentFragment context, where the methods don't exist) + if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) { + + // ID selector + if ( (m = match[1]) ) { + + // Document context + if ( nodeType === 9 ) { + if ( (elem = context.getElementById( m )) ) { + + // Support: IE, Opera, Webkit + // TODO: identify versions + // getElementById can match elements by name instead of ID + if ( elem.id === m ) { + results.push( elem ); + return results; + } + } else { + return results; + } + + // Element context + } else { + + // Support: IE, Opera, Webkit + // TODO: identify versions + // getElementById can match elements by name instead of ID + if ( newContext && (elem = newContext.getElementById( m )) && + contains( context, elem ) && + elem.id === m ) { + + results.push( elem ); + return results; + } + } + + // Type selector + } else if ( match[2] ) { + push.apply( results, context.getElementsByTagName( selector ) ); + return results; + + // Class selector + } else if ( (m = match[3]) && support.getElementsByClassName && + context.getElementsByClassName ) { + + push.apply( results, context.getElementsByClassName( m ) ); + return results; + } + } + + // Take advantage of querySelectorAll + if ( support.qsa && + !nonnativeSelectorCache[ selector + " " ] && + (!rbuggyQSA || !rbuggyQSA.test( selector )) && + + // Support: IE 8 only + // Exclude object elements + (nodeType !== 1 || context.nodeName.toLowerCase() !== "object") ) { + + newSelector = selector; + newContext = context; + + // qSA considers elements outside a scoping root when evaluating child or + // descendant combinators, which is not what we want. + // In such cases, we work around the behavior by prefixing every selector in the + // list with an ID selector referencing the scope context. + // Thanks to Andrew Dupont for this technique. + if ( nodeType === 1 && rdescend.test( selector ) ) { + + // Capture the context ID, setting it first if necessary + if ( (nid = context.getAttribute( "id" )) ) { + nid = nid.replace( rcssescape, fcssescape ); + } else { + context.setAttribute( "id", (nid = expando) ); + } + + // Prefix every selector in the list + groups = tokenize( selector ); + i = groups.length; + while ( i-- ) { + groups[i] = "#" + nid + " " + toSelector( groups[i] ); + } + newSelector = groups.join( "," ); + + // Expand context for sibling selectors + newContext = rsibling.test( selector ) && testContext( context.parentNode ) || + context; + } + + try { + push.apply( results, + newContext.querySelectorAll( newSelector ) + ); + return results; + } catch ( qsaError ) { + nonnativeSelectorCache( selector, true ); + } finally { + if ( nid === expando ) { + context.removeAttribute( "id" ); + } + } + } + } + } + + // All others + return select( selector.replace( rtrim, "$1" ), context, results, seed ); +} + +/** + * Create key-value caches of limited size + * @returns {function(string, object)} Returns the Object data after storing it on itself with + * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) + * deleting the oldest entry + */ +function createCache() { + var keys = []; + + function cache( key, value ) { + // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) + if ( keys.push( key + " " ) > Expr.cacheLength ) { + // Only keep the most recent entries + delete cache[ keys.shift() ]; + } + return (cache[ key + " " ] = value); + } + return cache; +} + +/** + * Mark a function for special use by Sizzle + * @param {Function} fn The function to mark + */ +function markFunction( fn ) { + fn[ expando ] = true; + return fn; +} + +/** + * Support testing using an element + * @param {Function} fn Passed the created element and returns a boolean result + */ +function assert( fn ) { + var el = document.createElement("fieldset"); + + try { + return !!fn( el ); + } catch (e) { + return false; + } finally { + // Remove from its parent by default + if ( el.parentNode ) { + el.parentNode.removeChild( el ); + } + // release memory in IE + el = null; + } +} + +/** + * Adds the same handler for all of the specified attrs + * @param {String} attrs Pipe-separated list of attributes + * @param {Function} handler The method that will be applied + */ +function addHandle( attrs, handler ) { + var arr = attrs.split("|"), + i = arr.length; + + while ( i-- ) { + Expr.attrHandle[ arr[i] ] = handler; + } +} + +/** + * Checks document order of two siblings + * @param {Element} a + * @param {Element} b + * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b + */ +function siblingCheck( a, b ) { + var cur = b && a, + diff = cur && a.nodeType === 1 && b.nodeType === 1 && + a.sourceIndex - b.sourceIndex; + + // Use IE sourceIndex if available on both nodes + if ( diff ) { + return diff; + } + + // Check if b follows a + if ( cur ) { + while ( (cur = cur.nextSibling) ) { + if ( cur === b ) { + return -1; + } + } + } + + return a ? 1 : -1; +} + +/** + * Returns a function to use in pseudos for input types + * @param {String} type + */ +function createInputPseudo( type ) { + return function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === type; + }; +} + +/** + * Returns a function to use in pseudos for buttons + * @param {String} type + */ +function createButtonPseudo( type ) { + return function( elem ) { + var name = elem.nodeName.toLowerCase(); + return (name === "input" || name === "button") && elem.type === type; + }; +} + +/** + * Returns a function to use in pseudos for :enabled/:disabled + * @param {Boolean} disabled true for :disabled; false for :enabled + */ +function createDisabledPseudo( disabled ) { + + // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable + return function( elem ) { + + // Only certain elements can match :enabled or :disabled + // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled + // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled + if ( "form" in elem ) { + + // Check for inherited disabledness on relevant non-disabled elements: + // * listed form-associated elements in a disabled fieldset + // https://html.spec.whatwg.org/multipage/forms.html#category-listed + // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled + // * option elements in a disabled optgroup + // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled + // All such elements have a "form" property. + if ( elem.parentNode && elem.disabled === false ) { + + // Option elements defer to a parent optgroup if present + if ( "label" in elem ) { + if ( "label" in elem.parentNode ) { + return elem.parentNode.disabled === disabled; + } else { + return elem.disabled === disabled; + } + } + + // Support: IE 6 - 11 + // Use the isDisabled shortcut property to check for disabled fieldset ancestors + return elem.isDisabled === disabled || + + // Where there is no isDisabled, check manually + /* jshint -W018 */ + elem.isDisabled !== !disabled && + inDisabledFieldset( elem ) === disabled; + } + + return elem.disabled === disabled; + + // Try to winnow out elements that can't be disabled before trusting the disabled property. + // Some victims get caught in our net (label, legend, menu, track), but it shouldn't + // even exist on them, let alone have a boolean value. + } else if ( "label" in elem ) { + return elem.disabled === disabled; + } + + // Remaining elements are neither :enabled nor :disabled + return false; + }; +} + +/** + * Returns a function to use in pseudos for positionals + * @param {Function} fn + */ +function createPositionalPseudo( fn ) { + return markFunction(function( argument ) { + argument = +argument; + return markFunction(function( seed, matches ) { + var j, + matchIndexes = fn( [], seed.length, argument ), + i = matchIndexes.length; + + // Match elements found at the specified indexes + while ( i-- ) { + if ( seed[ (j = matchIndexes[i]) ] ) { + seed[j] = !(matches[j] = seed[j]); + } + } + }); + }); +} + +/** + * Checks a node for validity as a Sizzle context + * @param {Element|Object=} context + * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value + */ +function testContext( context ) { + return context && typeof context.getElementsByTagName !== "undefined" && context; +} + +// Expose support vars for convenience +support = Sizzle.support = {}; + +/** + * Detects XML nodes + * @param {Element|Object} elem An element or a document + * @returns {Boolean} True iff elem is a non-HTML XML node + */ +isXML = Sizzle.isXML = function( elem ) { + var namespace = elem.namespaceURI, + docElem = (elem.ownerDocument || elem).documentElement; + + // Support: IE <=8 + // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes + // https://bugs.jquery.com/ticket/4833 + return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" ); +}; + +/** + * Sets document-related variables once based on the current document + * @param {Element|Object} [doc] An element or document object to use to set the document + * @returns {Object} Returns the current document + */ +setDocument = Sizzle.setDocument = function( node ) { + var hasCompare, subWindow, + doc = node ? node.ownerDocument || node : preferredDoc; + + // Return early if doc is invalid or already selected + if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { + return document; + } + + // Update global variables + document = doc; + docElem = document.documentElement; + documentIsHTML = !isXML( document ); + + // Support: IE 9-11, Edge + // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) + if ( preferredDoc !== document && + (subWindow = document.defaultView) && subWindow.top !== subWindow ) { + + // Support: IE 11, Edge + if ( subWindow.addEventListener ) { + subWindow.addEventListener( "unload", unloadHandler, false ); + + // Support: IE 9 - 10 only + } else if ( subWindow.attachEvent ) { + subWindow.attachEvent( "onunload", unloadHandler ); + } + } + + /* Attributes + ---------------------------------------------------------------------- */ + + // Support: IE<8 + // Verify that getAttribute really returns attributes and not properties + // (excepting IE8 booleans) + support.attributes = assert(function( el ) { + el.className = "i"; + return !el.getAttribute("className"); + }); + + /* getElement(s)By* + ---------------------------------------------------------------------- */ + + // Check if getElementsByTagName("*") returns only elements + support.getElementsByTagName = assert(function( el ) { + el.appendChild( document.createComment("") ); + return !el.getElementsByTagName("*").length; + }); + + // Support: IE<9 + support.getElementsByClassName = rnative.test( document.getElementsByClassName ); + + // Support: IE<10 + // Check if getElementById returns elements by name + // The broken getElementById methods don't pick up programmatically-set names, + // so use a roundabout getElementsByName test + support.getById = assert(function( el ) { + docElem.appendChild( el ).id = expando; + return !document.getElementsByName || !document.getElementsByName( expando ).length; + }); + + // ID filter and find + if ( support.getById ) { + Expr.filter["ID"] = function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + return elem.getAttribute("id") === attrId; + }; + }; + Expr.find["ID"] = function( id, context ) { + if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { + var elem = context.getElementById( id ); + return elem ? [ elem ] : []; + } + }; + } else { + Expr.filter["ID"] = function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + var node = typeof elem.getAttributeNode !== "undefined" && + elem.getAttributeNode("id"); + return node && node.value === attrId; + }; + }; + + // Support: IE 6 - 7 only + // getElementById is not reliable as a find shortcut + Expr.find["ID"] = function( id, context ) { + if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { + var node, i, elems, + elem = context.getElementById( id ); + + if ( elem ) { + + // Verify the id attribute + node = elem.getAttributeNode("id"); + if ( node && node.value === id ) { + return [ elem ]; + } + + // Fall back on getElementsByName + elems = context.getElementsByName( id ); + i = 0; + while ( (elem = elems[i++]) ) { + node = elem.getAttributeNode("id"); + if ( node && node.value === id ) { + return [ elem ]; + } + } + } + + return []; + } + }; + } + + // Tag + Expr.find["TAG"] = support.getElementsByTagName ? + function( tag, context ) { + if ( typeof context.getElementsByTagName !== "undefined" ) { + return context.getElementsByTagName( tag ); + + // DocumentFragment nodes don't have gEBTN + } else if ( support.qsa ) { + return context.querySelectorAll( tag ); + } + } : + + function( tag, context ) { + var elem, + tmp = [], + i = 0, + // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too + results = context.getElementsByTagName( tag ); + + // Filter out possible comments + if ( tag === "*" ) { + while ( (elem = results[i++]) ) { + if ( elem.nodeType === 1 ) { + tmp.push( elem ); + } + } + + return tmp; + } + return results; + }; + + // Class + Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { + if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { + return context.getElementsByClassName( className ); + } + }; + + /* QSA/matchesSelector + ---------------------------------------------------------------------- */ + + // QSA and matchesSelector support + + // matchesSelector(:active) reports false when true (IE9/Opera 11.5) + rbuggyMatches = []; + + // qSa(:focus) reports false when true (Chrome 21) + // We allow this because of a bug in IE8/9 that throws an error + // whenever `document.activeElement` is accessed on an iframe + // So, we allow :focus to pass through QSA all the time to avoid the IE error + // See https://bugs.jquery.com/ticket/13378 + rbuggyQSA = []; + + if ( (support.qsa = rnative.test( document.querySelectorAll )) ) { + // Build QSA regex + // Regex strategy adopted from Diego Perini + assert(function( el ) { + // Select is set to empty string on purpose + // This is to test IE's treatment of not explicitly + // setting a boolean content attribute, + // since its presence should be enough + // https://bugs.jquery.com/ticket/12359 + docElem.appendChild( el ).innerHTML = "" + + ""; + + // Support: IE8, Opera 11-12.16 + // Nothing should be selected when empty strings follow ^= or $= or *= + // The test attribute must be unknown in Opera but "safe" for WinRT + // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section + if ( el.querySelectorAll("[msallowcapture^='']").length ) { + rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); + } + + // Support: IE8 + // Boolean attributes and "value" are not treated correctly + if ( !el.querySelectorAll("[selected]").length ) { + rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); + } + + // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ + if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { + rbuggyQSA.push("~="); + } + + // Webkit/Opera - :checked should return selected option elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + // IE8 throws error here and will not see later tests + if ( !el.querySelectorAll(":checked").length ) { + rbuggyQSA.push(":checked"); + } + + // Support: Safari 8+, iOS 8+ + // https://bugs.webkit.org/show_bug.cgi?id=136851 + // In-page `selector#id sibling-combinator selector` fails + if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { + rbuggyQSA.push(".#.+[+~]"); + } + }); + + assert(function( el ) { + el.innerHTML = "" + + ""; + + // Support: Windows 8 Native Apps + // The type and name attributes are restricted during .innerHTML assignment + var input = document.createElement("input"); + input.setAttribute( "type", "hidden" ); + el.appendChild( input ).setAttribute( "name", "D" ); + + // Support: IE8 + // Enforce case-sensitivity of name attribute + if ( el.querySelectorAll("[name=d]").length ) { + rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); + } + + // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) + // IE8 throws error here and will not see later tests + if ( el.querySelectorAll(":enabled").length !== 2 ) { + rbuggyQSA.push( ":enabled", ":disabled" ); + } + + // Support: IE9-11+ + // IE's :disabled selector does not pick up the children of disabled fieldsets + docElem.appendChild( el ).disabled = true; + if ( el.querySelectorAll(":disabled").length !== 2 ) { + rbuggyQSA.push( ":enabled", ":disabled" ); + } + + // Opera 10-11 does not throw on post-comma invalid pseudos + el.querySelectorAll("*,:x"); + rbuggyQSA.push(",.*:"); + }); + } + + if ( (support.matchesSelector = rnative.test( (matches = docElem.matches || + docElem.webkitMatchesSelector || + docElem.mozMatchesSelector || + docElem.oMatchesSelector || + docElem.msMatchesSelector) )) ) { + + assert(function( el ) { + // Check to see if it's possible to do matchesSelector + // on a disconnected node (IE 9) + support.disconnectedMatch = matches.call( el, "*" ); + + // This should fail with an exception + // Gecko does not error, returns false instead + matches.call( el, "[s!='']:x" ); + rbuggyMatches.push( "!=", pseudos ); + }); + } + + rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); + rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); + + /* Contains + ---------------------------------------------------------------------- */ + hasCompare = rnative.test( docElem.compareDocumentPosition ); + + // Element contains another + // Purposefully self-exclusive + // As in, an element does not contain itself + contains = hasCompare || rnative.test( docElem.contains ) ? + function( a, b ) { + var adown = a.nodeType === 9 ? a.documentElement : a, + bup = b && b.parentNode; + return a === bup || !!( bup && bup.nodeType === 1 && ( + adown.contains ? + adown.contains( bup ) : + a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 + )); + } : + function( a, b ) { + if ( b ) { + while ( (b = b.parentNode) ) { + if ( b === a ) { + return true; + } + } + } + return false; + }; + + /* Sorting + ---------------------------------------------------------------------- */ + + // Document order sorting + sortOrder = hasCompare ? + function( a, b ) { + + // Flag for duplicate removal + if ( a === b ) { + hasDuplicate = true; + return 0; + } + + // Sort on method existence if only one input has compareDocumentPosition + var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; + if ( compare ) { + return compare; + } + + // Calculate position if both inputs belong to the same document + compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ? + a.compareDocumentPosition( b ) : + + // Otherwise we know they are disconnected + 1; + + // Disconnected nodes + if ( compare & 1 || + (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) { + + // Choose the first element that is related to our preferred document + if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) { + return -1; + } + if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) { + return 1; + } + + // Maintain original order + return sortInput ? + ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : + 0; + } + + return compare & 4 ? -1 : 1; + } : + function( a, b ) { + // Exit early if the nodes are identical + if ( a === b ) { + hasDuplicate = true; + return 0; + } + + var cur, + i = 0, + aup = a.parentNode, + bup = b.parentNode, + ap = [ a ], + bp = [ b ]; + + // Parentless nodes are either documents or disconnected + if ( !aup || !bup ) { + return a === document ? -1 : + b === document ? 1 : + aup ? -1 : + bup ? 1 : + sortInput ? + ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : + 0; + + // If the nodes are siblings, we can do a quick check + } else if ( aup === bup ) { + return siblingCheck( a, b ); + } + + // Otherwise we need full lists of their ancestors for comparison + cur = a; + while ( (cur = cur.parentNode) ) { + ap.unshift( cur ); + } + cur = b; + while ( (cur = cur.parentNode) ) { + bp.unshift( cur ); + } + + // Walk down the tree looking for a discrepancy + while ( ap[i] === bp[i] ) { + i++; + } + + return i ? + // Do a sibling check if the nodes have a common ancestor + siblingCheck( ap[i], bp[i] ) : + + // Otherwise nodes in our document sort first + ap[i] === preferredDoc ? -1 : + bp[i] === preferredDoc ? 1 : + 0; + }; + + return document; +}; + +Sizzle.matches = function( expr, elements ) { + return Sizzle( expr, null, null, elements ); +}; + +Sizzle.matchesSelector = function( elem, expr ) { + // Set document vars if needed + if ( ( elem.ownerDocument || elem ) !== document ) { + setDocument( elem ); + } + + if ( support.matchesSelector && documentIsHTML && + !nonnativeSelectorCache[ expr + " " ] && + ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && + ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { + + try { + var ret = matches.call( elem, expr ); + + // IE 9's matchesSelector returns false on disconnected nodes + if ( ret || support.disconnectedMatch || + // As well, disconnected nodes are said to be in a document + // fragment in IE 9 + elem.document && elem.document.nodeType !== 11 ) { + return ret; + } + } catch (e) { + nonnativeSelectorCache( expr, true ); + } + } + + return Sizzle( expr, document, null, [ elem ] ).length > 0; +}; + +Sizzle.contains = function( context, elem ) { + // Set document vars if needed + if ( ( context.ownerDocument || context ) !== document ) { + setDocument( context ); + } + return contains( context, elem ); +}; + +Sizzle.attr = function( elem, name ) { + // Set document vars if needed + if ( ( elem.ownerDocument || elem ) !== document ) { + setDocument( elem ); + } + + var fn = Expr.attrHandle[ name.toLowerCase() ], + // Don't get fooled by Object.prototype properties (jQuery #13807) + val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? + fn( elem, name, !documentIsHTML ) : + undefined; + + return val !== undefined ? + val : + support.attributes || !documentIsHTML ? + elem.getAttribute( name ) : + (val = elem.getAttributeNode(name)) && val.specified ? + val.value : + null; +}; + +Sizzle.escape = function( sel ) { + return (sel + "").replace( rcssescape, fcssescape ); +}; + +Sizzle.error = function( msg ) { + throw new Error( "Syntax error, unrecognized expression: " + msg ); +}; + +/** + * Document sorting and removing duplicates + * @param {ArrayLike} results + */ +Sizzle.uniqueSort = function( results ) { + var elem, + duplicates = [], + j = 0, + i = 0; + + // Unless we *know* we can detect duplicates, assume their presence + hasDuplicate = !support.detectDuplicates; + sortInput = !support.sortStable && results.slice( 0 ); + results.sort( sortOrder ); + + if ( hasDuplicate ) { + while ( (elem = results[i++]) ) { + if ( elem === results[ i ] ) { + j = duplicates.push( i ); + } + } + while ( j-- ) { + results.splice( duplicates[ j ], 1 ); + } + } + + // Clear input after sorting to release objects + // See https://github.com/jquery/sizzle/pull/225 + sortInput = null; + + return results; +}; + +/** + * Utility function for retrieving the text value of an array of DOM nodes + * @param {Array|Element} elem + */ +getText = Sizzle.getText = function( elem ) { + var node, + ret = "", + i = 0, + nodeType = elem.nodeType; + + if ( !nodeType ) { + // If no nodeType, this is expected to be an array + while ( (node = elem[i++]) ) { + // Do not traverse comment nodes + ret += getText( node ); + } + } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { + // Use textContent for elements + // innerText usage removed for consistency of new lines (jQuery #11153) + if ( typeof elem.textContent === "string" ) { + return elem.textContent; + } else { + // Traverse its children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + ret += getText( elem ); + } + } + } else if ( nodeType === 3 || nodeType === 4 ) { + return elem.nodeValue; + } + // Do not include comment or processing instruction nodes + + return ret; +}; + +Expr = Sizzle.selectors = { + + // Can be adjusted by the user + cacheLength: 50, + + createPseudo: markFunction, + + match: matchExpr, + + attrHandle: {}, + + find: {}, + + relative: { + ">": { dir: "parentNode", first: true }, + " ": { dir: "parentNode" }, + "+": { dir: "previousSibling", first: true }, + "~": { dir: "previousSibling" } + }, + + preFilter: { + "ATTR": function( match ) { + match[1] = match[1].replace( runescape, funescape ); + + // Move the given value to match[3] whether quoted or unquoted + match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape ); + + if ( match[2] === "~=" ) { + match[3] = " " + match[3] + " "; + } + + return match.slice( 0, 4 ); + }, + + "CHILD": function( match ) { + /* matches from matchExpr["CHILD"] + 1 type (only|nth|...) + 2 what (child|of-type) + 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) + 4 xn-component of xn+y argument ([+-]?\d*n|) + 5 sign of xn-component + 6 x of xn-component + 7 sign of y-component + 8 y of y-component + */ + match[1] = match[1].toLowerCase(); + + if ( match[1].slice( 0, 3 ) === "nth" ) { + // nth-* requires argument + if ( !match[3] ) { + Sizzle.error( match[0] ); + } + + // numeric x and y parameters for Expr.filter.CHILD + // remember that false/true cast respectively to 0/1 + match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); + match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); + + // other types prohibit arguments + } else if ( match[3] ) { + Sizzle.error( match[0] ); + } + + return match; + }, + + "PSEUDO": function( match ) { + var excess, + unquoted = !match[6] && match[2]; + + if ( matchExpr["CHILD"].test( match[0] ) ) { + return null; + } + + // Accept quoted arguments as-is + if ( match[3] ) { + match[2] = match[4] || match[5] || ""; + + // Strip excess characters from unquoted arguments + } else if ( unquoted && rpseudo.test( unquoted ) && + // Get excess from tokenize (recursively) + (excess = tokenize( unquoted, true )) && + // advance to the next closing parenthesis + (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { + + // excess is a negative index + match[0] = match[0].slice( 0, excess ); + match[2] = unquoted.slice( 0, excess ); + } + + // Return only captures needed by the pseudo filter method (type and argument) + return match.slice( 0, 3 ); + } + }, + + filter: { + + "TAG": function( nodeNameSelector ) { + var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); + return nodeNameSelector === "*" ? + function() { return true; } : + function( elem ) { + return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; + }; + }, + + "CLASS": function( className ) { + var pattern = classCache[ className + " " ]; + + return pattern || + (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && + classCache( className, function( elem ) { + return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" ); + }); + }, + + "ATTR": function( name, operator, check ) { + return function( elem ) { + var result = Sizzle.attr( elem, name ); + + if ( result == null ) { + return operator === "!="; + } + if ( !operator ) { + return true; + } + + result += ""; + + 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; + }; + }, + + "CHILD": function( type, what, argument, first, last ) { + var simple = type.slice( 0, 3 ) !== "nth", + forward = type.slice( -4 ) !== "last", + ofType = what === "of-type"; + + return first === 1 && last === 0 ? + + // Shortcut for :nth-*(n) + function( elem ) { + return !!elem.parentNode; + } : + + function( elem, context, xml ) { + var cache, uniqueCache, outerCache, node, nodeIndex, start, + dir = simple !== forward ? "nextSibling" : "previousSibling", + parent = elem.parentNode, + name = ofType && elem.nodeName.toLowerCase(), + useCache = !xml && !ofType, + diff = false; + + if ( parent ) { + + // :(first|last|only)-(child|of-type) + if ( simple ) { + while ( dir ) { + node = elem; + while ( (node = node[ dir ]) ) { + if ( ofType ? + node.nodeName.toLowerCase() === name : + node.nodeType === 1 ) { + + return false; + } + } + // Reverse direction for :only-* (if we haven't yet done so) + start = dir = type === "only" && !start && "nextSibling"; + } + return true; + } + + start = [ forward ? parent.firstChild : parent.lastChild ]; + + // non-xml :nth-child(...) stores cache data on `parent` + if ( forward && useCache ) { + + // Seek `elem` from a previously-cached index + + // ...in a gzip-friendly way + node = parent; + outerCache = node[ expando ] || (node[ expando ] = {}); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + (outerCache[ node.uniqueID ] = {}); + + cache = uniqueCache[ type ] || []; + nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; + diff = nodeIndex && cache[ 2 ]; + node = nodeIndex && parent.childNodes[ nodeIndex ]; + + while ( (node = ++nodeIndex && node && node[ dir ] || + + // Fallback to seeking `elem` from the start + (diff = nodeIndex = 0) || start.pop()) ) { + + // When found, cache indexes on `parent` and break + if ( node.nodeType === 1 && ++diff && node === elem ) { + uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; + break; + } + } + + } else { + // Use previously-cached element index if available + if ( useCache ) { + // ...in a gzip-friendly way + node = elem; + outerCache = node[ expando ] || (node[ expando ] = {}); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + (outerCache[ node.uniqueID ] = {}); + + cache = uniqueCache[ type ] || []; + nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; + diff = nodeIndex; + } + + // xml :nth-child(...) + // or :nth-last-child(...) or :nth(-last)?-of-type(...) + if ( diff === false ) { + // Use the same loop as above to seek `elem` from the start + while ( (node = ++nodeIndex && node && node[ dir ] || + (diff = nodeIndex = 0) || start.pop()) ) { + + if ( ( ofType ? + node.nodeName.toLowerCase() === name : + node.nodeType === 1 ) && + ++diff ) { + + // Cache the index of each encountered element + if ( useCache ) { + outerCache = node[ expando ] || (node[ expando ] = {}); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + (outerCache[ node.uniqueID ] = {}); + + uniqueCache[ type ] = [ dirruns, diff ]; + } + + if ( node === elem ) { + break; + } + } + } + } + } + + // Incorporate the offset, then check against cycle size + diff -= last; + return diff === first || ( diff % first === 0 && diff / first >= 0 ); + } + }; + }, + + "PSEUDO": function( pseudo, argument ) { + // pseudo-class names are case-insensitive + // http://www.w3.org/TR/selectors/#pseudo-classes + // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters + // Remember that setFilters inherits from pseudos + var args, + fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || + Sizzle.error( "unsupported pseudo: " + pseudo ); + + // The user may use createPseudo to indicate that + // arguments are needed to create the filter function + // just as Sizzle does + if ( fn[ expando ] ) { + return fn( argument ); + } + + // But maintain support for old signatures + if ( fn.length > 1 ) { + args = [ pseudo, pseudo, "", argument ]; + return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? + markFunction(function( seed, matches ) { + var idx, + matched = fn( seed, argument ), + i = matched.length; + while ( i-- ) { + idx = indexOf( seed, matched[i] ); + seed[ idx ] = !( matches[ idx ] = matched[i] ); + } + }) : + function( elem ) { + return fn( elem, 0, args ); + }; + } + + return fn; + } + }, + + pseudos: { + // Potentially complex pseudos + "not": markFunction(function( selector ) { + // Trim the selector passed to compile + // to avoid treating leading and trailing + // spaces as combinators + var input = [], + results = [], + matcher = compile( selector.replace( rtrim, "$1" ) ); + + return matcher[ expando ] ? + markFunction(function( seed, matches, context, xml ) { + var elem, + unmatched = matcher( seed, null, xml, [] ), + i = seed.length; + + // Match elements unmatched by `matcher` + while ( i-- ) { + if ( (elem = unmatched[i]) ) { + seed[i] = !(matches[i] = elem); + } + } + }) : + function( elem, context, xml ) { + input[0] = elem; + matcher( input, null, xml, results ); + // Don't keep the element (issue #299) + input[0] = null; + return !results.pop(); + }; + }), + + "has": markFunction(function( selector ) { + return function( elem ) { + return Sizzle( selector, elem ).length > 0; + }; + }), + + "contains": markFunction(function( text ) { + text = text.replace( runescape, funescape ); + return function( elem ) { + return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1; + }; + }), + + // "Whether an element is represented by a :lang() selector + // is based solely on the element's language value + // being equal to the identifier C, + // or beginning with the identifier C immediately followed by "-". + // The matching of C against the element's language value is performed case-insensitively. + // The identifier C does not have to be a valid language name." + // http://www.w3.org/TR/selectors/#lang-pseudo + "lang": markFunction( function( lang ) { + // lang value must be a valid identifier + if ( !ridentifier.test(lang || "") ) { + Sizzle.error( "unsupported lang: " + lang ); + } + lang = lang.replace( runescape, funescape ).toLowerCase(); + return function( elem ) { + var elemLang; + do { + if ( (elemLang = documentIsHTML ? + elem.lang : + elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) { + + elemLang = elemLang.toLowerCase(); + return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; + } + } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); + return false; + }; + }), + + // Miscellaneous + "target": function( elem ) { + var hash = window.location && window.location.hash; + return hash && hash.slice( 1 ) === elem.id; + }, + + "root": function( elem ) { + return elem === docElem; + }, + + "focus": function( elem ) { + return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); + }, + + // Boolean properties + "enabled": createDisabledPseudo( false ), + "disabled": createDisabledPseudo( true ), + + "checked": function( elem ) { + // In CSS3, :checked should return both checked and selected elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + var nodeName = elem.nodeName.toLowerCase(); + return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); + }, + + "selected": function( elem ) { + // Accessing this property makes selected-by-default + // options in Safari work properly + if ( elem.parentNode ) { + elem.parentNode.selectedIndex; + } + + return elem.selected === true; + }, + + // Contents + "empty": function( elem ) { + // http://www.w3.org/TR/selectors/#empty-pseudo + // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), + // but not by others (comment: 8; processing instruction: 7; etc.) + // nodeType < 6 works because attributes (2) do not appear as children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + if ( elem.nodeType < 6 ) { + return false; + } + } + return true; + }, + + "parent": function( elem ) { + return !Expr.pseudos["empty"]( elem ); + }, + + // Element/input types + "header": function( elem ) { + return rheader.test( elem.nodeName ); + }, + + "input": function( elem ) { + return rinputs.test( elem.nodeName ); + }, + + "button": function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === "button" || name === "button"; + }, + + "text": function( elem ) { + var attr; + return elem.nodeName.toLowerCase() === "input" && + elem.type === "text" && + + // Support: IE<8 + // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" + ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" ); + }, + + // Position-in-collection + "first": createPositionalPseudo(function() { + return [ 0 ]; + }), + + "last": createPositionalPseudo(function( matchIndexes, length ) { + return [ length - 1 ]; + }), + + "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { + return [ argument < 0 ? argument + length : argument ]; + }), + + "even": createPositionalPseudo(function( matchIndexes, length ) { + var i = 0; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + }), + + "odd": createPositionalPseudo(function( matchIndexes, length ) { + var i = 1; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + }), + + "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { + var i = argument < 0 ? + argument + length : + argument > length ? + length : + argument; + for ( ; --i >= 0; ) { + matchIndexes.push( i ); + } + return matchIndexes; + }), + + "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { + var i = argument < 0 ? argument + length : argument; + for ( ; ++i < length; ) { + matchIndexes.push( i ); + } + return matchIndexes; + }) + } +}; + +Expr.pseudos["nth"] = Expr.pseudos["eq"]; + +// Add button/input type pseudos +for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { + Expr.pseudos[ i ] = createInputPseudo( i ); +} +for ( i in { submit: true, reset: true } ) { + Expr.pseudos[ i ] = createButtonPseudo( i ); +} + +// Easy API for creating new setFilters +function setFilters() {} +setFilters.prototype = Expr.filters = Expr.pseudos; +Expr.setFilters = new setFilters(); + +tokenize = Sizzle.tokenize = function( selector, parseOnly ) { + var matched, match, tokens, type, + soFar, groups, preFilters, + cached = tokenCache[ selector + " " ]; + + if ( cached ) { + return parseOnly ? 0 : cached.slice( 0 ); + } + + soFar = selector; + groups = []; + preFilters = Expr.preFilter; + + while ( soFar ) { + + // Comma and first run + if ( !matched || (match = rcomma.exec( soFar )) ) { + if ( match ) { + // Don't consume trailing commas as valid + soFar = soFar.slice( match[0].length ) || soFar; + } + groups.push( (tokens = []) ); + } + + matched = false; + + // Combinators + if ( (match = rcombinators.exec( soFar )) ) { + matched = match.shift(); + tokens.push({ + value: matched, + // Cast descendant combinators to space + type: match[0].replace( rtrim, " " ) + }); + soFar = soFar.slice( matched.length ); + } + + // Filters + for ( type in Expr.filter ) { + if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || + (match = preFilters[ type ]( match ))) ) { + matched = match.shift(); + tokens.push({ + value: matched, + type: type, + matches: match + }); + soFar = soFar.slice( matched.length ); + } + } + + if ( !matched ) { + break; + } + } + + // Return the length of the invalid excess + // if we're just parsing + // Otherwise, throw an error or return tokens + return parseOnly ? + soFar.length : + soFar ? + Sizzle.error( selector ) : + // Cache the tokens + tokenCache( selector, groups ).slice( 0 ); +}; + +function toSelector( tokens ) { + var i = 0, + len = tokens.length, + selector = ""; + for ( ; i < len; i++ ) { + selector += tokens[i].value; + } + return selector; +} + +function addCombinator( matcher, combinator, base ) { + var dir = combinator.dir, + skip = combinator.next, + key = skip || dir, + checkNonElements = base && key === "parentNode", + doneName = done++; + + return combinator.first ? + // Check against closest ancestor/preceding element + function( elem, context, xml ) { + while ( (elem = elem[ dir ]) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + return matcher( elem, context, xml ); + } + } + return false; + } : + + // Check against all ancestor/preceding elements + function( elem, context, xml ) { + var oldCache, uniqueCache, outerCache, + newCache = [ dirruns, doneName ]; + + // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching + if ( xml ) { + while ( (elem = elem[ dir ]) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + if ( matcher( elem, context, xml ) ) { + return true; + } + } + } + } else { + while ( (elem = elem[ dir ]) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + outerCache = elem[ expando ] || (elem[ expando ] = {}); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {}); + + if ( skip && skip === elem.nodeName.toLowerCase() ) { + elem = elem[ dir ] || elem; + } else if ( (oldCache = uniqueCache[ key ]) && + oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { + + // Assign to newCache so results back-propagate to previous elements + return (newCache[ 2 ] = oldCache[ 2 ]); + } else { + // Reuse newcache so results back-propagate to previous elements + uniqueCache[ key ] = newCache; + + // A match means we're done; a fail means we have to keep checking + if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) { + return true; + } + } + } + } + } + return false; + }; +} + +function elementMatcher( matchers ) { + return matchers.length > 1 ? + function( elem, context, xml ) { + var i = matchers.length; + while ( i-- ) { + if ( !matchers[i]( elem, context, xml ) ) { + return false; + } + } + return true; + } : + matchers[0]; +} + +function multipleContexts( selector, contexts, results ) { + var i = 0, + len = contexts.length; + for ( ; i < len; i++ ) { + Sizzle( selector, contexts[i], results ); + } + return results; +} + +function condense( unmatched, map, filter, context, xml ) { + var elem, + newUnmatched = [], + i = 0, + len = unmatched.length, + mapped = map != null; + + for ( ; i < len; i++ ) { + if ( (elem = unmatched[i]) ) { + if ( !filter || filter( elem, context, xml ) ) { + newUnmatched.push( elem ); + if ( mapped ) { + map.push( i ); + } + } + } + } + + return newUnmatched; +} + +function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { + if ( postFilter && !postFilter[ expando ] ) { + postFilter = setMatcher( postFilter ); + } + if ( postFinder && !postFinder[ expando ] ) { + postFinder = setMatcher( postFinder, postSelector ); + } + return markFunction(function( seed, results, context, xml ) { + var temp, i, elem, + preMap = [], + postMap = [], + preexisting = results.length, + + // Get initial elements from seed or context + elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), + + // Prefilter to get matcher input, preserving a map for seed-results synchronization + matcherIn = preFilter && ( seed || !selector ) ? + condense( elems, preMap, preFilter, context, xml ) : + elems, + + matcherOut = matcher ? + // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, + postFinder || ( seed ? preFilter : preexisting || postFilter ) ? + + // ...intermediate processing is necessary + [] : + + // ...otherwise use results directly + results : + matcherIn; + + // Find primary matches + if ( matcher ) { + matcher( matcherIn, matcherOut, context, xml ); + } + + // Apply postFilter + if ( postFilter ) { + temp = condense( matcherOut, postMap ); + postFilter( temp, [], context, xml ); + + // Un-match failing elements by moving them back to matcherIn + i = temp.length; + while ( i-- ) { + if ( (elem = temp[i]) ) { + matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); + } + } + } + + if ( seed ) { + if ( postFinder || preFilter ) { + if ( postFinder ) { + // Get the final matcherOut by condensing this intermediate into postFinder contexts + temp = []; + i = matcherOut.length; + while ( i-- ) { + if ( (elem = matcherOut[i]) ) { + // Restore matcherIn since elem is not yet a final match + temp.push( (matcherIn[i] = elem) ); + } + } + postFinder( null, (matcherOut = []), temp, xml ); + } + + // Move matched elements from seed to results to keep them synchronized + i = matcherOut.length; + while ( i-- ) { + if ( (elem = matcherOut[i]) && + (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) { + + seed[temp] = !(results[temp] = elem); + } + } + } + + // Add elements to results, through postFinder if defined + } else { + matcherOut = condense( + matcherOut === results ? + matcherOut.splice( preexisting, matcherOut.length ) : + matcherOut + ); + if ( postFinder ) { + postFinder( null, results, matcherOut, xml ); + } else { + push.apply( results, matcherOut ); + } + } + }); +} + +function matcherFromTokens( tokens ) { + var checkContext, matcher, j, + len = tokens.length, + leadingRelative = Expr.relative[ tokens[0].type ], + implicitRelative = leadingRelative || Expr.relative[" "], + i = leadingRelative ? 1 : 0, + + // The foundational matcher ensures that elements are reachable from top-level context(s) + matchContext = addCombinator( function( elem ) { + return elem === checkContext; + }, implicitRelative, true ), + matchAnyContext = addCombinator( function( elem ) { + return indexOf( checkContext, elem ) > -1; + }, implicitRelative, true ), + matchers = [ function( elem, context, xml ) { + var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( + (checkContext = context).nodeType ? + matchContext( elem, context, xml ) : + matchAnyContext( elem, context, xml ) ); + // Avoid hanging onto element (issue #299) + checkContext = null; + return ret; + } ]; + + for ( ; i < len; i++ ) { + if ( (matcher = Expr.relative[ tokens[i].type ]) ) { + matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; + } else { + matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); + + // Return special upon seeing a positional matcher + if ( matcher[ expando ] ) { + // Find the next relative operator (if any) for proper handling + j = ++i; + for ( ; j < len; j++ ) { + if ( Expr.relative[ tokens[j].type ] ) { + break; + } + } + return setMatcher( + i > 1 && elementMatcher( matchers ), + i > 1 && toSelector( + // If the preceding token was a descendant combinator, insert an implicit any-element `*` + tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) + ).replace( rtrim, "$1" ), + matcher, + i < j && matcherFromTokens( tokens.slice( i, j ) ), + j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), + j < len && toSelector( tokens ) + ); + } + matchers.push( matcher ); + } + } + + return elementMatcher( matchers ); +} + +function matcherFromGroupMatchers( elementMatchers, setMatchers ) { + var bySet = setMatchers.length > 0, + byElement = elementMatchers.length > 0, + superMatcher = function( seed, context, xml, results, outermost ) { + var elem, j, matcher, + matchedCount = 0, + i = "0", + unmatched = seed && [], + setMatched = [], + contextBackup = outermostContext, + // We must always have either seed elements or outermost context + elems = seed || byElement && Expr.find["TAG"]( "*", outermost ), + // Use integer dirruns iff this is the outermost matcher + dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), + len = elems.length; + + if ( outermost ) { + outermostContext = context === document || context || outermost; + } + + // Add elements passing elementMatchers directly to results + // Support: IE<9, Safari + // Tolerate NodeList properties (IE: "length"; Safari: ) matching elements by id + for ( ; i !== len && (elem = elems[i]) != null; i++ ) { + if ( byElement && elem ) { + j = 0; + if ( !context && elem.ownerDocument !== document ) { + setDocument( elem ); + xml = !documentIsHTML; + } + while ( (matcher = elementMatchers[j++]) ) { + if ( matcher( elem, context || document, xml) ) { + results.push( elem ); + break; + } + } + if ( outermost ) { + dirruns = dirrunsUnique; + } + } + + // Track unmatched elements for set filters + if ( bySet ) { + // They will have gone through all possible matchers + if ( (elem = !matcher && elem) ) { + matchedCount--; + } + + // Lengthen the array for every element, matched or not + if ( seed ) { + unmatched.push( elem ); + } + } + } + + // `i` is now the count of elements visited above, and adding it to `matchedCount` + // makes the latter nonnegative. + matchedCount += i; + + // Apply set filters to unmatched elements + // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` + // equals `i`), unless we didn't visit _any_ elements in the above loop because we have + // no element matchers and no seed. + // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that + // case, which will result in a "00" `matchedCount` that differs from `i` but is also + // numerically zero. + if ( bySet && i !== matchedCount ) { + j = 0; + while ( (matcher = setMatchers[j++]) ) { + matcher( unmatched, setMatched, context, xml ); + } + + if ( seed ) { + // Reintegrate element matches to eliminate the need for sorting + if ( matchedCount > 0 ) { + while ( i-- ) { + if ( !(unmatched[i] || setMatched[i]) ) { + setMatched[i] = pop.call( results ); + } + } + } + + // Discard index placeholder values to get only actual matches + setMatched = condense( setMatched ); + } + + // Add matches to results + push.apply( results, setMatched ); + + // Seedless set matches succeeding multiple successful matchers stipulate sorting + if ( outermost && !seed && setMatched.length > 0 && + ( matchedCount + setMatchers.length ) > 1 ) { + + Sizzle.uniqueSort( results ); + } + } + + // Override manipulation of globals by nested matchers + if ( outermost ) { + dirruns = dirrunsUnique; + outermostContext = contextBackup; + } + + return unmatched; + }; + + return bySet ? + markFunction( superMatcher ) : + superMatcher; +} + +compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { + var i, + setMatchers = [], + elementMatchers = [], + cached = compilerCache[ selector + " " ]; + + if ( !cached ) { + // Generate a function of recursive functions that can be used to check each element + if ( !match ) { + match = tokenize( selector ); + } + i = match.length; + while ( i-- ) { + cached = matcherFromTokens( match[i] ); + if ( cached[ expando ] ) { + setMatchers.push( cached ); + } else { + elementMatchers.push( cached ); + } + } + + // Cache the compiled function + cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); + + // Save selector and tokenization + cached.selector = selector; + } + return cached; +}; + +/** + * A low-level selection function that works with Sizzle's compiled + * selector functions + * @param {String|Function} selector A selector or a pre-compiled + * selector function built with Sizzle.compile + * @param {Element} context + * @param {Array} [results] + * @param {Array} [seed] A set of elements to match against + */ +select = Sizzle.select = function( selector, context, results, seed ) { + var i, tokens, token, type, find, + compiled = typeof selector === "function" && selector, + match = !seed && tokenize( (selector = compiled.selector || selector) ); + + results = results || []; + + // Try to minimize operations if there is only one selector in the list and no seed + // (the latter of which guarantees us context) + if ( match.length === 1 ) { + + // Reduce context if the leading compound selector is an ID + tokens = match[0] = match[0].slice( 0 ); + if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && + context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) { + + context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; + if ( !context ) { + return results; + + // Precompiled matchers will still verify ancestry, so step up a level + } else if ( compiled ) { + context = context.parentNode; + } + + selector = selector.slice( tokens.shift().value.length ); + } + + // Fetch a seed set for right-to-left matching + i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; + while ( i-- ) { + token = tokens[i]; + + // Abort if we hit a combinator + if ( Expr.relative[ (type = token.type) ] ) { + break; + } + if ( (find = Expr.find[ type ]) ) { + // Search, expanding context for leading sibling combinators + if ( (seed = find( + token.matches[0].replace( runescape, funescape ), + rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context + )) ) { + + // If seed is empty or no tokens remain, we can return early + tokens.splice( i, 1 ); + selector = seed.length && toSelector( tokens ); + if ( !selector ) { + push.apply( results, seed ); + return results; + } + + break; + } + } + } + } + + // Compile and execute a filtering function if one is not provided + // Provide `match` to avoid retokenization if we modified the selector above + ( compiled || compile( selector, match ) )( + seed, + context, + !documentIsHTML, + results, + !context || rsibling.test( selector ) && testContext( context.parentNode ) || context + ); + return results; +}; + +// One-time assignments + +// Sort stability +support.sortStable = expando.split("").sort( sortOrder ).join("") === expando; + +// Support: Chrome 14-35+ +// Always assume duplicates if they aren't passed to the comparison function +support.detectDuplicates = !!hasDuplicate; + +// Initialize against the default document +setDocument(); + +// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) +// Detached nodes confoundingly follow *each other* +support.sortDetached = assert(function( el ) { + // Should return 1, but returns 4 (following) + return el.compareDocumentPosition( document.createElement("fieldset") ) & 1; +}); + +// Support: IE<8 +// Prevent attribute/property "interpolation" +// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx +if ( !assert(function( el ) { + el.innerHTML = ""; + return el.firstChild.getAttribute("href") === "#" ; +}) ) { + addHandle( "type|href|height|width", function( elem, name, isXML ) { + if ( !isXML ) { + return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); + } + }); +} + +// Support: IE<9 +// Use defaultValue in place of getAttribute("value") +if ( !support.attributes || !assert(function( el ) { + el.innerHTML = ""; + el.firstChild.setAttribute( "value", "" ); + return el.firstChild.getAttribute( "value" ) === ""; +}) ) { + addHandle( "value", function( elem, name, isXML ) { + if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { + return elem.defaultValue; + } + }); +} + +// Support: IE<9 +// Use getAttributeNode to fetch booleans when getAttribute lies +if ( !assert(function( el ) { + return el.getAttribute("disabled") == null; +}) ) { + addHandle( booleans, function( elem, name, isXML ) { + var val; + if ( !isXML ) { + return elem[ name ] === true ? name.toLowerCase() : + (val = elem.getAttributeNode( name )) && val.specified ? + val.value : + null; + } + }); +} + +return Sizzle; + +})( window ); + + + +jQuery.find = Sizzle; +jQuery.expr = Sizzle.selectors; + +// Deprecated +jQuery.expr[ ":" ] = jQuery.expr.pseudos; +jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; +jQuery.text = Sizzle.getText; +jQuery.isXMLDoc = Sizzle.isXML; +jQuery.contains = Sizzle.contains; +jQuery.escapeSelector = Sizzle.escape; + + + + +var dir = function( elem, dir, until ) { + var matched = [], + truncate = until !== undefined; + + while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { + if ( elem.nodeType === 1 ) { + if ( truncate && jQuery( elem ).is( until ) ) { + break; + } + matched.push( elem ); + } + } + return matched; +}; + + +var siblings = function( n, elem ) { + var matched = []; + + for ( ; n; n = n.nextSibling ) { + if ( n.nodeType === 1 && n !== elem ) { + matched.push( n ); + } + } + + return matched; +}; + + +var rneedsContext = jQuery.expr.match.needsContext; + + + +function nodeName( elem, name ) { + + return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); + +}; +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 +function winnow( elements, qualifier, not ) { + if ( isFunction( qualifier ) ) { + return jQuery.grep( elements, function( elem, i ) { + return !!qualifier.call( elem, i, elem ) !== not; + } ); + } + + // Single element + if ( qualifier.nodeType ) { + return jQuery.grep( elements, function( elem ) { + return ( elem === qualifier ) !== not; + } ); + } + + // Arraylike of elements (jQuery, arguments, Array) + if ( typeof qualifier !== "string" ) { + return jQuery.grep( elements, function( elem ) { + return ( indexOf.call( qualifier, elem ) > -1 ) !== not; + } ); + } + + // Filtered directly for both simple and complex selectors + return jQuery.filter( qualifier, elements, not ); +} + +jQuery.filter = function( expr, elems, not ) { + var elem = elems[ 0 ]; + + if ( not ) { + expr = ":not(" + expr + ")"; + } + + if ( elems.length === 1 && elem.nodeType === 1 ) { + return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; + } + + return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { + return elem.nodeType === 1; + } ) ); +}; + +jQuery.fn.extend( { + find: function( selector ) { + var i, ret, + len = this.length, + self = this; + + if ( typeof selector !== "string" ) { + return this.pushStack( jQuery( selector ).filter( function() { + for ( i = 0; i < len; i++ ) { + if ( jQuery.contains( self[ i ], this ) ) { + return true; + } + } + } ) ); + } + + ret = this.pushStack( [] ); + + for ( i = 0; i < len; i++ ) { + jQuery.find( selector, self[ i ], ret ); + } + + return len > 1 ? jQuery.uniqueSort( ret ) : ret; + }, + filter: function( selector ) { + return this.pushStack( winnow( this, selector || [], false ) ); + }, + not: function( selector ) { + return this.pushStack( winnow( this, selector || [], true ) ); + }, + is: function( selector ) { + return !!winnow( + this, + + // If this is a positional/relative selector, check membership in the returned set + // so $("p:first").is("p:last") won't return true for a doc with two "p". + typeof selector === "string" && rneedsContext.test( selector ) ? + jQuery( selector ) : + selector || [], + false + ).length; + } +} ); + + +// Initialize a jQuery object + + +// A central reference to the root jQuery(document) +var rootjQuery, + + // A simple way to check for HTML strings + // Prioritize #id over to avoid XSS via location.hash (#9521) + // Strict HTML recognition (#11290: must start with <) + // Shortcut simple #id case for speed + rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, + + init = jQuery.fn.init = function( selector, context, root ) { + var match, elem; + + // HANDLE: $(""), $(null), $(undefined), $(false) + if ( !selector ) { + return this; + } + + // Method init() accepts an alternate rootjQuery + // so migrate can support jQuery.sub (gh-2101) + root = root || rootjQuery; + + // Handle HTML strings + if ( typeof selector === "string" ) { + if ( selector[ 0 ] === "<" && + selector[ selector.length - 1 ] === ">" && + selector.length >= 3 ) { + + // Assume that strings that start and end with <> are HTML and skip the regex check + match = [ null, selector, null ]; + + } else { + match = rquickExpr.exec( selector ); + } + + // Match html or make sure no context is specified for #id + if ( match && ( match[ 1 ] || !context ) ) { + + // HANDLE: $(html) -> $(array) + if ( match[ 1 ] ) { + context = context instanceof jQuery ? context[ 0 ] : context; + + // Option to run scripts is true for back-compat + // Intentionally let the error be thrown if parseHTML is not present + jQuery.merge( this, jQuery.parseHTML( + match[ 1 ], + context && context.nodeType ? context.ownerDocument || context : document, + true + ) ); + + // HANDLE: $(html, props) + if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { + for ( match in context ) { + + // Properties of context are called as methods if possible + if ( isFunction( this[ match ] ) ) { + this[ match ]( context[ match ] ); + + // ...and otherwise set as attributes + } else { + this.attr( match, context[ match ] ); + } + } + } + + return this; + + // HANDLE: $(#id) + } else { + elem = document.getElementById( match[ 2 ] ); + + if ( elem ) { + + // Inject the element directly into the jQuery object + this[ 0 ] = elem; + this.length = 1; + } + return this; + } + + // HANDLE: $(expr, $(...)) + } else if ( !context || context.jquery ) { + return ( context || root ).find( selector ); + + // HANDLE: $(expr, context) + // (which is just equivalent to: $(context).find(expr) + } else { + return this.constructor( context ).find( selector ); + } + + // HANDLE: $(DOMElement) + } else if ( selector.nodeType ) { + this[ 0 ] = selector; + this.length = 1; + return this; + + // HANDLE: $(function) + // Shortcut for document ready + } else if ( isFunction( selector ) ) { + return root.ready !== undefined ? + root.ready( selector ) : + + // Execute immediately if ready is not present + selector( jQuery ); + } + + return jQuery.makeArray( selector, this ); + }; + +// Give the init function the jQuery prototype for later instantiation +init.prototype = jQuery.fn; + +// Initialize central reference +rootjQuery = jQuery( document ); + + +var rparentsprev = /^(?:parents|prev(?:Until|All))/, + + // Methods guaranteed to produce a unique set when starting from a unique set + guaranteedUnique = { + children: true, + contents: true, + next: true, + prev: true + }; + +jQuery.fn.extend( { + has: function( target ) { + var targets = jQuery( target, this ), + l = targets.length; + + return this.filter( function() { + var i = 0; + for ( ; i < l; i++ ) { + if ( jQuery.contains( this, targets[ i ] ) ) { + return true; + } + } + } ); + }, + + closest: function( selectors, context ) { + var cur, + i = 0, + l = this.length, + matched = [], + targets = typeof selectors !== "string" && jQuery( selectors ); + + // Positional selectors never match, since there's no _selection_ context + if ( !rneedsContext.test( selectors ) ) { + for ( ; i < l; i++ ) { + for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { + + // Always skip document fragments + if ( cur.nodeType < 11 && ( targets ? + targets.index( cur ) > -1 : + + // Don't pass non-elements to Sizzle + cur.nodeType === 1 && + jQuery.find.matchesSelector( cur, selectors ) ) ) { + + matched.push( cur ); + break; + } + } + } + } + + return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); + }, + + // Determine the position of an element within the set + index: function( elem ) { + + // No argument, return index in parent + if ( !elem ) { + return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; + } + + // Index in selector + if ( typeof elem === "string" ) { + return indexOf.call( jQuery( elem ), this[ 0 ] ); + } + + // Locate the position of the desired element + return indexOf.call( this, + + // If it receives a jQuery object, the first element is used + elem.jquery ? elem[ 0 ] : elem + ); + }, + + add: function( selector, context ) { + return this.pushStack( + jQuery.uniqueSort( + jQuery.merge( this.get(), jQuery( selector, context ) ) + ) + ); + }, + + addBack: function( selector ) { + return this.add( selector == null ? + this.prevObject : this.prevObject.filter( selector ) + ); + } +} ); + +function sibling( cur, dir ) { + while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} + return cur; +} + +jQuery.each( { + parent: function( elem ) { + var parent = elem.parentNode; + return parent && parent.nodeType !== 11 ? parent : null; + }, + parents: function( elem ) { + return dir( elem, "parentNode" ); + }, + parentsUntil: function( elem, i, until ) { + return dir( elem, "parentNode", until ); + }, + next: function( elem ) { + return sibling( elem, "nextSibling" ); + }, + prev: function( elem ) { + return sibling( elem, "previousSibling" ); + }, + nextAll: function( elem ) { + return dir( elem, "nextSibling" ); + }, + prevAll: function( elem ) { + return dir( elem, "previousSibling" ); + }, + nextUntil: function( elem, i, until ) { + return dir( elem, "nextSibling", until ); + }, + prevUntil: function( elem, i, until ) { + return dir( elem, "previousSibling", until ); + }, + siblings: function( elem ) { + return siblings( ( elem.parentNode || {} ).firstChild, elem ); + }, + children: function( elem ) { + return siblings( elem.firstChild ); + }, + contents: function( elem ) { + if ( typeof elem.contentDocument !== "undefined" ) { + return elem.contentDocument; + } + + // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only + // Treat the template element as a regular one in browsers that + // don't support it. + if ( nodeName( elem, "template" ) ) { + elem = elem.content || elem; + } + + return jQuery.merge( [], elem.childNodes ); + } +}, function( name, fn ) { + jQuery.fn[ name ] = function( until, selector ) { + var matched = jQuery.map( this, fn, until ); + + if ( name.slice( -5 ) !== "Until" ) { + selector = until; + } + + if ( selector && typeof selector === "string" ) { + matched = jQuery.filter( selector, matched ); + } + + if ( this.length > 1 ) { + + // Remove duplicates + if ( !guaranteedUnique[ name ] ) { + jQuery.uniqueSort( matched ); + } + + // Reverse order for parents* and prev-derivatives + if ( rparentsprev.test( name ) ) { + matched.reverse(); + } + } + + return this.pushStack( matched ); + }; +} ); +var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); + + + +// Convert String-formatted options into Object-formatted ones +function createOptions( options ) { + var object = {}; + jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { + object[ flag ] = true; + } ); + return object; +} + +/* + * Create a callback list using the following parameters: + * + * options: an optional list of space-separated options that will change how + * the callback list behaves or a more traditional option object + * + * By default a callback list will act like an event callback list and can be + * "fired" multiple times. + * + * Possible options: + * + * once: will ensure the callback list can only be fired once (like a Deferred) + * + * memory: will keep track of previous values and will call any callback added + * after the list has been fired right away with the latest "memorized" + * values (like a Deferred) + * + * unique: will ensure a callback can only be added once (no duplicate in the list) + * + * stopOnFalse: interrupt callings when a callback returns false + * + */ +jQuery.Callbacks = function( options ) { + + // Convert options from String-formatted to Object-formatted if needed + // (we check in cache first) + options = typeof options === "string" ? + createOptions( options ) : + jQuery.extend( {}, options ); + + var // Flag to know if list is currently firing + firing, + + // Last fire value for non-forgettable lists + memory, + + // Flag to know if list was already fired + fired, + + // Flag to prevent firing + locked, + + // Actual callback list + list = [], + + // Queue of execution data for repeatable lists + queue = [], + + // Index of currently firing callback (modified by add/remove as needed) + firingIndex = -1, + + // Fire callbacks + fire = function() { + + // Enforce single-firing + locked = locked || options.once; + + // Execute callbacks for all pending executions, + // respecting firingIndex overrides and runtime changes + fired = firing = true; + for ( ; queue.length; firingIndex = -1 ) { + memory = queue.shift(); + while ( ++firingIndex < list.length ) { + + // Run callback and check for early termination + if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && + options.stopOnFalse ) { + + // Jump to end and forget the data so .add doesn't re-fire + firingIndex = list.length; + memory = false; + } + } + } + + // Forget the data if we're done with it + if ( !options.memory ) { + memory = false; + } + + firing = false; + + // Clean up if we're done firing for good + if ( locked ) { + + // Keep an empty list if we have data for future add calls + if ( memory ) { + list = []; + + // Otherwise, this object is spent + } else { + list = ""; + } + } + }, + + // Actual Callbacks object + self = { + + // Add a callback or a collection of callbacks to the list + add: function() { + if ( list ) { + + // If we have memory from a past run, we should fire after adding + if ( memory && !firing ) { + firingIndex = list.length - 1; + queue.push( memory ); + } + + ( function add( args ) { + jQuery.each( args, function( _, arg ) { + if ( isFunction( arg ) ) { + if ( !options.unique || !self.has( arg ) ) { + list.push( arg ); + } + } else if ( arg && arg.length && toType( arg ) !== "string" ) { + + // Inspect recursively + add( arg ); + } + } ); + } )( arguments ); + + if ( memory && !firing ) { + fire(); + } + } + return this; + }, + + // Remove a callback from the list + remove: function() { + jQuery.each( arguments, function( _, arg ) { + var index; + while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { + list.splice( index, 1 ); + + // Handle firing indexes + if ( index <= firingIndex ) { + firingIndex--; + } + } + } ); + return this; + }, + + // Check if a given callback is in the list. + // If no argument is given, return whether or not list has callbacks attached. + has: function( fn ) { + return fn ? + jQuery.inArray( fn, list ) > -1 : + list.length > 0; + }, + + // Remove all callbacks from the list + empty: function() { + if ( list ) { + list = []; + } + return this; + }, + + // Disable .fire and .add + // Abort any current/pending executions + // Clear all callbacks and values + disable: function() { + locked = queue = []; + list = memory = ""; + return this; + }, + disabled: function() { + return !list; + }, + + // Disable .fire + // Also disable .add unless we have memory (since it would have no effect) + // Abort any pending executions + lock: function() { + locked = queue = []; + if ( !memory && !firing ) { + list = memory = ""; + } + return this; + }, + locked: function() { + return !!locked; + }, + + // Call all callbacks with the given context and arguments + fireWith: function( context, args ) { + if ( !locked ) { + args = args || []; + args = [ context, args.slice ? args.slice() : args ]; + queue.push( args ); + if ( !firing ) { + fire(); + } + } + return this; + }, + + // Call all the callbacks with the given arguments + fire: function() { + self.fireWith( this, arguments ); + return this; + }, + + // To know if the callbacks have already been called at least once + fired: function() { + return !!fired; + } + }; + + return self; +}; + + +function Identity( v ) { + return v; +} +function Thrower( ex ) { + throw ex; +} + +function adoptValue( value, resolve, reject, noValue ) { + var method; + + try { + + // Check for promise aspect first to privilege synchronous behavior + if ( value && isFunction( ( method = value.promise ) ) ) { + method.call( value ).done( resolve ).fail( reject ); + + // Other thenables + } else if ( value && isFunction( ( method = value.then ) ) ) { + method.call( value, resolve, reject ); + + // Other non-thenables + } else { + + // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: + // * false: [ value ].slice( 0 ) => resolve( value ) + // * true: [ value ].slice( 1 ) => resolve() + resolve.apply( undefined, [ value ].slice( noValue ) ); + } + + // For Promises/A+, convert exceptions into rejections + // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in + // Deferred#then to conditionally suppress rejection. + } catch ( value ) { + + // Support: Android 4.0 only + // Strict mode functions invoked without .call/.apply get global-object context + reject.apply( undefined, [ value ] ); + } +} + +jQuery.extend( { + + Deferred: function( func ) { + var tuples = [ + + // action, add listener, callbacks, + // ... .then handlers, argument index, [final state] + [ "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" ] + ], + state = "pending", + promise = { + state: function() { + return state; + }, + always: function() { + deferred.done( arguments ).fail( arguments ); + return this; + }, + "catch": function( fn ) { + return promise.then( null, fn ); + }, + + // Keep pipe for back-compat + pipe: function( /* fnDone, fnFail, fnProgress */ ) { + var fns = arguments; + + return jQuery.Deferred( function( newDefer ) { + jQuery.each( tuples, function( i, tuple ) { + + // Map tuples (progress, done, fail) to arguments (done, fail, progress) + var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; + + // deferred.progress(function() { bind to newDefer or newDefer.notify }) + // deferred.done(function() { bind to newDefer or newDefer.resolve }) + // deferred.fail(function() { bind to newDefer or newDefer.reject }) + deferred[ tuple[ 1 ] ]( function() { + var returned = fn && fn.apply( this, arguments ); + if ( returned && isFunction( returned.promise ) ) { + returned.promise() + .progress( newDefer.notify ) + .done( newDefer.resolve ) + .fail( newDefer.reject ); + } else { + newDefer[ tuple[ 0 ] + "With" ]( + this, + fn ? [ returned ] : arguments + ); + } + } ); + } ); + fns = null; + } ).promise(); + }, + then: function( onFulfilled, onRejected, onProgress ) { + var maxDepth = 0; + function resolve( depth, deferred, handler, special ) { + return function() { + var that = this, + args = arguments, + mightThrow = function() { + var returned, then; + + // Support: Promises/A+ section 2.3.3.3.3 + // https://promisesaplus.com/#point-59 + // Ignore double-resolution attempts + if ( depth < maxDepth ) { + return; + } + + returned = handler.apply( that, args ); + + // Support: Promises/A+ section 2.3.1 + // https://promisesaplus.com/#point-48 + if ( returned === deferred.promise() ) { + throw new TypeError( "Thenable self-resolution" ); + } + + // Support: Promises/A+ sections 2.3.3.1, 3.5 + // https://promisesaplus.com/#point-54 + // https://promisesaplus.com/#point-75 + // Retrieve `then` only once + then = returned && + + // Support: Promises/A+ section 2.3.4 + // https://promisesaplus.com/#point-64 + // Only check objects and functions for thenability + ( typeof returned === "object" || + typeof returned === "function" ) && + returned.then; + + // Handle a returned thenable + if ( isFunction( then ) ) { + + // Special processors (notify) just wait for resolution + if ( special ) { + then.call( + returned, + resolve( maxDepth, deferred, Identity, special ), + resolve( maxDepth, deferred, Thrower, special ) + ); + + // Normal processors (resolve) also hook into progress + } else { + + // ...and disregard older resolution values + maxDepth++; + + then.call( + returned, + resolve( maxDepth, deferred, Identity, special ), + resolve( maxDepth, deferred, Thrower, special ), + resolve( maxDepth, deferred, Identity, + deferred.notifyWith ) + ); + } + + // Handle all other returned values + } else { + + // Only substitute handlers pass on context + // and multiple values (non-spec behavior) + if ( handler !== Identity ) { + that = undefined; + args = [ returned ]; + } + + // Process the value(s) + // Default process is resolve + ( special || deferred.resolveWith )( that, args ); + } + }, + + // Only normal processors (resolve) catch and reject exceptions + process = special ? + mightThrow : + function() { + try { + mightThrow(); + } catch ( e ) { + + if ( jQuery.Deferred.exceptionHook ) { + jQuery.Deferred.exceptionHook( e, + process.stackTrace ); + } + + // Support: Promises/A+ section 2.3.3.3.4.1 + // https://promisesaplus.com/#point-61 + // Ignore post-resolution exceptions + if ( depth + 1 >= maxDepth ) { + + // Only substitute handlers pass on context + // and multiple values (non-spec behavior) + if ( handler !== Thrower ) { + that = undefined; + args = [ e ]; + } + + deferred.rejectWith( that, args ); + } + } + }; + + // Support: Promises/A+ section 2.3.3.3.1 + // https://promisesaplus.com/#point-57 + // Re-resolve promises immediately to dodge false rejection from + // subsequent errors + if ( depth ) { + process(); + } else { + + // Call an optional hook to record the stack, in case of exception + // since it's otherwise lost when execution goes async + if ( jQuery.Deferred.getStackHook ) { + process.stackTrace = jQuery.Deferred.getStackHook(); + } + window.setTimeout( process ); + } + }; + } + + return jQuery.Deferred( function( newDefer ) { + + // progress_handlers.add( ... ) + tuples[ 0 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onProgress ) ? + onProgress : + Identity, + newDefer.notifyWith + ) + ); + + // fulfilled_handlers.add( ... ) + tuples[ 1 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onFulfilled ) ? + onFulfilled : + Identity + ) + ); + + // rejected_handlers.add( ... ) + tuples[ 2 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onRejected ) ? + onRejected : + Thrower + ) + ); + } ).promise(); + }, + + // Get a promise for this deferred + // If obj is provided, the promise aspect is added to the object + promise: function( obj ) { + return obj != null ? jQuery.extend( obj, promise ) : promise; + } + }, + deferred = {}; + + // Add list-specific methods + jQuery.each( tuples, function( i, tuple ) { + var list = tuple[ 2 ], + stateString = tuple[ 5 ]; + + // promise.progress = list.add + // promise.done = list.add + // promise.fail = list.add + promise[ tuple[ 1 ] ] = list.add; + + // Handle state + if ( stateString ) { + list.add( + function() { + + // state = "resolved" (i.e., fulfilled) + // state = "rejected" + state = stateString; + }, + + // rejected_callbacks.disable + // fulfilled_callbacks.disable + tuples[ 3 - i ][ 2 ].disable, + + // rejected_handlers.disable + // fulfilled_handlers.disable + tuples[ 3 - i ][ 3 ].disable, + + // progress_callbacks.lock + tuples[ 0 ][ 2 ].lock, + + // progress_handlers.lock + tuples[ 0 ][ 3 ].lock + ); + } + + // progress_handlers.fire + // fulfilled_handlers.fire + // rejected_handlers.fire + list.add( tuple[ 3 ].fire ); + + // deferred.notify = function() { deferred.notifyWith(...) } + // deferred.resolve = function() { deferred.resolveWith(...) } + // deferred.reject = function() { deferred.rejectWith(...) } + deferred[ tuple[ 0 ] ] = function() { + deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); + return this; + }; + + // deferred.notifyWith = list.fireWith + // deferred.resolveWith = list.fireWith + // deferred.rejectWith = list.fireWith + deferred[ tuple[ 0 ] + "With" ] = list.fireWith; + } ); + + // Make the deferred a promise + promise.promise( deferred ); + + // Call given func if any + if ( func ) { + func.call( deferred, deferred ); + } + + // All done! + return deferred; + }, + + // Deferred helper + when: function( singleValue ) { + var + + // count of uncompleted subordinates + remaining = arguments.length, + + // count of unprocessed arguments + i = remaining, + + // subordinate fulfillment data + resolveContexts = Array( i ), + resolveValues = slice.call( arguments ), + + // the master Deferred + master = jQuery.Deferred(), + + // subordinate callback factory + updateFunc = function( i ) { + return function( value ) { + resolveContexts[ i ] = this; + resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; + if ( !( --remaining ) ) { + master.resolveWith( resolveContexts, resolveValues ); + } + }; + }; + + // Single- and empty arguments are adopted like Promise.resolve + if ( remaining <= 1 ) { + adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject, + !remaining ); + + // Use .then() to unwrap secondary thenables (cf. gh-3000) + if ( master.state() === "pending" || + isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { + + return master.then(); + } + } + + // Multiple arguments are aggregated like Promise.all array elements + while ( i-- ) { + adoptValue( resolveValues[ i ], updateFunc( i ), master.reject ); + } + + return master.promise(); + } +} ); + + +// These usually indicate a programmer mistake during development, +// warn about them ASAP rather than swallowing them by default. +var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; + +jQuery.Deferred.exceptionHook = function( error, stack ) { + + // Support: IE 8 - 9 only + // Console exists when dev tools are open, which can happen at any time + if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { + window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack ); + } +}; + + + + +jQuery.readyException = function( error ) { + window.setTimeout( function() { + throw error; + } ); +}; + + + + +// The deferred used on DOM ready +var readyList = jQuery.Deferred(); + +jQuery.fn.ready = function( fn ) { + + readyList + .then( fn ) + + // Wrap jQuery.readyException in a function so that the lookup + // happens at the time of error handling instead of callback + // registration. + .catch( function( error ) { + jQuery.readyException( error ); + } ); + + return this; +}; + +jQuery.extend( { + + // Is the DOM ready to be used? Set to true once it occurs. + isReady: false, + + // A counter to track how many items to wait for before + // the ready event fires. See #6781 + readyWait: 1, + + // Handle when the DOM is ready + ready: function( wait ) { + + // Abort if there are pending holds or we're already ready + if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { + return; + } + + // Remember that the DOM is ready + jQuery.isReady = true; + + // If a normal DOM Ready event fired, decrement, and wait if need be + if ( wait !== true && --jQuery.readyWait > 0 ) { + return; + } + + // If there are functions bound, to execute + readyList.resolveWith( document, [ jQuery ] ); + } +} ); + +jQuery.ready.then = readyList.then; + +// The ready event handler and self cleanup method +function completed() { + document.removeEventListener( "DOMContentLoaded", completed ); + window.removeEventListener( "load", completed ); + jQuery.ready(); +} + +// Catch cases where $(document).ready() is called +// after the browser event has already occurred. +// Support: IE <=9 - 10 only +// Older IE sometimes signals "interactive" too soon +if ( document.readyState === "complete" || + ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { + + // Handle it asynchronously to allow scripts the opportunity to delay ready + window.setTimeout( jQuery.ready ); + +} else { + + // Use the handy event callback + document.addEventListener( "DOMContentLoaded", completed ); + + // A fallback to window.onload, that will always work + window.addEventListener( "load", completed ); +} + + + + +// Multifunctional method to get and set values of a collection +// The value/s can optionally be executed if it's a function +var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { + var i = 0, + len = elems.length, + bulk = key == null; + + // Sets many values + if ( toType( key ) === "object" ) { + chainable = true; + for ( i in key ) { + access( elems, fn, i, key[ i ], true, emptyGet, raw ); + } + + // Sets one value + } else if ( value !== undefined ) { + chainable = true; + + if ( !isFunction( value ) ) { + raw = true; + } + + if ( bulk ) { + + // Bulk operations run against the entire set + if ( raw ) { + fn.call( elems, value ); + fn = null; + + // ...except when executing function values + } else { + bulk = fn; + fn = function( elem, key, value ) { + return bulk.call( jQuery( elem ), value ); + }; + } + } + + if ( fn ) { + for ( ; i < len; i++ ) { + fn( + elems[ i ], key, raw ? + value : + value.call( elems[ i ], i, fn( elems[ i ], key ) ) + ); + } + } + } + + if ( chainable ) { + return elems; + } + + // Gets + if ( bulk ) { + return fn.call( elems ); + } + + return len ? fn( elems[ 0 ], key ) : emptyGet; +}; + + +// Matches dashed string for camelizing +var rmsPrefix = /^-ms-/, + rdashAlpha = /-([a-z])/g; + +// Used by camelCase as callback to replace() +function fcamelCase( all, letter ) { + return letter.toUpperCase(); +} + +// Convert dashed to camelCase; used by the css and data modules +// Support: IE <=9 - 11, Edge 12 - 15 +// Microsoft forgot to hump their vendor prefix (#9572) +function camelCase( string ) { + return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); +} +var acceptData = function( owner ) { + + // Accepts only: + // - Node + // - Node.ELEMENT_NODE + // - Node.DOCUMENT_NODE + // - Object + // - Any + return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); +}; + + + + +function Data() { + this.expando = jQuery.expando + Data.uid++; +} + +Data.uid = 1; + +Data.prototype = { + + cache: function( owner ) { + + // Check if the owner object already has a cache + var value = owner[ this.expando ]; + + // If not, create one + if ( !value ) { + value = {}; + + // We can accept data for non-element nodes in modern browsers, + // but we should not, see #8335. + // Always return an empty object. + if ( acceptData( owner ) ) { + + // If it is a node unlikely to be stringify-ed or looped over + // use plain assignment + if ( owner.nodeType ) { + owner[ this.expando ] = value; + + // Otherwise secure it in a non-enumerable property + // configurable must be true to allow the property to be + // deleted when data is removed + } else { + Object.defineProperty( owner, this.expando, { + value: value, + configurable: true + } ); + } + } + } + + return value; + }, + set: function( owner, data, value ) { + var prop, + cache = this.cache( owner ); + + // Handle: [ owner, key, value ] args + // Always use camelCase key (gh-2257) + if ( typeof data === "string" ) { + cache[ camelCase( data ) ] = value; + + // Handle: [ owner, { properties } ] args + } else { + + // Copy the properties one-by-one to the cache object + for ( prop in data ) { + cache[ camelCase( prop ) ] = data[ prop ]; + } + } + return cache; + }, + get: function( owner, key ) { + return key === undefined ? + this.cache( owner ) : + + // Always use camelCase key (gh-2257) + owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; + }, + access: function( owner, key, value ) { + + // In cases where either: + // + // 1. No key was specified + // 2. A string key was specified, but no value provided + // + // Take the "read" path and allow the get method to determine + // which value to return, respectively either: + // + // 1. The entire cache object + // 2. The data stored at the key + // + if ( key === undefined || + ( ( key && typeof key === "string" ) && value === undefined ) ) { + + return this.get( owner, key ); + } + + // When the key is not a string, or both a key and value + // are specified, set or extend (existing objects) with either: + // + // 1. An object of properties + // 2. A key and value + // + this.set( owner, key, value ); + + // Since the "set" path can have two possible entry points + // return the expected data based on which path was taken[*] + return value !== undefined ? value : key; + }, + remove: function( owner, key ) { + var i, + cache = owner[ this.expando ]; + + if ( cache === undefined ) { + return; + } + + if ( key !== undefined ) { + + // Support array or space separated string of keys + if ( Array.isArray( key ) ) { + + // If key is an array of keys... + // We always set camelCase keys, so remove that. + key = key.map( camelCase ); + } else { + key = camelCase( key ); + + // If a key with the spaces exists, use it. + // Otherwise, create an array by matching non-whitespace + key = key in cache ? + [ key ] : + ( key.match( rnothtmlwhite ) || [] ); + } + + i = key.length; + + while ( i-- ) { + delete cache[ key[ i ] ]; + } + } + + // Remove the expando if there's no more data + if ( key === undefined || jQuery.isEmptyObject( cache ) ) { + + // Support: Chrome <=35 - 45 + // Webkit & Blink performance suffers when deleting properties + // from DOM nodes, so set to undefined instead + // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) + if ( owner.nodeType ) { + owner[ this.expando ] = undefined; + } else { + delete owner[ this.expando ]; + } + } + }, + hasData: function( owner ) { + var cache = owner[ this.expando ]; + return cache !== undefined && !jQuery.isEmptyObject( cache ); + } +}; +var dataPriv = new Data(); + +var dataUser = new Data(); + + + +// Implementation Summary +// +// 1. Enforce API surface and semantic compatibility with 1.9.x branch +// 2. Improve the module's maintainability by reducing the storage +// paths to a single mechanism. +// 3. Use the same single mechanism to support "private" and "user" data. +// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) +// 5. Avoid exposing implementation details on user objects (eg. expando properties) +// 6. Provide a clear path for implementation upgrade to WeakMap in 2014 + +var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, + rmultiDash = /[A-Z]/g; + +function getData( data ) { + if ( data === "true" ) { + return true; + } + + if ( data === "false" ) { + return false; + } + + if ( data === "null" ) { + return null; + } + + // Only convert to a number if it doesn't change the string + if ( data === +data + "" ) { + return +data; + } + + if ( rbrace.test( data ) ) { + return JSON.parse( data ); + } + + return data; +} + +function dataAttr( elem, key, data ) { + var name; + + // If nothing was found internally, try to fetch any + // data from the HTML5 data-* attribute + if ( data === undefined && elem.nodeType === 1 ) { + name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); + data = elem.getAttribute( name ); + + if ( typeof data === "string" ) { + try { + data = getData( data ); + } catch ( e ) {} + + // Make sure we set the data so it isn't changed later + dataUser.set( elem, key, data ); + } else { + data = undefined; + } + } + return data; +} + +jQuery.extend( { + hasData: function( elem ) { + return dataUser.hasData( elem ) || dataPriv.hasData( elem ); + }, + + data: function( elem, name, data ) { + return dataUser.access( elem, name, data ); + }, + + removeData: function( elem, name ) { + dataUser.remove( elem, name ); + }, + + // TODO: Now that all calls to _data and _removeData have been replaced + // with direct calls to dataPriv methods, these can be deprecated. + _data: function( elem, name, data ) { + return dataPriv.access( elem, name, data ); + }, + + _removeData: function( elem, name ) { + dataPriv.remove( elem, name ); + } +} ); + +jQuery.fn.extend( { + data: function( key, value ) { + var i, name, data, + elem = this[ 0 ], + attrs = elem && elem.attributes; + + // Gets all values + if ( key === undefined ) { + if ( this.length ) { + data = dataUser.get( elem ); + + if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { + i = attrs.length; + while ( i-- ) { + + // Support: IE 11 only + // The attrs elements can be null (#14894) + if ( attrs[ i ] ) { + name = attrs[ i ].name; + if ( name.indexOf( "data-" ) === 0 ) { + name = camelCase( name.slice( 5 ) ); + dataAttr( elem, name, data[ name ] ); + } + } + } + dataPriv.set( elem, "hasDataAttrs", true ); + } + } + + return data; + } + + // Sets multiple values + if ( typeof key === "object" ) { + return this.each( function() { + dataUser.set( this, key ); + } ); + } + + return access( this, function( value ) { + var data; + + // The calling jQuery object (element matches) is not empty + // (and therefore has an element appears at this[ 0 ]) and the + // `value` parameter was not undefined. An empty jQuery object + // will result in `undefined` for elem = this[ 0 ] which will + // throw an exception if an attempt to read a data cache is made. + if ( elem && value === undefined ) { + + // Attempt to get data from the cache + // The key will always be camelCased in Data + data = dataUser.get( elem, key ); + if ( data !== undefined ) { + return data; + } + + // Attempt to "discover" the data in + // HTML5 custom data-* attrs + data = dataAttr( elem, key ); + if ( data !== undefined ) { + return data; + } + + // We tried really hard, but the data doesn't exist. + return; + } + + // Set the data... + this.each( function() { + + // We always store the camelCased key + dataUser.set( this, key, value ); + } ); + }, null, value, arguments.length > 1, null, true ); + }, + + removeData: function( key ) { + return this.each( function() { + dataUser.remove( this, key ); + } ); + } +} ); + + +jQuery.extend( { + queue: function( elem, type, data ) { + var queue; + + if ( elem ) { + type = ( type || "fx" ) + "queue"; + queue = dataPriv.get( elem, type ); + + // Speed up dequeue by getting out quickly if this is just a lookup + if ( data ) { + if ( !queue || Array.isArray( data ) ) { + queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); + } else { + queue.push( data ); + } + } + return queue || []; + } + }, + + dequeue: function( elem, type ) { + type = type || "fx"; + + var queue = jQuery.queue( elem, type ), + startLength = queue.length, + fn = queue.shift(), + hooks = jQuery._queueHooks( elem, type ), + next = function() { + jQuery.dequeue( elem, type ); + }; + + // If the fx queue is dequeued, always remove the progress sentinel + if ( fn === "inprogress" ) { + fn = queue.shift(); + startLength--; + } + + if ( fn ) { + + // Add a progress sentinel to prevent the fx queue from being + // automatically dequeued + if ( type === "fx" ) { + queue.unshift( "inprogress" ); + } + + // Clear up the last queue stop function + delete hooks.stop; + fn.call( elem, next, hooks ); + } + + if ( !startLength && hooks ) { + hooks.empty.fire(); + } + }, + + // Not public - generate a queueHooks object, or return the current one + _queueHooks: function( elem, type ) { + var key = type + "queueHooks"; + return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { + empty: jQuery.Callbacks( "once memory" ).add( function() { + dataPriv.remove( elem, [ type + "queue", key ] ); + } ) + } ); + } +} ); + +jQuery.fn.extend( { + queue: function( type, data ) { + var setter = 2; + + if ( typeof type !== "string" ) { + data = type; + type = "fx"; + setter--; + } + + if ( arguments.length < setter ) { + return jQuery.queue( this[ 0 ], type ); + } + + return data === undefined ? + this : + this.each( function() { + var queue = jQuery.queue( this, type, data ); + + // Ensure a hooks for this queue + jQuery._queueHooks( this, type ); + + if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { + jQuery.dequeue( this, type ); + } + } ); + }, + dequeue: function( type ) { + return this.each( function() { + jQuery.dequeue( this, type ); + } ); + }, + clearQueue: function( type ) { + return this.queue( type || "fx", [] ); + }, + + // Get a promise resolved when queues of a certain type + // are emptied (fx is the type by default) + promise: function( type, obj ) { + var tmp, + count = 1, + defer = jQuery.Deferred(), + elements = this, + i = this.length, + resolve = function() { + if ( !( --count ) ) { + defer.resolveWith( elements, [ elements ] ); + } + }; + + if ( typeof type !== "string" ) { + obj = type; + type = undefined; + } + type = type || "fx"; + + while ( i-- ) { + tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); + if ( tmp && tmp.empty ) { + count++; + tmp.empty.add( resolve ); + } + } + resolve(); + return defer.promise( obj ); + } +} ); +var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; + +var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); + + +var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; + +var documentElement = document.documentElement; + + + + var isAttached = function( elem ) { + return jQuery.contains( elem.ownerDocument, elem ); + }, + composed = { composed: true }; + + // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only + // Check attachment across shadow DOM boundaries when possible (gh-3504) + // Support: iOS 10.0-10.2 only + // Early iOS 10 versions support `attachShadow` but not `getRootNode`, + // leading to errors. We need to check for `getRootNode`. + if ( documentElement.getRootNode ) { + isAttached = function( elem ) { + return jQuery.contains( elem.ownerDocument, elem ) || + elem.getRootNode( composed ) === elem.ownerDocument; + }; + } +var isHiddenWithinTree = function( elem, el ) { + + // isHiddenWithinTree might be called from jQuery#filter function; + // in that case, element will be second argument + elem = el || elem; + + // Inline style trumps all + return elem.style.display === "none" || + elem.style.display === "" && + + // Otherwise, check computed style + // Support: Firefox <=43 - 45 + // Disconnected elements can have computed display: none, so first confirm that elem is + // in the document. + isAttached( elem ) && + + jQuery.css( elem, "display" ) === "none"; + }; + +var swap = function( elem, options, callback, args ) { + var ret, name, + old = {}; + + // Remember the old values, and insert the new ones + for ( name in options ) { + old[ name ] = elem.style[ name ]; + elem.style[ name ] = options[ name ]; + } + + ret = callback.apply( elem, args || [] ); + + // Revert the old values + for ( name in options ) { + elem.style[ name ] = old[ name ]; + } + + return ret; +}; + + + + +function adjustCSS( elem, prop, valueParts, tween ) { + var adjusted, scale, + maxIterations = 20, + currentValue = tween ? + function() { + return tween.cur(); + } : + function() { + return jQuery.css( elem, prop, "" ); + }, + initial = currentValue(), + unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), + + // Starting value computation is required for potential unit mismatches + initialInUnit = elem.nodeType && + ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && + rcssNum.exec( jQuery.css( elem, prop ) ); + + if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { + + // Support: Firefox <=54 + // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) + initial = initial / 2; + + // Trust units reported by jQuery.css + unit = unit || initialInUnit[ 3 ]; + + // Iteratively approximate from a nonzero starting point + initialInUnit = +initial || 1; + + while ( maxIterations-- ) { + + // Evaluate and update our best guess (doubling guesses that zero out). + // Finish if the scale equals or crosses 1 (making the old*new product non-positive). + jQuery.style( elem, prop, initialInUnit + unit ); + if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { + maxIterations = 0; + } + initialInUnit = initialInUnit / scale; + + } + + initialInUnit = initialInUnit * 2; + jQuery.style( elem, prop, initialInUnit + unit ); + + // Make sure we update the tween properties later on + valueParts = valueParts || []; + } + + if ( valueParts ) { + initialInUnit = +initialInUnit || +initial || 0; + + // Apply relative offset (+=/-=) if specified + adjusted = valueParts[ 1 ] ? + initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : + +valueParts[ 2 ]; + if ( tween ) { + tween.unit = unit; + tween.start = initialInUnit; + tween.end = adjusted; + } + } + return adjusted; +} + + +var defaultDisplayMap = {}; + +function getDefaultDisplay( elem ) { + var temp, + doc = elem.ownerDocument, + nodeName = elem.nodeName, + display = defaultDisplayMap[ nodeName ]; + + if ( display ) { + return display; + } + + temp = doc.body.appendChild( doc.createElement( nodeName ) ); + display = jQuery.css( temp, "display" ); + + temp.parentNode.removeChild( temp ); + + if ( display === "none" ) { + display = "block"; + } + defaultDisplayMap[ nodeName ] = display; + + return display; +} + +function showHide( elements, show ) { + var display, elem, + values = [], + index = 0, + length = elements.length; + + // Determine new display value for elements that need to change + for ( ; index < length; index++ ) { + elem = elements[ index ]; + if ( !elem.style ) { + continue; + } + + display = elem.style.display; + if ( show ) { + + // Since we force visibility upon cascade-hidden elements, an immediate (and slow) + // check is required in this first loop unless we have a nonempty display value (either + // inline or about-to-be-restored) + if ( display === "none" ) { + values[ index ] = dataPriv.get( elem, "display" ) || null; + if ( !values[ index ] ) { + elem.style.display = ""; + } + } + if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { + values[ index ] = getDefaultDisplay( elem ); + } + } else { + if ( display !== "none" ) { + values[ index ] = "none"; + + // Remember what we're overwriting + dataPriv.set( elem, "display", display ); + } + } + } + + // Set the display of the elements in a second loop to avoid constant reflow + for ( index = 0; index < length; index++ ) { + if ( values[ index ] != null ) { + elements[ index ].style.display = values[ index ]; + } + } + + return elements; +} + +jQuery.fn.extend( { + show: function() { + return showHide( this, true ); + }, + hide: function() { + return showHide( this ); + }, + toggle: function( state ) { + if ( typeof state === "boolean" ) { + return state ? this.show() : this.hide(); + } + + return this.each( function() { + if ( isHiddenWithinTree( this ) ) { + jQuery( this ).show(); + } else { + jQuery( this ).hide(); + } + } ); + } +} ); +var rcheckableType = ( /^(?:checkbox|radio)$/i ); + +var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i ); + +var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); + + + +// We have to close these tags to support XHTML (#13200) +var wrapMap = { + + // Support: IE <=9 only + option: [ 1, "" ], + + // XHTML parsers do not magically insert elements in the + // same way that tag soup parsers do. So we cannot shorten + // this by omitting or other required elements. + thead: [ 1, "", "
" ], + col: [ 2, "", "
" ], + tr: [ 2, "", "
" ], + td: [ 3, "", "
" ], + + _default: [ 0, "", "" ] +}; + +// Support: IE <=9 only +wrapMap.optgroup = wrapMap.option; + +wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; +wrapMap.th = wrapMap.td; + + +function getAll( context, tag ) { + + // Support: IE <=9 - 11 only + // Use typeof to avoid zero-argument method invocation on host objects (#15151) + var ret; + + if ( typeof context.getElementsByTagName !== "undefined" ) { + ret = context.getElementsByTagName( tag || "*" ); + + } else if ( typeof context.querySelectorAll !== "undefined" ) { + ret = context.querySelectorAll( tag || "*" ); + + } else { + ret = []; + } + + if ( tag === undefined || tag && nodeName( context, tag ) ) { + return jQuery.merge( [ context ], ret ); + } + + return ret; +} + + +// Mark scripts as having already been evaluated +function setGlobalEval( elems, refElements ) { + var i = 0, + l = elems.length; + + for ( ; i < l; i++ ) { + dataPriv.set( + elems[ i ], + "globalEval", + !refElements || dataPriv.get( refElements[ i ], "globalEval" ) + ); + } +} + + +var rhtml = /<|&#?\w+;/; + +function buildFragment( elems, context, scripts, selection, ignored ) { + var elem, tmp, tag, wrap, attached, j, + fragment = context.createDocumentFragment(), + nodes = [], + i = 0, + l = elems.length; + + for ( ; i < l; i++ ) { + elem = elems[ i ]; + + if ( elem || elem === 0 ) { + + // Add nodes directly + if ( toType( elem ) === "object" ) { + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); + + // Convert non-html into a text node + } else if ( !rhtml.test( elem ) ) { + nodes.push( context.createTextNode( elem ) ); + + // Convert html into DOM nodes + } else { + tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); + + // Deserialize a standard representation + tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); + wrap = wrapMap[ tag ] || wrapMap._default; + tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; + + // Descend through wrappers to the right content + j = wrap[ 0 ]; + while ( j-- ) { + tmp = tmp.lastChild; + } + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( nodes, tmp.childNodes ); + + // Remember the top-level container + tmp = fragment.firstChild; + + // Ensure the created nodes are orphaned (#12392) + tmp.textContent = ""; + } + } + } + + // Remove wrapper from fragment + fragment.textContent = ""; + + i = 0; + while ( ( elem = nodes[ i++ ] ) ) { + + // Skip elements already in the context collection (trac-4087) + if ( selection && jQuery.inArray( elem, selection ) > -1 ) { + if ( ignored ) { + ignored.push( elem ); + } + continue; + } + + attached = isAttached( elem ); + + // Append to fragment + tmp = getAll( fragment.appendChild( elem ), "script" ); + + // Preserve script evaluation history + if ( attached ) { + setGlobalEval( tmp ); + } + + // Capture executables + if ( scripts ) { + j = 0; + while ( ( elem = tmp[ j++ ] ) ) { + if ( rscriptType.test( elem.type || "" ) ) { + scripts.push( elem ); + } + } + } + } + + return fragment; +} + + +( function() { + var fragment = document.createDocumentFragment(), + div = fragment.appendChild( document.createElement( "div" ) ), + input = document.createElement( "input" ); + + // Support: Android 4.0 - 4.3 only + // Check state lost if the name is set (#11217) + // Support: Windows Web Apps (WWA) + // `name` and `type` must use .setAttribute for WWA (#14901) + input.setAttribute( "type", "radio" ); + input.setAttribute( "checked", "checked" ); + input.setAttribute( "name", "t" ); + + div.appendChild( input ); + + // Support: Android <=4.1 only + // Older WebKit doesn't clone checked state correctly in fragments + support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; + + // Support: IE <=11 only + // Make sure textarea (and checkbox) defaultValue is properly cloned + div.innerHTML = ""; + support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; +} )(); + + +var + rkeyEvent = /^key/, + rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, + rtypenamespace = /^([^.]*)(?:\.(.+)|)/; + +function returnTrue() { + return true; +} + +function returnFalse() { + return false; +} + +// Support: IE <=9 - 11+ +// focus() and blur() are asynchronous, except when they are no-op. +// So expect focus to be synchronous when the element is already active, +// and blur to be synchronous when the element is not already active. +// (focus and blur are always synchronous in other supported browsers, +// this just defines when we can count on it). +function expectSync( elem, type ) { + return ( elem === safeActiveElement() ) === ( type === "focus" ); +} + +// Support: IE <=9 only +// Accessing document.activeElement can throw unexpectedly +// https://bugs.jquery.com/ticket/13393 +function safeActiveElement() { + try { + return document.activeElement; + } catch ( err ) { } +} + +function on( elem, types, selector, data, fn, one ) { + var origFn, type; + + // Types can be a map of types/handlers + if ( typeof types === "object" ) { + + // ( types-Object, selector, data ) + if ( typeof selector !== "string" ) { + + // ( types-Object, data ) + data = data || selector; + selector = undefined; + } + for ( type in types ) { + on( elem, type, selector, data, types[ type ], one ); + } + return elem; + } + + if ( data == null && fn == null ) { + + // ( types, fn ) + fn = selector; + data = selector = undefined; + } else if ( fn == null ) { + if ( typeof selector === "string" ) { + + // ( types, selector, fn ) + fn = data; + data = undefined; + } else { + + // ( types, data, fn ) + fn = data; + data = selector; + selector = undefined; + } + } + if ( fn === false ) { + fn = returnFalse; + } else if ( !fn ) { + return elem; + } + + if ( one === 1 ) { + origFn = fn; + fn = function( event ) { + + // Can use an empty set, since event contains the info + jQuery().off( event ); + return origFn.apply( this, arguments ); + }; + + // Use same guid so caller can remove using origFn + fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); + } + return elem.each( function() { + jQuery.event.add( this, types, fn, data, selector ); + } ); +} + +/* + * Helper functions for managing events -- not part of the public interface. + * Props to Dean Edwards' addEvent library for many of the ideas. + */ +jQuery.event = { + + global: {}, + + add: function( elem, types, handler, data, selector ) { + + var handleObjIn, eventHandle, tmp, + events, t, handleObj, + special, handlers, type, namespaces, origType, + elemData = dataPriv.get( elem ); + + // Don't attach events to noData or text/comment nodes (but allow plain objects) + if ( !elemData ) { + return; + } + + // Caller can pass in an object of custom data in lieu of the handler + if ( handler.handler ) { + handleObjIn = handler; + handler = handleObjIn.handler; + selector = handleObjIn.selector; + } + + // Ensure that invalid selectors throw exceptions at attach time + // Evaluate against documentElement in case elem is a non-element node (e.g., document) + if ( selector ) { + jQuery.find.matchesSelector( documentElement, selector ); + } + + // Make sure that the handler has a unique ID, used to find/remove it later + if ( !handler.guid ) { + handler.guid = jQuery.guid++; + } + + // Init the element's event structure and main handler, if this is the first + if ( !( events = elemData.events ) ) { + events = elemData.events = {}; + } + if ( !( eventHandle = elemData.handle ) ) { + eventHandle = elemData.handle = function( e ) { + + // Discard the second event of a jQuery.event.trigger() and + // when an event is called after a page has unloaded + return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? + jQuery.event.dispatch.apply( elem, arguments ) : undefined; + }; + } + + // Handle multiple events separated by a space + types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[ t ] ) || []; + type = origType = tmp[ 1 ]; + namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); + + // There *must* be a type, no attaching namespace-only handlers + if ( !type ) { + continue; + } + + // If event changes its type, use the special event handlers for the changed type + special = jQuery.event.special[ type ] || {}; + + // If selector defined, determine special event api type, otherwise given type + type = ( selector ? special.delegateType : special.bindType ) || type; + + // Update special based on newly reset type + special = jQuery.event.special[ type ] || {}; + + // handleObj is passed to all event handlers + handleObj = jQuery.extend( { + type: type, + origType: origType, + data: data, + handler: handler, + guid: handler.guid, + selector: selector, + needsContext: selector && jQuery.expr.match.needsContext.test( selector ), + namespace: namespaces.join( "." ) + }, handleObjIn ); + + // Init the event handler queue if we're the first + if ( !( handlers = events[ type ] ) ) { + handlers = events[ type ] = []; + handlers.delegateCount = 0; + + // Only use addEventListener if the special events handler returns false + if ( !special.setup || + special.setup.call( elem, data, namespaces, eventHandle ) === false ) { + + if ( elem.addEventListener ) { + elem.addEventListener( type, eventHandle ); + } + } + } + + if ( special.add ) { + special.add.call( elem, handleObj ); + + if ( !handleObj.handler.guid ) { + handleObj.handler.guid = handler.guid; + } + } + + // Add to the element's handler list, delegates in front + if ( selector ) { + handlers.splice( handlers.delegateCount++, 0, handleObj ); + } else { + handlers.push( handleObj ); + } + + // Keep track of which events have ever been used, for event optimization + jQuery.event.global[ type ] = true; + } + + }, + + // Detach an event or set of events from an element + remove: function( elem, types, handler, selector, mappedTypes ) { + + var j, origCount, tmp, + events, t, handleObj, + special, handlers, type, namespaces, origType, + elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); + + if ( !elemData || !( events = elemData.events ) ) { + return; + } + + // Once for each type.namespace in types; type may be omitted + types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[ t ] ) || []; + type = origType = tmp[ 1 ]; + namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); + + // Unbind all events (on this namespace, if provided) for the element + if ( !type ) { + for ( type in events ) { + jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); + } + continue; + } + + special = jQuery.event.special[ type ] || {}; + type = ( selector ? special.delegateType : special.bindType ) || type; + handlers = events[ type ] || []; + tmp = tmp[ 2 ] && + new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); + + // Remove matching events + origCount = j = handlers.length; + while ( j-- ) { + handleObj = handlers[ j ]; + + if ( ( mappedTypes || origType === handleObj.origType ) && + ( !handler || handler.guid === handleObj.guid ) && + ( !tmp || tmp.test( handleObj.namespace ) ) && + ( !selector || selector === handleObj.selector || + selector === "**" && handleObj.selector ) ) { + handlers.splice( j, 1 ); + + if ( handleObj.selector ) { + handlers.delegateCount--; + } + if ( special.remove ) { + special.remove.call( elem, handleObj ); + } + } + } + + // Remove generic event handler if we removed something and no more handlers exist + // (avoids potential for endless recursion during removal of special event handlers) + if ( origCount && !handlers.length ) { + if ( !special.teardown || + special.teardown.call( elem, namespaces, elemData.handle ) === false ) { + + jQuery.removeEvent( elem, type, elemData.handle ); + } + + delete events[ type ]; + } + } + + // Remove data and the expando if it's no longer used + if ( jQuery.isEmptyObject( events ) ) { + dataPriv.remove( elem, "handle events" ); + } + }, + + dispatch: function( nativeEvent ) { + + // Make a writable jQuery.Event from the native event object + var event = jQuery.event.fix( nativeEvent ); + + var i, j, ret, matched, handleObj, handlerQueue, + args = new Array( arguments.length ), + handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [], + special = jQuery.event.special[ event.type ] || {}; + + // Use the fix-ed jQuery.Event rather than the (read-only) native event + args[ 0 ] = event; + + for ( i = 1; i < arguments.length; i++ ) { + args[ i ] = arguments[ i ]; + } + + event.delegateTarget = this; + + // Call the preDispatch hook for the mapped type, and let it bail if desired + if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { + return; + } + + // Determine handlers + handlerQueue = jQuery.event.handlers.call( this, event, handlers ); + + // Run delegates first; they may want to stop propagation beneath us + i = 0; + while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { + event.currentTarget = matched.elem; + + j = 0; + while ( ( handleObj = matched.handlers[ j++ ] ) && + !event.isImmediatePropagationStopped() ) { + + // If the event is namespaced, then each handler is only invoked if it is + // specially universal or its namespaces are a superset of the event's. + if ( !event.rnamespace || handleObj.namespace === false || + event.rnamespace.test( handleObj.namespace ) ) { + + event.handleObj = handleObj; + event.data = handleObj.data; + + ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || + handleObj.handler ).apply( matched.elem, args ); + + if ( ret !== undefined ) { + if ( ( event.result = ret ) === false ) { + event.preventDefault(); + event.stopPropagation(); + } + } + } + } + } + + // Call the postDispatch hook for the mapped type + if ( special.postDispatch ) { + special.postDispatch.call( this, event ); + } + + return event.result; + }, + + handlers: function( event, handlers ) { + var i, handleObj, sel, matchedHandlers, matchedSelectors, + handlerQueue = [], + delegateCount = handlers.delegateCount, + cur = event.target; + + // Find delegate handlers + if ( delegateCount && + + // Support: IE <=9 + // Black-hole SVG instance trees (trac-13180) + cur.nodeType && + + // Support: Firefox <=42 + // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) + // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click + // Support: IE 11 only + // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) + !( event.type === "click" && event.button >= 1 ) ) { + + for ( ; cur !== this; cur = cur.parentNode || this ) { + + // Don't check non-elements (#13208) + // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) + if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { + matchedHandlers = []; + matchedSelectors = {}; + for ( i = 0; i < delegateCount; i++ ) { + handleObj = handlers[ i ]; + + // Don't conflict with Object.prototype properties (#13203) + sel = handleObj.selector + " "; + + if ( matchedSelectors[ sel ] === undefined ) { + matchedSelectors[ sel ] = handleObj.needsContext ? + jQuery( sel, this ).index( cur ) > -1 : + jQuery.find( sel, this, null, [ cur ] ).length; + } + if ( matchedSelectors[ sel ] ) { + matchedHandlers.push( handleObj ); + } + } + if ( matchedHandlers.length ) { + handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); + } + } + } + } + + // Add the remaining (directly-bound) handlers + cur = this; + if ( delegateCount < handlers.length ) { + handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); + } + + return handlerQueue; + }, + + addProp: function( name, hook ) { + Object.defineProperty( jQuery.Event.prototype, name, { + enumerable: true, + configurable: true, + + get: isFunction( hook ) ? + function() { + if ( this.originalEvent ) { + return hook( this.originalEvent ); + } + } : + function() { + if ( this.originalEvent ) { + return this.originalEvent[ name ]; + } + }, + + set: function( value ) { + Object.defineProperty( this, name, { + enumerable: true, + configurable: true, + writable: true, + value: value + } ); + } + } ); + }, + + fix: function( originalEvent ) { + return originalEvent[ jQuery.expando ] ? + originalEvent : + new jQuery.Event( originalEvent ); + }, + + special: { + load: { + + // Prevent triggered image.load events from bubbling to window.load + noBubble: true + }, + click: { + + // Utilize native event to ensure correct state for checkable inputs + setup: function( data ) { + + // For mutual compressibility with _default, replace `this` access with a local var. + // `|| data` is dead code meant only to preserve the variable through minification. + var el = this || data; + + // Claim the first handler + if ( rcheckableType.test( el.type ) && + el.click && nodeName( el, "input" ) ) { + + // dataPriv.set( el, "click", ... ) + leverageNative( el, "click", returnTrue ); + } + + // Return false to allow normal processing in the caller + return false; + }, + trigger: function( data ) { + + // For mutual compressibility with _default, replace `this` access with a local var. + // `|| data` is dead code meant only to preserve the variable through minification. + var el = this || data; + + // Force setup before triggering a click + if ( rcheckableType.test( el.type ) && + el.click && nodeName( el, "input" ) ) { + + leverageNative( el, "click" ); + } + + // Return non-false to allow normal event-path propagation + return true; + }, + + // For cross-browser consistency, suppress native .click() on links + // Also prevent it if we're currently inside a leveraged native-event stack + _default: function( event ) { + var target = event.target; + return rcheckableType.test( target.type ) && + target.click && nodeName( target, "input" ) && + dataPriv.get( target, "click" ) || + nodeName( target, "a" ); + } + }, + + beforeunload: { + postDispatch: function( event ) { + + // Support: Firefox 20+ + // Firefox doesn't alert if the returnValue field is not set. + if ( event.result !== undefined && event.originalEvent ) { + event.originalEvent.returnValue = event.result; + } + } + } + } +}; + +// Ensure the presence of an event listener that handles manually-triggered +// synthetic events by interrupting progress until reinvoked in response to +// *native* events that it fires directly, ensuring that state changes have +// already occurred before other listeners are invoked. +function leverageNative( el, type, expectSync ) { + + // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add + if ( !expectSync ) { + if ( dataPriv.get( el, type ) === undefined ) { + jQuery.event.add( el, type, returnTrue ); + } + return; + } + + // Register the controller as a special universal handler for all event namespaces + dataPriv.set( el, type, false ); + jQuery.event.add( el, type, { + namespace: false, + handler: function( event ) { + var notAsync, result, + saved = dataPriv.get( this, type ); + + if ( ( event.isTrigger & 1 ) && this[ type ] ) { + + // Interrupt processing of the outer synthetic .trigger()ed event + // Saved data should be false in such cases, but might be a leftover capture object + // from an async native handler (gh-4350) + if ( !saved.length ) { + + // Store arguments for use when handling the inner native event + // There will always be at least one argument (an event object), so this array + // will not be confused with a leftover capture object. + saved = slice.call( arguments ); + dataPriv.set( this, type, saved ); + + // Trigger the native event and capture its result + // Support: IE <=9 - 11+ + // focus() and blur() are asynchronous + notAsync = expectSync( this, type ); + this[ type ](); + result = dataPriv.get( this, type ); + if ( saved !== result || notAsync ) { + dataPriv.set( this, type, false ); + } else { + result = {}; + } + if ( saved !== result ) { + + // Cancel the outer synthetic event + event.stopImmediatePropagation(); + event.preventDefault(); + return result.value; + } + + // If this is an inner synthetic event for an event with a bubbling surrogate + // (focus or blur), assume that the surrogate already propagated from triggering the + // native event and prevent that from happening again here. + // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the + // bubbling surrogate propagates *after* the non-bubbling base), but that seems + // less bad than duplication. + } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { + event.stopPropagation(); + } + + // If this is a native event triggered above, everything is now in order + // Fire an inner synthetic event with the original arguments + } else if ( saved.length ) { + + // ...and capture the result + dataPriv.set( this, type, { + value: jQuery.event.trigger( + + // Support: IE <=9 - 11+ + // Extend with the prototype to reset the above stopImmediatePropagation() + jQuery.extend( saved[ 0 ], jQuery.Event.prototype ), + saved.slice( 1 ), + this + ) + } ); + + // Abort handling of the native event + event.stopImmediatePropagation(); + } + } + } ); +} + +jQuery.removeEvent = function( elem, type, handle ) { + + // This "if" is needed for plain objects + if ( elem.removeEventListener ) { + elem.removeEventListener( type, handle ); + } +}; + +jQuery.Event = function( src, props ) { + + // Allow instantiation without the 'new' keyword + if ( !( this instanceof jQuery.Event ) ) { + return new jQuery.Event( src, props ); + } + + // Event object + if ( src && src.type ) { + this.originalEvent = src; + this.type = src.type; + + // Events bubbling up the document may have been marked as prevented + // by a handler lower down the tree; reflect the correct value. + this.isDefaultPrevented = src.defaultPrevented || + src.defaultPrevented === undefined && + + // Support: Android <=2.3 only + src.returnValue === false ? + returnTrue : + returnFalse; + + // Create target properties + // Support: Safari <=6 - 7 only + // Target should not be a text node (#504, #13143) + this.target = ( src.target && src.target.nodeType === 3 ) ? + src.target.parentNode : + src.target; + + this.currentTarget = src.currentTarget; + this.relatedTarget = src.relatedTarget; + + // Event type + } else { + this.type = src; + } + + // Put explicitly provided properties onto the event object + if ( props ) { + jQuery.extend( this, props ); + } + + // Create a timestamp if incoming event doesn't have one + this.timeStamp = src && src.timeStamp || Date.now(); + + // Mark it as fixed + this[ jQuery.expando ] = true; +}; + +// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding +// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html +jQuery.Event.prototype = { + constructor: jQuery.Event, + isDefaultPrevented: returnFalse, + isPropagationStopped: returnFalse, + isImmediatePropagationStopped: returnFalse, + isSimulated: false, + + preventDefault: function() { + var e = this.originalEvent; + + this.isDefaultPrevented = returnTrue; + + if ( e && !this.isSimulated ) { + e.preventDefault(); + } + }, + stopPropagation: function() { + var e = this.originalEvent; + + this.isPropagationStopped = returnTrue; + + if ( e && !this.isSimulated ) { + e.stopPropagation(); + } + }, + stopImmediatePropagation: function() { + var e = this.originalEvent; + + this.isImmediatePropagationStopped = returnTrue; + + if ( e && !this.isSimulated ) { + e.stopImmediatePropagation(); + } + + this.stopPropagation(); + } +}; + +// Includes all common event props including KeyEvent and MouseEvent specific props +jQuery.each( { + altKey: true, + bubbles: true, + cancelable: true, + changedTouches: true, + ctrlKey: true, + detail: true, + eventPhase: true, + metaKey: true, + pageX: true, + pageY: true, + shiftKey: true, + view: true, + "char": true, + code: true, + charCode: true, + key: true, + keyCode: true, + button: true, + buttons: true, + clientX: true, + clientY: true, + offsetX: true, + offsetY: true, + pointerId: true, + pointerType: true, + screenX: true, + screenY: true, + targetTouches: true, + toElement: true, + touches: true, + + which: function( event ) { + var button = event.button; + + // Add which for key events + if ( event.which == null && rkeyEvent.test( event.type ) ) { + return event.charCode != null ? event.charCode : event.keyCode; + } + + // Add which for click: 1 === left; 2 === middle; 3 === right + if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) { + if ( button & 1 ) { + return 1; + } + + if ( button & 2 ) { + return 3; + } + + if ( button & 4 ) { + return 2; + } + + return 0; + } + + return event.which; + } +}, jQuery.event.addProp ); + +jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { + jQuery.event.special[ type ] = { + + // Utilize native event if possible so blur/focus sequence is correct + setup: function() { + + // Claim the first handler + // dataPriv.set( this, "focus", ... ) + // dataPriv.set( this, "blur", ... ) + leverageNative( this, type, expectSync ); + + // Return false to allow normal processing in the caller + return false; + }, + trigger: function() { + + // Force setup before trigger + leverageNative( this, type ); + + // Return non-false to allow normal event-path propagation + return true; + }, + + delegateType: delegateType + }; +} ); + +// Create mouseenter/leave events using mouseover/out and event-time checks +// so that event delegation works in jQuery. +// Do the same for pointerenter/pointerleave and pointerover/pointerout +// +// Support: Safari 7 only +// Safari sends mouseenter too often; see: +// https://bugs.chromium.org/p/chromium/issues/detail?id=470258 +// for the description of the bug (it existed in older Chrome versions as well). +jQuery.each( { + mouseenter: "mouseover", + mouseleave: "mouseout", + pointerenter: "pointerover", + pointerleave: "pointerout" +}, function( orig, fix ) { + jQuery.event.special[ orig ] = { + delegateType: fix, + bindType: fix, + + handle: function( event ) { + var ret, + target = this, + related = event.relatedTarget, + handleObj = event.handleObj; + + // For mouseenter/leave call the handler if related is outside the target. + // NB: No relatedTarget if the mouse left/entered the browser window + if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { + event.type = handleObj.origType; + ret = handleObj.handler.apply( this, arguments ); + event.type = fix; + } + return ret; + } + }; +} ); + +jQuery.fn.extend( { + + on: function( types, selector, data, fn ) { + return on( this, types, selector, data, fn ); + }, + one: function( types, selector, data, fn ) { + return on( this, types, selector, data, fn, 1 ); + }, + off: function( types, selector, fn ) { + var handleObj, type; + if ( types && types.preventDefault && types.handleObj ) { + + // ( event ) dispatched jQuery.Event + handleObj = types.handleObj; + jQuery( types.delegateTarget ).off( + handleObj.namespace ? + handleObj.origType + "." + handleObj.namespace : + handleObj.origType, + handleObj.selector, + handleObj.handler + ); + return this; + } + if ( typeof types === "object" ) { + + // ( types-object [, selector] ) + for ( type in types ) { + this.off( type, selector, types[ type ] ); + } + return this; + } + if ( selector === false || typeof selector === "function" ) { + + // ( types [, fn] ) + fn = selector; + selector = undefined; + } + if ( fn === false ) { + fn = returnFalse; + } + return this.each( function() { + jQuery.event.remove( this, types, fn, selector ); + } ); + } +} ); + + +var + + /* eslint-disable max-len */ + + // See https://github.com/eslint/eslint/issues/3229 + rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi, + + /* eslint-enable */ + + // Support: IE <=10 - 11, Edge 12 - 13 only + // In IE/Edge using regex groups here causes severe slowdowns. + // See https://connect.microsoft.com/IE/feedback/details/1736512/ + rnoInnerhtml = /\s*$/g; + +// Prefer a tbody over its parent table for containing new rows +function manipulationTarget( elem, content ) { + if ( nodeName( elem, "table" ) && + nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { + + return jQuery( elem ).children( "tbody" )[ 0 ] || elem; + } + + return elem; +} + +// Replace/restore the type attribute of script elements for safe DOM manipulation +function disableScript( elem ) { + elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; + return elem; +} +function restoreScript( elem ) { + if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { + elem.type = elem.type.slice( 5 ); + } else { + elem.removeAttribute( "type" ); + } + + return elem; +} + +function cloneCopyEvent( src, dest ) { + var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events; + + if ( dest.nodeType !== 1 ) { + return; + } + + // 1. Copy private data: events, handlers, etc. + if ( dataPriv.hasData( src ) ) { + pdataOld = dataPriv.access( src ); + pdataCur = dataPriv.set( dest, pdataOld ); + events = pdataOld.events; + + if ( events ) { + delete pdataCur.handle; + pdataCur.events = {}; + + for ( type in events ) { + for ( i = 0, l = events[ type ].length; i < l; i++ ) { + jQuery.event.add( dest, type, events[ type ][ i ] ); + } + } + } + } + + // 2. Copy user data + if ( dataUser.hasData( src ) ) { + udataOld = dataUser.access( src ); + udataCur = jQuery.extend( {}, udataOld ); + + dataUser.set( dest, udataCur ); + } +} + +// Fix IE bugs, see support tests +function fixInput( src, dest ) { + var nodeName = dest.nodeName.toLowerCase(); + + // Fails to persist the checked state of a cloned checkbox or radio button. + if ( nodeName === "input" && rcheckableType.test( src.type ) ) { + dest.checked = src.checked; + + // Fails to return the selected option to the default selected state when cloning options + } else if ( nodeName === "input" || nodeName === "textarea" ) { + dest.defaultValue = src.defaultValue; + } +} + +function domManip( collection, args, callback, ignored ) { + + // Flatten any nested arrays + args = concat.apply( [], args ); + + var fragment, first, scripts, hasScripts, node, doc, + i = 0, + l = collection.length, + iNoClone = l - 1, + value = args[ 0 ], + valueIsFunction = isFunction( value ); + + // We can't cloneNode fragments that contain checked, in WebKit + if ( valueIsFunction || + ( l > 1 && typeof value === "string" && + !support.checkClone && rchecked.test( value ) ) ) { + return collection.each( function( index ) { + var self = collection.eq( index ); + if ( valueIsFunction ) { + args[ 0 ] = value.call( this, index, self.html() ); + } + domManip( self, args, callback, ignored ); + } ); + } + + if ( l ) { + fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); + first = fragment.firstChild; + + if ( fragment.childNodes.length === 1 ) { + fragment = first; + } + + // Require either new content or an interest in ignored elements to invoke the callback + if ( first || ignored ) { + scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); + hasScripts = scripts.length; + + // Use the original fragment for the last item + // instead of the first because it can end up + // being emptied incorrectly in certain situations (#8070). + for ( ; i < l; i++ ) { + node = fragment; + + if ( i !== iNoClone ) { + node = jQuery.clone( node, true, true ); + + // Keep references to cloned scripts for later restoration + if ( hasScripts ) { + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( scripts, getAll( node, "script" ) ); + } + } + + callback.call( collection[ i ], node, i ); + } + + if ( hasScripts ) { + doc = scripts[ scripts.length - 1 ].ownerDocument; + + // Reenable scripts + jQuery.map( scripts, restoreScript ); + + // Evaluate executable scripts on first document insertion + for ( i = 0; i < hasScripts; i++ ) { + node = scripts[ i ]; + if ( rscriptType.test( node.type || "" ) && + !dataPriv.access( node, "globalEval" ) && + jQuery.contains( doc, node ) ) { + + if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { + + // Optional AJAX dependency, but won't run scripts if not present + if ( jQuery._evalUrl && !node.noModule ) { + jQuery._evalUrl( node.src, { + nonce: node.nonce || node.getAttribute( "nonce" ) + } ); + } + } else { + DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); + } + } + } + } + } + } + + return collection; +} + +function remove( elem, selector, keepData ) { + var node, + nodes = selector ? jQuery.filter( selector, elem ) : elem, + i = 0; + + for ( ; ( node = nodes[ i ] ) != null; i++ ) { + if ( !keepData && node.nodeType === 1 ) { + jQuery.cleanData( getAll( node ) ); + } + + if ( node.parentNode ) { + if ( keepData && isAttached( node ) ) { + setGlobalEval( getAll( node, "script" ) ); + } + node.parentNode.removeChild( node ); + } + } + + return elem; +} + +jQuery.extend( { + htmlPrefilter: function( html ) { + return html.replace( rxhtmlTag, "<$1>" ); + }, + + clone: function( elem, dataAndEvents, deepDataAndEvents ) { + var i, l, srcElements, destElements, + clone = elem.cloneNode( true ), + inPage = isAttached( elem ); + + // Fix IE cloning issues + if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && + !jQuery.isXMLDoc( elem ) ) { + + // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 + destElements = getAll( clone ); + srcElements = getAll( elem ); + + for ( i = 0, l = srcElements.length; i < l; i++ ) { + fixInput( srcElements[ i ], destElements[ i ] ); + } + } + + // Copy the events from the original to the clone + if ( dataAndEvents ) { + if ( deepDataAndEvents ) { + srcElements = srcElements || getAll( elem ); + destElements = destElements || getAll( clone ); + + for ( i = 0, l = srcElements.length; i < l; i++ ) { + cloneCopyEvent( srcElements[ i ], destElements[ i ] ); + } + } else { + cloneCopyEvent( elem, clone ); + } + } + + // Preserve script evaluation history + destElements = getAll( clone, "script" ); + if ( destElements.length > 0 ) { + setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); + } + + // Return the cloned set + return clone; + }, + + cleanData: function( elems ) { + var data, elem, type, + special = jQuery.event.special, + i = 0; + + for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { + if ( acceptData( elem ) ) { + if ( ( data = elem[ dataPriv.expando ] ) ) { + if ( data.events ) { + for ( type in data.events ) { + if ( special[ type ] ) { + jQuery.event.remove( elem, type ); + + // This is a shortcut to avoid jQuery.event.remove's overhead + } else { + jQuery.removeEvent( elem, type, data.handle ); + } + } + } + + // Support: Chrome <=35 - 45+ + // Assign undefined instead of using delete, see Data#remove + elem[ dataPriv.expando ] = undefined; + } + if ( elem[ dataUser.expando ] ) { + + // Support: Chrome <=35 - 45+ + // Assign undefined instead of using delete, see Data#remove + elem[ dataUser.expando ] = undefined; + } + } + } + } +} ); + +jQuery.fn.extend( { + detach: function( selector ) { + return remove( this, selector, true ); + }, + + remove: function( selector ) { + return remove( this, selector ); + }, + + text: function( value ) { + return access( this, function( value ) { + return value === undefined ? + jQuery.text( this ) : + this.empty().each( function() { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + this.textContent = value; + } + } ); + }, null, value, arguments.length ); + }, + + append: function() { + return domManip( this, arguments, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + var target = manipulationTarget( this, elem ); + target.appendChild( elem ); + } + } ); + }, + + prepend: function() { + return domManip( this, arguments, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + var target = manipulationTarget( this, elem ); + target.insertBefore( elem, target.firstChild ); + } + } ); + }, + + before: function() { + return domManip( this, arguments, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this ); + } + } ); + }, + + after: function() { + return domManip( this, arguments, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this.nextSibling ); + } + } ); + }, + + empty: function() { + var elem, + i = 0; + + for ( ; ( elem = this[ i ] ) != null; i++ ) { + if ( elem.nodeType === 1 ) { + + // Prevent memory leaks + jQuery.cleanData( getAll( elem, false ) ); + + // Remove any remaining nodes + elem.textContent = ""; + } + } + + return this; + }, + + clone: function( dataAndEvents, deepDataAndEvents ) { + dataAndEvents = dataAndEvents == null ? false : dataAndEvents; + deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; + + return this.map( function() { + return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); + } ); + }, + + html: function( value ) { + return access( this, function( value ) { + var elem = this[ 0 ] || {}, + i = 0, + l = this.length; + + if ( value === undefined && elem.nodeType === 1 ) { + return elem.innerHTML; + } + + // See if we can take a shortcut and just use innerHTML + if ( typeof value === "string" && !rnoInnerhtml.test( value ) && + !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { + + value = jQuery.htmlPrefilter( value ); + + try { + for ( ; i < l; i++ ) { + elem = this[ i ] || {}; + + // Remove element nodes and prevent memory leaks + if ( elem.nodeType === 1 ) { + jQuery.cleanData( getAll( elem, false ) ); + elem.innerHTML = value; + } + } + + elem = 0; + + // If using innerHTML throws an exception, use the fallback method + } catch ( e ) {} + } + + if ( elem ) { + this.empty().append( value ); + } + }, null, value, arguments.length ); + }, + + replaceWith: function() { + var ignored = []; + + // Make the changes, replacing each non-ignored context element with the new content + return domManip( this, arguments, function( elem ) { + var parent = this.parentNode; + + if ( jQuery.inArray( this, ignored ) < 0 ) { + jQuery.cleanData( getAll( this ) ); + if ( parent ) { + parent.replaceChild( elem, this ); + } + } + + // Force callback invocation + }, ignored ); + } +} ); + +jQuery.each( { + appendTo: "append", + prependTo: "prepend", + insertBefore: "before", + insertAfter: "after", + replaceAll: "replaceWith" +}, function( name, original ) { + jQuery.fn[ name ] = function( selector ) { + var elems, + ret = [], + insert = jQuery( selector ), + last = insert.length - 1, + i = 0; + + for ( ; i <= last; i++ ) { + elems = i === last ? this : this.clone( true ); + jQuery( insert[ i ] )[ original ]( elems ); + + // Support: Android <=4.0 only, PhantomJS 1 only + // .get() because push.apply(_, arraylike) throws on ancient WebKit + push.apply( ret, elems.get() ); + } + + return this.pushStack( ret ); + }; +} ); +var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); + +var getStyles = function( elem ) { + + // Support: IE <=11 only, Firefox <=30 (#15098, #14150) + // IE throws on elements created in popups + // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" + var view = elem.ownerDocument.defaultView; + + if ( !view || !view.opener ) { + view = window; + } + + return view.getComputedStyle( elem ); + }; + +var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); + + + +( function() { + + // Executing both pixelPosition & boxSizingReliable tests require only one layout + // so they're executed at the same time to save the second computation. + function computeStyleTests() { + + // This is a singleton, we need to execute it only once + if ( !div ) { + return; + } + + container.style.cssText = "position:absolute;left:-11111px;width:60px;" + + "margin-top:1px;padding:0;border:0"; + div.style.cssText = + "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + + "margin:auto;border:1px;padding:1px;" + + "width:60%;top:1%"; + documentElement.appendChild( container ).appendChild( div ); + + var divStyle = window.getComputedStyle( div ); + pixelPositionVal = divStyle.top !== "1%"; + + // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 + reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; + + // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 + // Some styles come back with percentage values, even though they shouldn't + div.style.right = "60%"; + pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; + + // Support: IE 9 - 11 only + // Detect misreporting of content dimensions for box-sizing:border-box elements + boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; + + // Support: IE 9 only + // Detect overflow:scroll screwiness (gh-3699) + // Support: Chrome <=64 + // Don't get tricked when zoom affects offsetWidth (gh-4029) + div.style.position = "absolute"; + scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; + + documentElement.removeChild( container ); + + // Nullify the div so it wouldn't be stored in the memory and + // it will also be a sign that checks already performed + div = null; + } + + function roundPixelMeasures( measure ) { + return Math.round( parseFloat( measure ) ); + } + + var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, + reliableMarginLeftVal, + container = document.createElement( "div" ), + div = document.createElement( "div" ); + + // Finish early in limited (non-browser) environments + if ( !div.style ) { + return; + } + + // Support: IE <=9 - 11 only + // Style of cloned element affects source element cloned (#8908) + div.style.backgroundClip = "content-box"; + div.cloneNode( true ).style.backgroundClip = ""; + support.clearCloneStyle = div.style.backgroundClip === "content-box"; + + jQuery.extend( support, { + boxSizingReliable: function() { + computeStyleTests(); + return boxSizingReliableVal; + }, + pixelBoxStyles: function() { + computeStyleTests(); + return pixelBoxStylesVal; + }, + pixelPosition: function() { + computeStyleTests(); + return pixelPositionVal; + }, + reliableMarginLeft: function() { + computeStyleTests(); + return reliableMarginLeftVal; + }, + scrollboxSize: function() { + computeStyleTests(); + return scrollboxSizeVal; + } + } ); +} )(); + + +function curCSS( elem, name, computed ) { + var width, minWidth, maxWidth, ret, + + // Support: Firefox 51+ + // Retrieving style before computed somehow + // fixes an issue with getting wrong values + // on detached elements + style = elem.style; + + computed = computed || getStyles( elem ); + + // getPropertyValue is needed for: + // .css('filter') (IE 9 only, #12537) + // .css('--customProperty) (#3144) + if ( computed ) { + ret = computed.getPropertyValue( name ) || computed[ name ]; + + if ( ret === "" && !isAttached( elem ) ) { + ret = jQuery.style( elem, name ); + } + + // A tribute to the "awesome hack by Dean Edwards" + // Android Browser returns percentage for some values, + // but width seems to be reliably pixels. + // This is against the CSSOM draft spec: + // https://drafts.csswg.org/cssom/#resolved-values + if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { + + // Remember the original values + width = style.width; + minWidth = style.minWidth; + maxWidth = style.maxWidth; + + // Put in the new values to get a computed value out + style.minWidth = style.maxWidth = style.width = ret; + ret = computed.width; + + // Revert the changed values + style.width = width; + style.minWidth = minWidth; + style.maxWidth = maxWidth; + } + } + + return ret !== undefined ? + + // Support: IE <=9 - 11 only + // IE returns zIndex value as an integer. + ret + "" : + ret; +} + + +function addGetHookIf( conditionFn, hookFn ) { + + // Define the hook, we'll check on the first run if it's really needed. + return { + get: function() { + if ( conditionFn() ) { + + // Hook not needed (or it's not possible to use it due + // to missing dependency), remove it. + delete this.get; + return; + } + + // Hook needed; redefine it so that the support test is not executed again. + return ( this.get = hookFn ).apply( this, arguments ); + } + }; +} + + +var cssPrefixes = [ "Webkit", "Moz", "ms" ], + emptyStyle = document.createElement( "div" ).style, + vendorProps = {}; + +// Return a vendor-prefixed property or undefined +function vendorPropName( name ) { + + // Check for vendor prefixed names + var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), + i = cssPrefixes.length; + + while ( i-- ) { + name = cssPrefixes[ i ] + capName; + if ( name in emptyStyle ) { + return name; + } + } +} + +// Return a potentially-mapped jQuery.cssProps or vendor prefixed property +function finalPropName( name ) { + var final = jQuery.cssProps[ name ] || vendorProps[ name ]; + + if ( final ) { + return final; + } + if ( name in emptyStyle ) { + return name; + } + return vendorProps[ name ] = vendorPropName( name ) || name; +} + + +var + + // Swappable if display is none or starts with table + // except "table", "table-cell", or "table-caption" + // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display + rdisplayswap = /^(none|table(?!-c[ea]).+)/, + rcustomProp = /^--/, + cssShow = { position: "absolute", visibility: "hidden", display: "block" }, + cssNormalTransform = { + letterSpacing: "0", + fontWeight: "400" + }; + +function setPositiveNumber( elem, value, subtract ) { + + // Any relative (+/-) values have already been + // normalized at this point + var matches = rcssNum.exec( value ); + return matches ? + + // Guard against undefined "subtract", e.g., when used as in cssHooks + Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : + value; +} + +function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { + var i = dimension === "width" ? 1 : 0, + extra = 0, + delta = 0; + + // Adjustment may not be necessary + if ( box === ( isBorderBox ? "border" : "content" ) ) { + return 0; + } + + for ( ; i < 4; i += 2 ) { + + // Both box models exclude margin + if ( box === "margin" ) { + delta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); + } + + // If we get here with a content-box, we're seeking "padding" or "border" or "margin" + if ( !isBorderBox ) { + + // Add padding + delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + + // For "border" or "margin", add border + if ( box !== "padding" ) { + delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + + // But still keep track of it otherwise + } else { + extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + + // If we get here with a border-box (content + padding + border), we're seeking "content" or + // "padding" or "margin" + } else { + + // For "content", subtract padding + if ( box === "content" ) { + delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + } + + // For "content" or "padding", subtract border + if ( box !== "margin" ) { + delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + } + } + + // Account for positive content-box scroll gutter when requested by providing computedVal + if ( !isBorderBox && computedVal >= 0 ) { + + // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border + // Assuming integer scroll gutter, subtract the rest and round down + delta += Math.max( 0, Math.ceil( + elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - + computedVal - + delta - + extra - + 0.5 + + // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter + // Use an explicit zero to avoid NaN (gh-3964) + ) ) || 0; + } + + return delta; +} + +function getWidthOrHeight( elem, dimension, extra ) { + + // Start with computed style + var styles = getStyles( elem ), + + // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). + // Fake content-box until we know it's needed to know the true value. + boxSizingNeeded = !support.boxSizingReliable() || extra, + isBorderBox = boxSizingNeeded && + jQuery.css( elem, "boxSizing", false, styles ) === "border-box", + valueIsBorderBox = isBorderBox, + + val = curCSS( elem, dimension, styles ), + offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); + + // Support: Firefox <=54 + // Return a confounding non-pixel value or feign ignorance, as appropriate. + if ( rnumnonpx.test( val ) ) { + if ( !extra ) { + return val; + } + val = "auto"; + } + + + // Fall back to offsetWidth/offsetHeight when value is "auto" + // This happens for inline elements with no explicit setting (gh-3571) + // Support: Android <=4.1 - 4.3 only + // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) + // Support: IE 9-11 only + // Also use offsetWidth/offsetHeight for when box sizing is unreliable + // We use getClientRects() to check for hidden/disconnected. + // In those cases, the computed value can be trusted to be border-box + if ( ( !support.boxSizingReliable() && isBorderBox || + val === "auto" || + !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && + elem.getClientRects().length ) { + + isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; + + // Where available, offsetWidth/offsetHeight approximate border box dimensions. + // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the + // retrieved value as a content box dimension. + valueIsBorderBox = offsetProp in elem; + if ( valueIsBorderBox ) { + val = elem[ offsetProp ]; + } + } + + // Normalize "" and auto + val = parseFloat( val ) || 0; + + // Adjust for the element's box model + return ( val + + boxModelAdjustment( + elem, + dimension, + extra || ( isBorderBox ? "border" : "content" ), + valueIsBorderBox, + styles, + + // Provide the current computed size to request scroll gutter calculation (gh-3589) + val + ) + ) + "px"; +} + +jQuery.extend( { + + // Add in style property hooks for overriding the default + // behavior of getting and setting a style property + cssHooks: { + opacity: { + get: function( elem, computed ) { + if ( computed ) { + + // We should always get a number back from opacity + var ret = curCSS( elem, "opacity" ); + return ret === "" ? "1" : ret; + } + } + } + }, + + // Don't automatically add "px" to these possibly-unitless properties + cssNumber: { + "animationIterationCount": true, + "columnCount": true, + "fillOpacity": true, + "flexGrow": true, + "flexShrink": true, + "fontWeight": true, + "gridArea": true, + "gridColumn": true, + "gridColumnEnd": true, + "gridColumnStart": true, + "gridRow": true, + "gridRowEnd": true, + "gridRowStart": true, + "lineHeight": true, + "opacity": true, + "order": true, + "orphans": true, + "widows": true, + "zIndex": true, + "zoom": true + }, + + // Add in properties whose names you wish to fix before + // setting or getting the value + cssProps: {}, + + // Get and set the style property on a DOM Node + style: function( elem, name, value, extra ) { + + // Don't set styles on text and comment nodes + if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { + return; + } + + // Make sure that we're working with the right name + var ret, type, hooks, + origName = camelCase( name ), + isCustomProp = rcustomProp.test( name ), + style = elem.style; + + // Make sure that we're working with the right name. We don't + // want to query the value if it is a CSS custom property + // since they are user-defined. + if ( !isCustomProp ) { + name = finalPropName( origName ); + } + + // Gets hook for the prefixed version, then unprefixed version + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // Check if we're setting a value + if ( value !== undefined ) { + type = typeof value; + + // Convert "+=" or "-=" to relative numbers (#7345) + if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { + value = adjustCSS( elem, name, ret ); + + // Fixes bug #9237 + type = "number"; + } + + // Make sure that null and NaN values aren't set (#7116) + if ( value == null || value !== value ) { + return; + } + + // If a number was passed in, add the unit (except for certain CSS properties) + // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append + // "px" to a few hardcoded values. + if ( type === "number" && !isCustomProp ) { + value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); + } + + // background-* props affect original clone's values + if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { + style[ name ] = "inherit"; + } + + // If a hook was provided, use that value, otherwise just set the specified value + if ( !hooks || !( "set" in hooks ) || + ( value = hooks.set( elem, value, extra ) ) !== undefined ) { + + if ( isCustomProp ) { + style.setProperty( name, value ); + } else { + style[ name ] = value; + } + } + + } else { + + // If a hook was provided get the non-computed value from there + if ( hooks && "get" in hooks && + ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { + + return ret; + } + + // Otherwise just get the value from the style object + return style[ name ]; + } + }, + + css: function( elem, name, extra, styles ) { + var val, num, hooks, + origName = camelCase( name ), + isCustomProp = rcustomProp.test( name ); + + // Make sure that we're working with the right name. We don't + // want to modify the value if it is a CSS custom property + // since they are user-defined. + if ( !isCustomProp ) { + name = finalPropName( origName ); + } + + // Try prefixed name followed by the unprefixed name + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // If a hook was provided get the computed value from there + if ( hooks && "get" in hooks ) { + val = hooks.get( elem, true, extra ); + } + + // Otherwise, if a way to get the computed value exists, use that + if ( val === undefined ) { + val = curCSS( elem, name, styles ); + } + + // Convert "normal" to computed value + if ( val === "normal" && name in cssNormalTransform ) { + val = cssNormalTransform[ name ]; + } + + // Make numeric if forced or a qualifier was provided and val looks numeric + if ( extra === "" || extra ) { + num = parseFloat( val ); + return extra === true || isFinite( num ) ? num || 0 : val; + } + + return val; + } +} ); + +jQuery.each( [ "height", "width" ], function( i, dimension ) { + jQuery.cssHooks[ dimension ] = { + get: function( elem, computed, extra ) { + if ( computed ) { + + // Certain elements can have dimension info if we invisibly show them + // but it must have a current display style that would benefit + return rdisplayswap.test( jQuery.css( elem, "display" ) ) && + + // Support: Safari 8+ + // Table columns in Safari have non-zero offsetWidth & zero + // getBoundingClientRect().width unless display is changed. + // Support: IE <=11 only + // Running getBoundingClientRect on a disconnected node + // in IE throws an error. + ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? + swap( elem, cssShow, function() { + return getWidthOrHeight( elem, dimension, extra ); + } ) : + getWidthOrHeight( elem, dimension, extra ); + } + }, + + set: function( elem, value, extra ) { + var matches, + styles = getStyles( elem ), + + // Only read styles.position if the test has a chance to fail + // to avoid forcing a reflow. + scrollboxSizeBuggy = !support.scrollboxSize() && + styles.position === "absolute", + + // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) + boxSizingNeeded = scrollboxSizeBuggy || extra, + isBorderBox = boxSizingNeeded && + jQuery.css( elem, "boxSizing", false, styles ) === "border-box", + subtract = extra ? + boxModelAdjustment( + elem, + dimension, + extra, + isBorderBox, + styles + ) : + 0; + + // Account for unreliable border-box dimensions by comparing offset* to computed and + // faking a content-box to get border and padding (gh-3699) + if ( isBorderBox && scrollboxSizeBuggy ) { + subtract -= Math.ceil( + elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - + parseFloat( styles[ dimension ] ) - + boxModelAdjustment( elem, dimension, "border", false, styles ) - + 0.5 + ); + } + + // Convert to pixels if value adjustment is needed + if ( subtract && ( matches = rcssNum.exec( value ) ) && + ( matches[ 3 ] || "px" ) !== "px" ) { + + elem.style[ dimension ] = value; + value = jQuery.css( elem, dimension ); + } + + return setPositiveNumber( elem, value, subtract ); + } + }; +} ); + +jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, + function( elem, computed ) { + if ( computed ) { + return ( parseFloat( curCSS( elem, "marginLeft" ) ) || + elem.getBoundingClientRect().left - + swap( elem, { marginLeft: 0 }, function() { + return elem.getBoundingClientRect().left; + } ) + ) + "px"; + } + } +); + +// These hooks are used by animate to expand properties +jQuery.each( { + margin: "", + padding: "", + border: "Width" +}, function( prefix, suffix ) { + jQuery.cssHooks[ prefix + suffix ] = { + expand: function( value ) { + var i = 0, + expanded = {}, + + // Assumes a single number if not a string + parts = typeof value === "string" ? value.split( " " ) : [ value ]; + + for ( ; i < 4; i++ ) { + expanded[ prefix + cssExpand[ i ] + suffix ] = + parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; + } + + return expanded; + } + }; + + if ( prefix !== "margin" ) { + jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; + } +} ); + +jQuery.fn.extend( { + css: function( name, value ) { + return access( this, function( elem, name, value ) { + var styles, len, + map = {}, + i = 0; + + if ( Array.isArray( name ) ) { + styles = getStyles( elem ); + len = name.length; + + for ( ; i < len; i++ ) { + map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); + } + + return map; + } + + return value !== undefined ? + jQuery.style( elem, name, value ) : + jQuery.css( elem, name ); + }, name, value, arguments.length > 1 ); + } +} ); + + +function Tween( elem, options, prop, end, easing ) { + return new Tween.prototype.init( elem, options, prop, end, easing ); +} +jQuery.Tween = Tween; + +Tween.prototype = { + constructor: Tween, + init: function( elem, options, prop, end, easing, unit ) { + this.elem = elem; + this.prop = prop; + this.easing = easing || jQuery.easing._default; + this.options = options; + this.start = this.now = this.cur(); + this.end = end; + this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); + }, + cur: function() { + var hooks = Tween.propHooks[ this.prop ]; + + return hooks && hooks.get ? + hooks.get( this ) : + Tween.propHooks._default.get( this ); + }, + run: function( percent ) { + var eased, + hooks = Tween.propHooks[ this.prop ]; + + if ( this.options.duration ) { + this.pos = eased = jQuery.easing[ this.easing ]( + percent, this.options.duration * percent, 0, 1, this.options.duration + ); + } else { + this.pos = eased = percent; + } + this.now = ( this.end - this.start ) * eased + this.start; + + if ( this.options.step ) { + this.options.step.call( this.elem, this.now, this ); + } + + if ( hooks && hooks.set ) { + hooks.set( this ); + } else { + Tween.propHooks._default.set( this ); + } + return this; + } +}; + +Tween.prototype.init.prototype = Tween.prototype; + +Tween.propHooks = { + _default: { + get: function( tween ) { + var result; + + // Use a property on the element directly when it is not a DOM element, + // or when there is no matching style property that exists. + if ( tween.elem.nodeType !== 1 || + tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { + return tween.elem[ tween.prop ]; + } + + // Passing an empty string as a 3rd parameter to .css will automatically + // attempt a parseFloat and fallback to a string if the parse fails. + // Simple values such as "10px" are parsed to Float; + // complex values such as "rotate(1rad)" are returned as-is. + result = jQuery.css( tween.elem, tween.prop, "" ); + + // Empty strings, null, undefined and "auto" are converted to 0. + return !result || result === "auto" ? 0 : result; + }, + set: function( tween ) { + + // Use step hook for back compat. + // Use cssHook if its there. + // Use .style if available and use plain properties where available. + if ( jQuery.fx.step[ tween.prop ] ) { + jQuery.fx.step[ tween.prop ]( tween ); + } else if ( tween.elem.nodeType === 1 && ( + jQuery.cssHooks[ tween.prop ] || + tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { + jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); + } else { + tween.elem[ tween.prop ] = tween.now; + } + } + } +}; + +// Support: IE <=9 only +// Panic based approach to setting things on disconnected nodes +Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { + set: function( tween ) { + if ( tween.elem.nodeType && tween.elem.parentNode ) { + tween.elem[ tween.prop ] = tween.now; + } + } +}; + +jQuery.easing = { + linear: function( p ) { + return p; + }, + swing: function( p ) { + return 0.5 - Math.cos( p * Math.PI ) / 2; + }, + _default: "swing" +}; + +jQuery.fx = Tween.prototype.init; + +// Back compat <1.8 extension point +jQuery.fx.step = {}; + + + + +var + fxNow, inProgress, + rfxtypes = /^(?:toggle|show|hide)$/, + rrun = /queueHooks$/; + +function schedule() { + if ( inProgress ) { + if ( document.hidden === false && window.requestAnimationFrame ) { + window.requestAnimationFrame( schedule ); + } else { + window.setTimeout( schedule, jQuery.fx.interval ); + } + + jQuery.fx.tick(); + } +} + +// Animations created synchronously will run synchronously +function createFxNow() { + window.setTimeout( function() { + fxNow = undefined; + } ); + return ( fxNow = Date.now() ); +} + +// Generate parameters to create a standard animation +function genFx( type, includeWidth ) { + var which, + i = 0, + attrs = { height: type }; + + // If we include width, step value is 1 to do all cssExpand values, + // otherwise step value is 2 to skip over Left and Right + includeWidth = includeWidth ? 1 : 0; + for ( ; i < 4; i += 2 - includeWidth ) { + which = cssExpand[ i ]; + attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; + } + + if ( includeWidth ) { + attrs.opacity = attrs.width = type; + } + + return attrs; +} + +function createTween( value, prop, animation ) { + var tween, + collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), + index = 0, + length = collection.length; + for ( ; index < length; index++ ) { + if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { + + // We're done with this property + return tween; + } + } +} + +function defaultPrefilter( elem, props, opts ) { + var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, + isBox = "width" in props || "height" in props, + anim = this, + orig = {}, + style = elem.style, + hidden = elem.nodeType && isHiddenWithinTree( elem ), + dataShow = dataPriv.get( elem, "fxshow" ); + + // Queue-skipping animations hijack the fx hooks + if ( !opts.queue ) { + hooks = jQuery._queueHooks( elem, "fx" ); + if ( hooks.unqueued == null ) { + hooks.unqueued = 0; + oldfire = hooks.empty.fire; + hooks.empty.fire = function() { + if ( !hooks.unqueued ) { + oldfire(); + } + }; + } + hooks.unqueued++; + + anim.always( function() { + + // Ensure the complete handler is called before this completes + anim.always( function() { + hooks.unqueued--; + if ( !jQuery.queue( elem, "fx" ).length ) { + hooks.empty.fire(); + } + } ); + } ); + } + + // Detect show/hide animations + for ( prop in props ) { + value = props[ prop ]; + if ( rfxtypes.test( value ) ) { + delete props[ prop ]; + toggle = toggle || value === "toggle"; + if ( value === ( hidden ? "hide" : "show" ) ) { + + // Pretend to be hidden if this is a "show" and + // there is still data from a stopped show/hide + if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { + hidden = true; + + // Ignore all other no-op show/hide data + } else { + continue; + } + } + orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); + } + } + + // Bail out if this is a no-op like .hide().hide() + propTween = !jQuery.isEmptyObject( props ); + if ( !propTween && jQuery.isEmptyObject( orig ) ) { + return; + } + + // Restrict "overflow" and "display" styles during box animations + if ( isBox && elem.nodeType === 1 ) { + + // Support: IE <=9 - 11, Edge 12 - 15 + // Record all 3 overflow attributes because IE does not infer the shorthand + // from identically-valued overflowX and overflowY and Edge just mirrors + // the overflowX value there. + opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; + + // Identify a display type, preferring old show/hide data over the CSS cascade + restoreDisplay = dataShow && dataShow.display; + if ( restoreDisplay == null ) { + restoreDisplay = dataPriv.get( elem, "display" ); + } + display = jQuery.css( elem, "display" ); + if ( display === "none" ) { + if ( restoreDisplay ) { + display = restoreDisplay; + } else { + + // Get nonempty value(s) by temporarily forcing visibility + showHide( [ elem ], true ); + restoreDisplay = elem.style.display || restoreDisplay; + display = jQuery.css( elem, "display" ); + showHide( [ elem ] ); + } + } + + // Animate inline elements as inline-block + if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { + if ( jQuery.css( elem, "float" ) === "none" ) { + + // Restore the original display value at the end of pure show/hide animations + if ( !propTween ) { + anim.done( function() { + style.display = restoreDisplay; + } ); + if ( restoreDisplay == null ) { + display = style.display; + restoreDisplay = display === "none" ? "" : display; + } + } + style.display = "inline-block"; + } + } + } + + if ( opts.overflow ) { + style.overflow = "hidden"; + anim.always( function() { + style.overflow = opts.overflow[ 0 ]; + style.overflowX = opts.overflow[ 1 ]; + style.overflowY = opts.overflow[ 2 ]; + } ); + } + + // Implement show/hide animations + propTween = false; + for ( prop in orig ) { + + // General show/hide setup for this element animation + if ( !propTween ) { + if ( dataShow ) { + if ( "hidden" in dataShow ) { + hidden = dataShow.hidden; + } + } else { + dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); + } + + // Store hidden/visible for toggle so `.stop().toggle()` "reverses" + if ( toggle ) { + dataShow.hidden = !hidden; + } + + // Show elements before animating them + if ( hidden ) { + showHide( [ elem ], true ); + } + + /* eslint-disable no-loop-func */ + + anim.done( function() { + + /* eslint-enable no-loop-func */ + + // The final step of a "hide" animation is actually hiding the element + if ( !hidden ) { + showHide( [ elem ] ); + } + dataPriv.remove( elem, "fxshow" ); + for ( prop in orig ) { + jQuery.style( elem, prop, orig[ prop ] ); + } + } ); + } + + // Per-property setup + propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); + if ( !( prop in dataShow ) ) { + dataShow[ prop ] = propTween.start; + if ( hidden ) { + propTween.end = propTween.start; + propTween.start = 0; + } + } + } +} + +function propFilter( props, specialEasing ) { + var index, name, easing, value, hooks; + + // camelCase, specialEasing and expand cssHook pass + for ( index in props ) { + name = camelCase( index ); + easing = specialEasing[ name ]; + value = props[ index ]; + if ( Array.isArray( value ) ) { + easing = value[ 1 ]; + value = props[ index ] = value[ 0 ]; + } + + if ( index !== name ) { + props[ name ] = value; + delete props[ index ]; + } + + hooks = jQuery.cssHooks[ name ]; + if ( hooks && "expand" in hooks ) { + value = hooks.expand( value ); + delete props[ name ]; + + // Not quite $.extend, this won't overwrite existing keys. + // Reusing 'index' because we have the correct "name" + for ( index in value ) { + if ( !( index in props ) ) { + props[ index ] = value[ index ]; + specialEasing[ index ] = easing; + } + } + } else { + specialEasing[ name ] = easing; + } + } +} + +function Animation( elem, properties, options ) { + var result, + stopped, + index = 0, + length = Animation.prefilters.length, + deferred = jQuery.Deferred().always( function() { + + // Don't match elem in the :animated selector + delete tick.elem; + } ), + tick = function() { + if ( stopped ) { + return false; + } + var currentTime = fxNow || createFxNow(), + remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), + + // Support: Android 2.3 only + // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) + temp = remaining / animation.duration || 0, + percent = 1 - temp, + index = 0, + length = animation.tweens.length; + + for ( ; index < length; index++ ) { + animation.tweens[ index ].run( percent ); + } + + deferred.notifyWith( elem, [ animation, percent, remaining ] ); + + // If there's more to do, yield + if ( percent < 1 && length ) { + return remaining; + } + + // If this was an empty animation, synthesize a final progress notification + if ( !length ) { + deferred.notifyWith( elem, [ animation, 1, 0 ] ); + } + + // Resolve the animation and report its conclusion + deferred.resolveWith( elem, [ animation ] ); + return false; + }, + animation = deferred.promise( { + elem: elem, + props: jQuery.extend( {}, properties ), + opts: jQuery.extend( true, { + specialEasing: {}, + easing: jQuery.easing._default + }, options ), + originalProperties: properties, + originalOptions: options, + startTime: fxNow || createFxNow(), + duration: options.duration, + tweens: [], + createTween: function( prop, end ) { + var tween = jQuery.Tween( elem, animation.opts, prop, end, + animation.opts.specialEasing[ prop ] || animation.opts.easing ); + animation.tweens.push( tween ); + return tween; + }, + stop: function( gotoEnd ) { + var index = 0, + + // If we are going to the end, we want to run all the tweens + // otherwise we skip this part + length = gotoEnd ? animation.tweens.length : 0; + if ( stopped ) { + return this; + } + stopped = true; + for ( ; index < length; index++ ) { + animation.tweens[ index ].run( 1 ); + } + + // Resolve when we played the last frame; otherwise, reject + if ( gotoEnd ) { + deferred.notifyWith( elem, [ animation, 1, 0 ] ); + deferred.resolveWith( elem, [ animation, gotoEnd ] ); + } else { + deferred.rejectWith( elem, [ animation, gotoEnd ] ); + } + return this; + } + } ), + props = animation.props; + + propFilter( props, animation.opts.specialEasing ); + + for ( ; index < length; index++ ) { + result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); + if ( result ) { + if ( isFunction( result.stop ) ) { + jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = + result.stop.bind( result ); + } + return result; + } + } + + jQuery.map( props, createTween, animation ); + + if ( isFunction( animation.opts.start ) ) { + animation.opts.start.call( elem, animation ); + } + + // Attach callbacks from options + animation + .progress( animation.opts.progress ) + .done( animation.opts.done, animation.opts.complete ) + .fail( animation.opts.fail ) + .always( animation.opts.always ); + + jQuery.fx.timer( + jQuery.extend( tick, { + elem: elem, + anim: animation, + queue: animation.opts.queue + } ) + ); + + return animation; +} + +jQuery.Animation = jQuery.extend( Animation, { + + tweeners: { + "*": [ function( prop, value ) { + var tween = this.createTween( prop, value ); + adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); + return tween; + } ] + }, + + tweener: function( props, callback ) { + if ( isFunction( props ) ) { + callback = props; + props = [ "*" ]; + } else { + props = props.match( rnothtmlwhite ); + } + + var prop, + index = 0, + length = props.length; + + for ( ; index < length; index++ ) { + prop = props[ index ]; + Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; + Animation.tweeners[ prop ].unshift( callback ); + } + }, + + prefilters: [ defaultPrefilter ], + + prefilter: function( callback, prepend ) { + if ( prepend ) { + Animation.prefilters.unshift( callback ); + } else { + Animation.prefilters.push( callback ); + } + } +} ); + +jQuery.speed = function( speed, easing, fn ) { + var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { + complete: fn || !fn && easing || + isFunction( speed ) && speed, + duration: speed, + easing: fn && easing || easing && !isFunction( easing ) && easing + }; + + // Go to the end state if fx are off + if ( jQuery.fx.off ) { + opt.duration = 0; + + } else { + if ( typeof opt.duration !== "number" ) { + if ( opt.duration in jQuery.fx.speeds ) { + opt.duration = jQuery.fx.speeds[ opt.duration ]; + + } else { + opt.duration = jQuery.fx.speeds._default; + } + } + } + + // Normalize opt.queue - true/undefined/null -> "fx" + if ( opt.queue == null || opt.queue === true ) { + opt.queue = "fx"; + } + + // Queueing + opt.old = opt.complete; + + opt.complete = function() { + if ( isFunction( opt.old ) ) { + opt.old.call( this ); + } + + if ( opt.queue ) { + jQuery.dequeue( this, opt.queue ); + } + }; + + return opt; +}; + +jQuery.fn.extend( { + fadeTo: function( speed, to, easing, callback ) { + + // Show any hidden elements after setting opacity to 0 + return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() + + // Animate to the value specified + .end().animate( { opacity: to }, speed, easing, callback ); + }, + animate: function( prop, speed, easing, callback ) { + var empty = jQuery.isEmptyObject( prop ), + optall = jQuery.speed( speed, easing, callback ), + doAnimation = function() { + + // Operate on a copy of prop so per-property easing won't be lost + var anim = Animation( this, jQuery.extend( {}, prop ), optall ); + + // Empty animations, or finishing resolves immediately + if ( empty || dataPriv.get( this, "finish" ) ) { + anim.stop( true ); + } + }; + doAnimation.finish = doAnimation; + + return empty || optall.queue === false ? + this.each( doAnimation ) : + this.queue( optall.queue, doAnimation ); + }, + stop: function( type, clearQueue, gotoEnd ) { + var stopQueue = function( hooks ) { + var stop = hooks.stop; + delete hooks.stop; + stop( gotoEnd ); + }; + + if ( typeof type !== "string" ) { + gotoEnd = clearQueue; + clearQueue = type; + type = undefined; + } + if ( clearQueue && type !== false ) { + this.queue( type || "fx", [] ); + } + + return this.each( function() { + var dequeue = true, + index = type != null && type + "queueHooks", + timers = jQuery.timers, + data = dataPriv.get( this ); + + if ( index ) { + if ( data[ index ] && data[ index ].stop ) { + stopQueue( data[ index ] ); + } + } else { + for ( index in data ) { + if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { + stopQueue( data[ index ] ); + } + } + } + + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && + ( type == null || timers[ index ].queue === type ) ) { + + timers[ index ].anim.stop( gotoEnd ); + dequeue = false; + timers.splice( index, 1 ); + } + } + + // Start the next in the queue if the last step wasn't forced. + // Timers currently will call their complete callbacks, which + // will dequeue but only if they were gotoEnd. + if ( dequeue || !gotoEnd ) { + jQuery.dequeue( this, type ); + } + } ); + }, + finish: function( type ) { + if ( type !== false ) { + type = type || "fx"; + } + return this.each( function() { + var index, + data = dataPriv.get( this ), + queue = data[ type + "queue" ], + hooks = data[ type + "queueHooks" ], + timers = jQuery.timers, + length = queue ? queue.length : 0; + + // Enable finishing flag on private data + data.finish = true; + + // Empty the queue first + jQuery.queue( this, type, [] ); + + if ( hooks && hooks.stop ) { + hooks.stop.call( this, true ); + } + + // Look for any active animations, and finish them + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && timers[ index ].queue === type ) { + timers[ index ].anim.stop( true ); + timers.splice( index, 1 ); + } + } + + // Look for any animations in the old queue and finish them + for ( index = 0; index < length; index++ ) { + if ( queue[ index ] && queue[ index ].finish ) { + queue[ index ].finish.call( this ); + } + } + + // Turn off finishing flag + delete data.finish; + } ); + } +} ); + +jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) { + var cssFn = jQuery.fn[ name ]; + jQuery.fn[ name ] = function( speed, easing, callback ) { + return speed == null || typeof speed === "boolean" ? + cssFn.apply( this, arguments ) : + this.animate( genFx( name, true ), speed, easing, callback ); + }; +} ); + +// Generate shortcuts for custom animations +jQuery.each( { + slideDown: genFx( "show" ), + slideUp: genFx( "hide" ), + slideToggle: genFx( "toggle" ), + fadeIn: { opacity: "show" }, + fadeOut: { opacity: "hide" }, + fadeToggle: { opacity: "toggle" } +}, function( name, props ) { + jQuery.fn[ name ] = function( speed, easing, callback ) { + return this.animate( props, speed, easing, callback ); + }; +} ); + +jQuery.timers = []; +jQuery.fx.tick = function() { + var timer, + i = 0, + timers = jQuery.timers; + + fxNow = Date.now(); + + for ( ; i < timers.length; i++ ) { + timer = timers[ i ]; + + // Run the timer and safely remove it when done (allowing for external removal) + if ( !timer() && timers[ i ] === timer ) { + timers.splice( i--, 1 ); + } + } + + if ( !timers.length ) { + jQuery.fx.stop(); + } + fxNow = undefined; +}; + +jQuery.fx.timer = function( timer ) { + jQuery.timers.push( timer ); + jQuery.fx.start(); +}; + +jQuery.fx.interval = 13; +jQuery.fx.start = function() { + if ( inProgress ) { + return; + } + + inProgress = true; + schedule(); +}; + +jQuery.fx.stop = function() { + inProgress = null; +}; + +jQuery.fx.speeds = { + slow: 600, + fast: 200, + + // Default speed + _default: 400 +}; + + +// Based off of the plugin by Clint Helfers, with permission. +// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ +jQuery.fn.delay = function( time, type ) { + time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; + type = type || "fx"; + + return this.queue( type, function( next, hooks ) { + var timeout = window.setTimeout( next, time ); + hooks.stop = function() { + window.clearTimeout( timeout ); + }; + } ); +}; + + +( function() { + var input = document.createElement( "input" ), + select = document.createElement( "select" ), + opt = select.appendChild( document.createElement( "option" ) ); + + input.type = "checkbox"; + + // Support: Android <=4.3 only + // Default value for a checkbox should be "on" + support.checkOn = input.value !== ""; + + // Support: IE <=11 only + // Must access selectedIndex to make default options select + support.optSelected = opt.selected; + + // Support: IE <=11 only + // An input loses its value after becoming a radio + input = document.createElement( "input" ); + input.value = "t"; + input.type = "radio"; + support.radioValue = input.value === "t"; +} )(); + + +var boolHook, + attrHandle = jQuery.expr.attrHandle; + +jQuery.fn.extend( { + attr: function( name, value ) { + return access( this, jQuery.attr, name, value, arguments.length > 1 ); + }, + + removeAttr: function( name ) { + return this.each( function() { + jQuery.removeAttr( this, name ); + } ); + } +} ); + +jQuery.extend( { + attr: function( elem, name, value ) { + var ret, hooks, + nType = elem.nodeType; + + // Don't get/set attributes on text, comment and attribute nodes + if ( nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + // Fallback to prop when attributes are not supported + if ( typeof elem.getAttribute === "undefined" ) { + return jQuery.prop( elem, name, value ); + } + + // Attribute hooks are determined by the lowercase version + // Grab necessary hook if one is defined + if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { + hooks = jQuery.attrHooks[ name.toLowerCase() ] || + ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); + } + + if ( value !== undefined ) { + if ( value === null ) { + jQuery.removeAttr( elem, name ); + return; + } + + if ( hooks && "set" in hooks && + ( ret = hooks.set( elem, value, name ) ) !== undefined ) { + return ret; + } + + elem.setAttribute( name, value + "" ); + return value; + } + + if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { + return ret; + } + + ret = jQuery.find.attr( elem, name ); + + // Non-existent attributes return null, we normalize to undefined + return ret == null ? undefined : ret; + }, + + attrHooks: { + type: { + set: function( elem, value ) { + if ( !support.radioValue && value === "radio" && + nodeName( elem, "input" ) ) { + var val = elem.value; + elem.setAttribute( "type", value ); + if ( val ) { + elem.value = val; + } + return value; + } + } + } + }, + + removeAttr: function( elem, value ) { + var name, + i = 0, + + // Attribute names can contain non-HTML whitespace characters + // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 + attrNames = value && value.match( rnothtmlwhite ); + + if ( attrNames && elem.nodeType === 1 ) { + while ( ( name = attrNames[ i++ ] ) ) { + elem.removeAttribute( name ); + } + } + } +} ); + +// Hooks for boolean attributes +boolHook = { + set: function( elem, value, name ) { + if ( value === false ) { + + // Remove boolean attributes when set to false + jQuery.removeAttr( elem, name ); + } else { + elem.setAttribute( name, name ); + } + return name; + } +}; + +jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) { + var getter = attrHandle[ name ] || jQuery.find.attr; + + attrHandle[ name ] = function( elem, name, isXML ) { + var ret, handle, + lowercaseName = name.toLowerCase(); + + if ( !isXML ) { + + // Avoid an infinite loop by temporarily removing this function from the getter + handle = attrHandle[ lowercaseName ]; + attrHandle[ lowercaseName ] = ret; + ret = getter( elem, name, isXML ) != null ? + lowercaseName : + null; + attrHandle[ lowercaseName ] = handle; + } + return ret; + }; +} ); + + + + +var rfocusable = /^(?:input|select|textarea|button)$/i, + rclickable = /^(?:a|area)$/i; + +jQuery.fn.extend( { + prop: function( name, value ) { + return access( this, jQuery.prop, name, value, arguments.length > 1 ); + }, + + removeProp: function( name ) { + return this.each( function() { + delete this[ jQuery.propFix[ name ] || name ]; + } ); + } +} ); + +jQuery.extend( { + prop: function( elem, name, value ) { + var ret, hooks, + nType = elem.nodeType; + + // Don't get/set properties on text, comment and attribute nodes + if ( nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { + + // Fix name and attach hooks + name = jQuery.propFix[ name ] || name; + hooks = jQuery.propHooks[ name ]; + } + + if ( value !== undefined ) { + if ( hooks && "set" in hooks && + ( ret = hooks.set( elem, value, name ) ) !== undefined ) { + return ret; + } + + return ( elem[ name ] = value ); + } + + if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { + return ret; + } + + return elem[ name ]; + }, + + propHooks: { + tabIndex: { + get: function( elem ) { + + // Support: IE <=9 - 11 only + // elem.tabIndex doesn't always return the + // correct value when it hasn't been explicitly set + // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ + // Use proper attribute retrieval(#12072) + var tabindex = jQuery.find.attr( elem, "tabindex" ); + + if ( tabindex ) { + return parseInt( tabindex, 10 ); + } + + if ( + rfocusable.test( elem.nodeName ) || + rclickable.test( elem.nodeName ) && + elem.href + ) { + return 0; + } + + return -1; + } + } + }, + + propFix: { + "for": "htmlFor", + "class": "className" + } +} ); + +// Support: IE <=11 only +// Accessing the selectedIndex property +// forces the browser to respect setting selected +// on the option +// The getter ensures a default option is selected +// when in an optgroup +// eslint rule "no-unused-expressions" is disabled for this code +// since it considers such accessions noop +if ( !support.optSelected ) { + jQuery.propHooks.selected = { + get: function( elem ) { + + /* eslint no-unused-expressions: "off" */ + + var parent = elem.parentNode; + if ( parent && parent.parentNode ) { + parent.parentNode.selectedIndex; + } + return null; + }, + set: function( elem ) { + + /* eslint no-unused-expressions: "off" */ + + var parent = elem.parentNode; + if ( parent ) { + parent.selectedIndex; + + if ( parent.parentNode ) { + parent.parentNode.selectedIndex; + } + } + } + }; +} + +jQuery.each( [ + "tabIndex", + "readOnly", + "maxLength", + "cellSpacing", + "cellPadding", + "rowSpan", + "colSpan", + "useMap", + "frameBorder", + "contentEditable" +], function() { + jQuery.propFix[ this.toLowerCase() ] = this; +} ); + + + + + // Strip and collapse whitespace according to HTML spec + // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace + function stripAndCollapse( value ) { + var tokens = value.match( rnothtmlwhite ) || []; + return tokens.join( " " ); + } + + +function getClass( elem ) { + return elem.getAttribute && elem.getAttribute( "class" ) || ""; +} + +function classesToArray( value ) { + if ( Array.isArray( value ) ) { + return value; + } + if ( typeof value === "string" ) { + return value.match( rnothtmlwhite ) || []; + } + return []; +} + +jQuery.fn.extend( { + addClass: function( value ) { + var classes, elem, cur, curValue, clazz, j, finalValue, + i = 0; + + if ( isFunction( value ) ) { + return this.each( function( j ) { + jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); + } ); + } + + classes = classesToArray( value ); + + if ( classes.length ) { + while ( ( elem = this[ i++ ] ) ) { + curValue = getClass( elem ); + cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); + + if ( cur ) { + j = 0; + while ( ( clazz = classes[ j++ ] ) ) { + if ( cur.indexOf( " " + clazz + " " ) < 0 ) { + cur += clazz + " "; + } + } + + // Only assign if different to avoid unneeded rendering. + finalValue = stripAndCollapse( cur ); + if ( curValue !== finalValue ) { + elem.setAttribute( "class", finalValue ); + } + } + } + } + + return this; + }, + + removeClass: function( value ) { + var classes, elem, cur, curValue, clazz, j, finalValue, + i = 0; + + if ( isFunction( value ) ) { + return this.each( function( j ) { + jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); + } ); + } + + if ( !arguments.length ) { + return this.attr( "class", "" ); + } + + classes = classesToArray( value ); + + if ( classes.length ) { + while ( ( elem = this[ i++ ] ) ) { + curValue = getClass( elem ); + + // This expression is here for better compressibility (see addClass) + cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); + + if ( cur ) { + j = 0; + while ( ( clazz = classes[ j++ ] ) ) { + + // Remove *all* instances + while ( cur.indexOf( " " + clazz + " " ) > -1 ) { + cur = cur.replace( " " + clazz + " ", " " ); + } + } + + // Only assign if different to avoid unneeded rendering. + finalValue = stripAndCollapse( cur ); + if ( curValue !== finalValue ) { + elem.setAttribute( "class", finalValue ); + } + } + } + } + + return this; + }, + + toggleClass: function( value, stateVal ) { + var type = typeof value, + isValidValue = type === "string" || Array.isArray( value ); + + if ( typeof stateVal === "boolean" && isValidValue ) { + return stateVal ? this.addClass( value ) : this.removeClass( value ); + } + + if ( isFunction( value ) ) { + return this.each( function( i ) { + jQuery( this ).toggleClass( + value.call( this, i, getClass( this ), stateVal ), + stateVal + ); + } ); + } + + return this.each( function() { + var className, i, self, classNames; + + if ( isValidValue ) { + + // Toggle individual class names + i = 0; + self = jQuery( this ); + classNames = classesToArray( value ); + + while ( ( className = classNames[ i++ ] ) ) { + + // Check each className given, space separated list + if ( self.hasClass( className ) ) { + self.removeClass( className ); + } else { + self.addClass( className ); + } + } + + // Toggle whole class name + } else if ( value === undefined || type === "boolean" ) { + className = getClass( this ); + if ( className ) { + + // Store className if set + dataPriv.set( this, "__className__", className ); + } + + // If the element has a class name or if we're passed `false`, + // then remove the whole classname (if there was one, the above saved it). + // Otherwise bring back whatever was previously saved (if anything), + // falling back to the empty string if nothing was stored. + if ( this.setAttribute ) { + this.setAttribute( "class", + className || value === false ? + "" : + dataPriv.get( this, "__className__" ) || "" + ); + } + } + } ); + }, + + hasClass: function( selector ) { + var className, elem, + i = 0; + + className = " " + selector + " "; + while ( ( elem = this[ i++ ] ) ) { + if ( elem.nodeType === 1 && + ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { + return true; + } + } + + return false; + } +} ); + + + + +var rreturn = /\r/g; + +jQuery.fn.extend( { + val: function( value ) { + var hooks, ret, valueIsFunction, + elem = this[ 0 ]; + + if ( !arguments.length ) { + if ( elem ) { + hooks = jQuery.valHooks[ elem.type ] || + jQuery.valHooks[ elem.nodeName.toLowerCase() ]; + + if ( hooks && + "get" in hooks && + ( ret = hooks.get( elem, "value" ) ) !== undefined + ) { + return ret; + } + + ret = elem.value; + + // Handle most common string cases + if ( typeof ret === "string" ) { + return ret.replace( rreturn, "" ); + } + + // Handle cases where value is null/undef or number + return ret == null ? "" : ret; + } + + return; + } + + valueIsFunction = isFunction( value ); + + return this.each( function( i ) { + var val; + + if ( this.nodeType !== 1 ) { + return; + } + + if ( valueIsFunction ) { + val = value.call( this, i, jQuery( this ).val() ); + } else { + val = value; + } + + // Treat null/undefined as ""; convert numbers to string + if ( val == null ) { + val = ""; + + } else if ( typeof val === "number" ) { + val += ""; + + } else if ( Array.isArray( val ) ) { + val = jQuery.map( val, function( value ) { + return value == null ? "" : value + ""; + } ); + } + + hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; + + // If set returns undefined, fall back to normal setting + if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { + this.value = val; + } + } ); + } +} ); + +jQuery.extend( { + valHooks: { + option: { + get: function( elem ) { + + var val = jQuery.find.attr( elem, "value" ); + return val != null ? + val : + + // Support: IE <=10 - 11 only + // option.text throws exceptions (#14686, #14858) + // Strip and collapse whitespace + // https://html.spec.whatwg.org/#strip-and-collapse-whitespace + stripAndCollapse( jQuery.text( elem ) ); + } + }, + select: { + get: function( elem ) { + var value, option, i, + options = elem.options, + index = elem.selectedIndex, + one = elem.type === "select-one", + values = one ? null : [], + max = one ? index + 1 : options.length; + + if ( index < 0 ) { + i = max; + + } else { + i = one ? index : 0; + } + + // Loop through all the selected options + for ( ; i < max; i++ ) { + option = options[ i ]; + + // Support: IE <=9 only + // IE8-9 doesn't update selected after form reset (#2551) + if ( ( option.selected || i === index ) && + + // Don't return options that are disabled or in a disabled optgroup + !option.disabled && + ( !option.parentNode.disabled || + !nodeName( option.parentNode, "optgroup" ) ) ) { + + // Get the specific value for the option + value = jQuery( option ).val(); + + // We don't need an array for one selects + if ( one ) { + return value; + } + + // Multi-Selects return an array + values.push( value ); + } + } + + return values; + }, + + set: function( elem, value ) { + var optionSet, option, + options = elem.options, + values = jQuery.makeArray( value ), + i = options.length; + + while ( i-- ) { + option = options[ i ]; + + /* eslint-disable no-cond-assign */ + + if ( option.selected = + jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 + ) { + optionSet = true; + } + + /* eslint-enable no-cond-assign */ + } + + // Force browsers to behave consistently when non-matching value is set + if ( !optionSet ) { + elem.selectedIndex = -1; + } + return values; + } + } + } +} ); + +// Radios and checkboxes getter/setter +jQuery.each( [ "radio", "checkbox" ], function() { + jQuery.valHooks[ this ] = { + set: function( elem, value ) { + if ( Array.isArray( value ) ) { + return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); + } + } + }; + if ( !support.checkOn ) { + jQuery.valHooks[ this ].get = function( elem ) { + return elem.getAttribute( "value" ) === null ? "on" : elem.value; + }; + } +} ); + + + + +// Return jQuery for attributes-only inclusion + + +support.focusin = "onfocusin" in window; + + +var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, + stopPropagationCallback = function( e ) { + e.stopPropagation(); + }; + +jQuery.extend( jQuery.event, { + + trigger: function( event, data, elem, onlyHandlers ) { + + var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, + eventPath = [ elem || document ], + type = hasOwn.call( event, "type" ) ? event.type : event, + namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; + + cur = lastElement = tmp = elem = elem || document; + + // Don't do events on text and comment nodes + if ( elem.nodeType === 3 || elem.nodeType === 8 ) { + return; + } + + // focus/blur morphs to focusin/out; ensure we're not firing them right now + if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { + return; + } + + if ( type.indexOf( "." ) > -1 ) { + + // Namespaced trigger; create a regexp to match event type in handle() + namespaces = type.split( "." ); + type = namespaces.shift(); + namespaces.sort(); + } + ontype = type.indexOf( ":" ) < 0 && "on" + type; + + // Caller can pass in a jQuery.Event object, Object, or just an event type string + event = event[ jQuery.expando ] ? + event : + new jQuery.Event( type, typeof event === "object" && event ); + + // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) + event.isTrigger = onlyHandlers ? 2 : 3; + event.namespace = namespaces.join( "." ); + event.rnamespace = event.namespace ? + new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : + null; + + // Clean up the event in case it is being reused + event.result = undefined; + if ( !event.target ) { + event.target = elem; + } + + // Clone any incoming data and prepend the event, creating the handler arg list + data = data == null ? + [ event ] : + jQuery.makeArray( data, [ event ] ); + + // Allow special events to draw outside the lines + special = jQuery.event.special[ type ] || {}; + if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { + return; + } + + // Determine event propagation path in advance, per W3C events spec (#9951) + // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) + if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { + + bubbleType = special.delegateType || type; + if ( !rfocusMorph.test( bubbleType + type ) ) { + cur = cur.parentNode; + } + for ( ; cur; cur = cur.parentNode ) { + eventPath.push( cur ); + tmp = cur; + } + + // Only add window if we got to document (e.g., not plain obj or detached DOM) + if ( tmp === ( elem.ownerDocument || document ) ) { + eventPath.push( tmp.defaultView || tmp.parentWindow || window ); + } + } + + // Fire handlers on the event path + i = 0; + while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { + lastElement = cur; + event.type = i > 1 ? + bubbleType : + special.bindType || type; + + // jQuery handler + handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] && + dataPriv.get( cur, "handle" ); + if ( handle ) { + handle.apply( cur, data ); + } + + // Native handler + handle = ontype && cur[ ontype ]; + if ( handle && handle.apply && acceptData( cur ) ) { + event.result = handle.apply( cur, data ); + if ( event.result === false ) { + event.preventDefault(); + } + } + } + event.type = type; + + // If nobody prevented the default action, do it now + if ( !onlyHandlers && !event.isDefaultPrevented() ) { + + if ( ( !special._default || + special._default.apply( eventPath.pop(), data ) === false ) && + acceptData( elem ) ) { + + // Call a native DOM method on the target with the same name as the event. + // Don't do default actions on window, that's where global variables be (#6170) + if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { + + // Don't re-trigger an onFOO event when we call its FOO() method + tmp = elem[ ontype ]; + + if ( tmp ) { + elem[ ontype ] = null; + } + + // Prevent re-triggering of the same event, since we already bubbled it above + jQuery.event.triggered = type; + + if ( event.isPropagationStopped() ) { + lastElement.addEventListener( type, stopPropagationCallback ); + } + + elem[ type ](); + + if ( event.isPropagationStopped() ) { + lastElement.removeEventListener( type, stopPropagationCallback ); + } + + jQuery.event.triggered = undefined; + + if ( tmp ) { + elem[ ontype ] = tmp; + } + } + } + } + + return event.result; + }, + + // Piggyback on a donor event to simulate a different one + // Used only for `focus(in | out)` events + simulate: function( type, elem, event ) { + var e = jQuery.extend( + new jQuery.Event(), + event, + { + type: type, + isSimulated: true + } + ); + + jQuery.event.trigger( e, null, elem ); + } + +} ); + +jQuery.fn.extend( { + + trigger: function( type, data ) { + return this.each( function() { + jQuery.event.trigger( type, data, this ); + } ); + }, + triggerHandler: function( type, data ) { + var elem = this[ 0 ]; + if ( elem ) { + return jQuery.event.trigger( type, data, elem, true ); + } + } +} ); + + +// Support: Firefox <=44 +// Firefox doesn't have focus(in | out) events +// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 +// +// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 +// focus(in | out) events fire after focus & blur events, +// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order +// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 +if ( !support.focusin ) { + jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) { + + // Attach a single capturing handler on the document while someone wants focusin/focusout + var handler = function( event ) { + jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); + }; + + jQuery.event.special[ fix ] = { + setup: function() { + var doc = this.ownerDocument || this, + attaches = dataPriv.access( doc, fix ); + + if ( !attaches ) { + doc.addEventListener( orig, handler, true ); + } + dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); + }, + teardown: function() { + var doc = this.ownerDocument || this, + attaches = dataPriv.access( doc, fix ) - 1; + + if ( !attaches ) { + doc.removeEventListener( orig, handler, true ); + dataPriv.remove( doc, fix ); + + } else { + dataPriv.access( doc, fix, attaches ); + } + } + }; + } ); +} +var location = window.location; + +var nonce = Date.now(); + +var rquery = ( /\?/ ); + + + +// Cross-browser xml parsing +jQuery.parseXML = function( data ) { + var xml; + if ( !data || typeof data !== "string" ) { + return null; + } + + // Support: IE 9 - 11 only + // IE throws on parseFromString with invalid input. + try { + xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); + } catch ( e ) { + xml = undefined; + } + + if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) { + jQuery.error( "Invalid XML: " + data ); + } + return xml; +}; + + +var + rbracket = /\[\]$/, + rCRLF = /\r?\n/g, + rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, + rsubmittable = /^(?:input|select|textarea|keygen)/i; + +function buildParams( prefix, obj, traditional, add ) { + var name; + + if ( Array.isArray( obj ) ) { + + // Serialize array item. + jQuery.each( obj, function( i, v ) { + if ( traditional || rbracket.test( prefix ) ) { + + // Treat each array item as a scalar. + add( prefix, v ); + + } else { + + // Item is non-scalar (array or object), encode its numeric index. + buildParams( + prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", + v, + traditional, + add + ); + } + } ); + + } else if ( !traditional && toType( obj ) === "object" ) { + + // Serialize object item. + for ( name in obj ) { + buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); + } + + } else { + + // Serialize scalar item. + add( prefix, obj ); + } +} + +// Serialize an array of form elements or a set of +// key/values into a query string +jQuery.param = function( a, traditional ) { + var prefix, + s = [], + add = function( key, valueOrFunction ) { + + // If value is a function, invoke it and use its return value + var value = isFunction( valueOrFunction ) ? + valueOrFunction() : + valueOrFunction; + + s[ s.length ] = encodeURIComponent( key ) + "=" + + encodeURIComponent( value == null ? "" : value ); + }; + + if ( a == null ) { + return ""; + } + + // If an array was passed in, assume that it is an array of form elements. + if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { + + // Serialize the form elements + jQuery.each( a, function() { + add( this.name, this.value ); + } ); + + } else { + + // If traditional, encode the "old" way (the way 1.3.2 or older + // did it), otherwise encode params recursively. + for ( prefix in a ) { + buildParams( prefix, a[ prefix ], traditional, add ); + } + } + + // Return the resulting serialization + return s.join( "&" ); +}; + +jQuery.fn.extend( { + serialize: function() { + return jQuery.param( this.serializeArray() ); + }, + serializeArray: function() { + return this.map( function() { + + // Can add propHook for "elements" to filter or add form elements + var elements = jQuery.prop( this, "elements" ); + return elements ? jQuery.makeArray( elements ) : this; + } ) + .filter( function() { + var type = this.type; + + // Use .is( ":disabled" ) so that fieldset[disabled] works + return this.name && !jQuery( this ).is( ":disabled" ) && + rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && + ( this.checked || !rcheckableType.test( type ) ); + } ) + .map( function( i, elem ) { + var val = jQuery( this ).val(); + + if ( val == null ) { + return null; + } + + if ( Array.isArray( val ) ) { + return jQuery.map( val, function( val ) { + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; + } ); + } + + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; + } ).get(); + } +} ); + + +var + r20 = /%20/g, + rhash = /#.*$/, + rantiCache = /([?&])_=[^&]*/, + rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, + + // #7653, #8125, #8152: local protocol detection + rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, + rnoContent = /^(?:GET|HEAD)$/, + rprotocol = /^\/\//, + + /* Prefilters + * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) + * 2) These are called: + * - BEFORE asking for a transport + * - AFTER param serialization (s.data is a string if s.processData is true) + * 3) key is the dataType + * 4) the catchall symbol "*" can be used + * 5) execution will start with transport dataType and THEN continue down to "*" if needed + */ + prefilters = {}, + + /* Transports bindings + * 1) key is the dataType + * 2) the catchall symbol "*" can be used + * 3) selection will start with transport dataType and THEN go to "*" if needed + */ + transports = {}, + + // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression + allTypes = "*/".concat( "*" ), + + // Anchor tag for parsing the document origin + originAnchor = document.createElement( "a" ); + originAnchor.href = location.href; + +// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport +function addToPrefiltersOrTransports( structure ) { + + // dataTypeExpression is optional and defaults to "*" + return function( dataTypeExpression, func ) { + + if ( typeof dataTypeExpression !== "string" ) { + func = dataTypeExpression; + dataTypeExpression = "*"; + } + + var dataType, + i = 0, + dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; + + if ( isFunction( func ) ) { + + // For each dataType in the dataTypeExpression + while ( ( dataType = dataTypes[ i++ ] ) ) { + + // Prepend if requested + if ( dataType[ 0 ] === "+" ) { + dataType = dataType.slice( 1 ) || "*"; + ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); + + // Otherwise append + } else { + ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); + } + } + } + }; +} + +// Base inspection function for prefilters and transports +function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { + + var inspected = {}, + seekingTransport = ( structure === transports ); + + function inspect( dataType ) { + var selected; + inspected[ dataType ] = true; + jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { + var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); + if ( typeof dataTypeOrTransport === "string" && + !seekingTransport && !inspected[ dataTypeOrTransport ] ) { + + options.dataTypes.unshift( dataTypeOrTransport ); + inspect( dataTypeOrTransport ); + return false; + } else if ( seekingTransport ) { + return !( selected = dataTypeOrTransport ); + } + } ); + return selected; + } + + return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); +} + +// A special extend for ajax options +// that takes "flat" options (not to be deep extended) +// Fixes #9887 +function ajaxExtend( target, src ) { + var key, deep, + flatOptions = jQuery.ajaxSettings.flatOptions || {}; + + for ( key in src ) { + if ( src[ key ] !== undefined ) { + ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; + } + } + if ( deep ) { + jQuery.extend( true, target, deep ); + } + + return target; +} + +/* Handles responses to an ajax request: + * - finds the right dataType (mediates between content-type and expected dataType) + * - returns the corresponding response + */ +function ajaxHandleResponses( s, jqXHR, responses ) { + + var ct, type, finalDataType, firstDataType, + contents = s.contents, + dataTypes = s.dataTypes; + + // Remove auto dataType and get content-type in the process + while ( dataTypes[ 0 ] === "*" ) { + dataTypes.shift(); + if ( ct === undefined ) { + ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); + } + } + + // Check if we're dealing with a known content-type + if ( ct ) { + for ( type in contents ) { + if ( contents[ type ] && contents[ type ].test( ct ) ) { + dataTypes.unshift( type ); + break; + } + } + } + + // Check to see if we have a response for the expected dataType + if ( dataTypes[ 0 ] in responses ) { + finalDataType = dataTypes[ 0 ]; + } else { + + // Try convertible dataTypes + for ( type in responses ) { + if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { + finalDataType = type; + break; + } + if ( !firstDataType ) { + firstDataType = type; + } + } + + // Or just use first one + finalDataType = finalDataType || firstDataType; + } + + // If we found a dataType + // We add the dataType to the list if needed + // and return the corresponding response + if ( finalDataType ) { + if ( finalDataType !== dataTypes[ 0 ] ) { + dataTypes.unshift( finalDataType ); + } + return responses[ finalDataType ]; + } +} + +/* Chain conversions given the request and the original response + * Also sets the responseXXX fields on the jqXHR instance + */ +function ajaxConvert( s, response, jqXHR, isSuccess ) { + var conv2, current, conv, tmp, prev, + converters = {}, + + // Work with a copy of dataTypes in case we need to modify it for conversion + dataTypes = s.dataTypes.slice(); + + // Create converters map with lowercased keys + if ( dataTypes[ 1 ] ) { + for ( conv in s.converters ) { + converters[ conv.toLowerCase() ] = s.converters[ conv ]; + } + } + + current = dataTypes.shift(); + + // Convert to each sequential dataType + while ( current ) { + + if ( s.responseFields[ current ] ) { + jqXHR[ s.responseFields[ current ] ] = response; + } + + // Apply the dataFilter if provided + if ( !prev && isSuccess && s.dataFilter ) { + response = s.dataFilter( response, s.dataType ); + } + + prev = current; + current = dataTypes.shift(); + + if ( current ) { + + // There's only work to do if current dataType is non-auto + if ( current === "*" ) { + + current = prev; + + // Convert response if prev dataType is non-auto and differs from current + } else if ( prev !== "*" && prev !== current ) { + + // Seek a direct converter + conv = converters[ prev + " " + current ] || converters[ "* " + current ]; + + // If none found, seek a pair + if ( !conv ) { + for ( conv2 in converters ) { + + // If conv2 outputs current + tmp = conv2.split( " " ); + if ( tmp[ 1 ] === current ) { + + // If prev can be converted to accepted input + conv = converters[ prev + " " + tmp[ 0 ] ] || + converters[ "* " + tmp[ 0 ] ]; + if ( conv ) { + + // Condense equivalence converters + if ( conv === true ) { + conv = converters[ conv2 ]; + + // Otherwise, insert the intermediate dataType + } else if ( converters[ conv2 ] !== true ) { + current = tmp[ 0 ]; + dataTypes.unshift( tmp[ 1 ] ); + } + break; + } + } + } + } + + // Apply converter (if not an equivalence) + if ( conv !== true ) { + + // Unless errors are allowed to bubble, catch and return them + if ( conv && s.throws ) { + response = conv( response ); + } else { + try { + response = conv( response ); + } catch ( e ) { + return { + state: "parsererror", + error: conv ? e : "No conversion from " + prev + " to " + current + }; + } + } + } + } + } + } + + return { state: "success", data: response }; +} + +jQuery.extend( { + + // Counter for holding the number of active queries + active: 0, + + // Last-Modified header cache for next request + lastModified: {}, + etag: {}, + + ajaxSettings: { + url: location.href, + type: "GET", + isLocal: rlocalProtocol.test( location.protocol ), + global: true, + processData: true, + async: true, + contentType: "application/x-www-form-urlencoded; charset=UTF-8", + + /* + timeout: 0, + data: null, + dataType: null, + username: null, + password: null, + cache: null, + throws: false, + traditional: false, + headers: {}, + */ + + accepts: { + "*": allTypes, + text: "text/plain", + html: "text/html", + xml: "application/xml, text/xml", + json: "application/json, text/javascript" + }, + + contents: { + xml: /\bxml\b/, + html: /\bhtml/, + json: /\bjson\b/ + }, + + responseFields: { + xml: "responseXML", + text: "responseText", + json: "responseJSON" + }, + + // Data converters + // Keys separate source (or catchall "*") and destination types with a single space + converters: { + + // Convert anything to text + "* text": String, + + // Text to html (true = no transformation) + "text html": true, + + // Evaluate text as a json expression + "text json": JSON.parse, + + // Parse text as xml + "text xml": jQuery.parseXML + }, + + // For options that shouldn't be deep extended: + // you can add your own custom options here if + // and when you create one that shouldn't be + // deep extended (see ajaxExtend) + flatOptions: { + url: true, + context: true + } + }, + + // Creates a full fledged settings object into target + // with both ajaxSettings and settings fields. + // If target is omitted, writes into ajaxSettings. + ajaxSetup: function( target, settings ) { + return settings ? + + // Building a settings object + ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : + + // Extending ajaxSettings + ajaxExtend( jQuery.ajaxSettings, target ); + }, + + ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), + ajaxTransport: addToPrefiltersOrTransports( transports ), + + // Main method + ajax: function( url, options ) { + + // If url is an object, simulate pre-1.5 signature + if ( typeof url === "object" ) { + options = url; + url = undefined; + } + + // Force options to be an object + options = options || {}; + + var transport, + + // URL without anti-cache param + cacheURL, + + // Response headers + responseHeadersString, + responseHeaders, + + // timeout handle + timeoutTimer, + + // Url cleanup var + urlAnchor, + + // Request state (becomes false upon send and true upon completion) + completed, + + // To know if global events are to be dispatched + fireGlobals, + + // Loop variable + i, + + // uncached part of the url + uncached, + + // Create the final options object + s = jQuery.ajaxSetup( {}, options ), + + // Callbacks context + callbackContext = s.context || s, + + // Context for global events is callbackContext if it is a DOM node or jQuery collection + globalEventContext = s.context && + ( callbackContext.nodeType || callbackContext.jquery ) ? + jQuery( callbackContext ) : + jQuery.event, + + // Deferreds + deferred = jQuery.Deferred(), + completeDeferred = jQuery.Callbacks( "once memory" ), + + // Status-dependent callbacks + statusCode = s.statusCode || {}, + + // Headers (they are sent all at once) + requestHeaders = {}, + requestHeadersNames = {}, + + // Default abort message + strAbort = "canceled", + + // Fake xhr + jqXHR = { + readyState: 0, + + // Builds headers hashtable if needed + getResponseHeader: function( key ) { + var match; + if ( completed ) { + if ( !responseHeaders ) { + responseHeaders = {}; + while ( ( match = rheaders.exec( responseHeadersString ) ) ) { + responseHeaders[ match[ 1 ].toLowerCase() + " " ] = + ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) + .concat( match[ 2 ] ); + } + } + match = responseHeaders[ key.toLowerCase() + " " ]; + } + return match == null ? null : match.join( ", " ); + }, + + // Raw string + getAllResponseHeaders: function() { + return completed ? responseHeadersString : null; + }, + + // Caches the header + setRequestHeader: function( name, value ) { + if ( completed == null ) { + name = requestHeadersNames[ name.toLowerCase() ] = + requestHeadersNames[ name.toLowerCase() ] || name; + requestHeaders[ name ] = value; + } + return this; + }, + + // Overrides response content-type header + overrideMimeType: function( type ) { + if ( completed == null ) { + s.mimeType = type; + } + return this; + }, + + // Status-dependent callbacks + statusCode: function( map ) { + var code; + if ( map ) { + if ( completed ) { + + // Execute the appropriate callbacks + jqXHR.always( map[ jqXHR.status ] ); + } else { + + // Lazy-add the new callbacks in a way that preserves old ones + for ( code in map ) { + statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; + } + } + } + return this; + }, + + // Cancel the request + abort: function( statusText ) { + var finalText = statusText || strAbort; + if ( transport ) { + transport.abort( finalText ); + } + done( 0, finalText ); + return this; + } + }; + + // Attach deferreds + deferred.promise( jqXHR ); + + // Add protocol if not provided (prefilters might expect it) + // Handle falsy url in the settings object (#10093: consistency with old signature) + // We also use the url parameter if available + s.url = ( ( url || s.url || location.href ) + "" ) + .replace( rprotocol, location.protocol + "//" ); + + // Alias method option to type as per ticket #12004 + s.type = options.method || options.type || s.method || s.type; + + // Extract dataTypes list + s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; + + // A cross-domain request is in order when the origin doesn't match the current origin. + if ( s.crossDomain == null ) { + urlAnchor = document.createElement( "a" ); + + // Support: IE <=8 - 11, Edge 12 - 15 + // IE throws exception on accessing the href property if url is malformed, + // e.g. http://example.com:80x/ + try { + urlAnchor.href = s.url; + + // Support: IE <=8 - 11 only + // Anchor's host property isn't correctly set when s.url is relative + urlAnchor.href = urlAnchor.href; + s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== + urlAnchor.protocol + "//" + urlAnchor.host; + } catch ( e ) { + + // If there is an error parsing the URL, assume it is crossDomain, + // it can be rejected by the transport if it is invalid + s.crossDomain = true; + } + } + + // Convert data if not already a string + if ( s.data && s.processData && typeof s.data !== "string" ) { + s.data = jQuery.param( s.data, s.traditional ); + } + + // Apply prefilters + inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); + + // If request was aborted inside a prefilter, stop there + if ( completed ) { + return jqXHR; + } + + // We can fire global events as of now if asked to + // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) + fireGlobals = jQuery.event && s.global; + + // Watch for a new set of requests + if ( fireGlobals && jQuery.active++ === 0 ) { + jQuery.event.trigger( "ajaxStart" ); + } + + // Uppercase the type + s.type = s.type.toUpperCase(); + + // Determine if request has content + s.hasContent = !rnoContent.test( s.type ); + + // Save the URL in case we're toying with the If-Modified-Since + // and/or If-None-Match header later on + // Remove hash to simplify url manipulation + cacheURL = s.url.replace( rhash, "" ); + + // More options handling for requests with no content + if ( !s.hasContent ) { + + // Remember the hash so we can put it back + uncached = s.url.slice( cacheURL.length ); + + // If data is available and should be processed, append data to url + if ( s.data && ( s.processData || typeof s.data === "string" ) ) { + cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; + + // #9682: remove data so that it's not used in an eventual retry + delete s.data; + } + + // Add or update anti-cache param if needed + if ( s.cache === false ) { + cacheURL = cacheURL.replace( rantiCache, "$1" ); + uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached; + } + + // Put hash and anti-cache on the URL that will be requested (gh-1732) + s.url = cacheURL + uncached; + + // Change '%20' to '+' if this is encoded form body content (gh-2658) + } else if ( s.data && s.processData && + ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { + s.data = s.data.replace( r20, "+" ); + } + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + if ( jQuery.lastModified[ cacheURL ] ) { + jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); + } + if ( jQuery.etag[ cacheURL ] ) { + jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); + } + } + + // Set the correct header, if data is being sent + if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { + jqXHR.setRequestHeader( "Content-Type", s.contentType ); + } + + // Set the Accepts header for the server, depending on the dataType + 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 + for ( i in s.headers ) { + jqXHR.setRequestHeader( i, s.headers[ i ] ); + } + + // Allow custom headers/mimetypes and early abort + if ( s.beforeSend && + ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { + + // Abort if not done already and return + return jqXHR.abort(); + } + + // Aborting is no longer a cancellation + strAbort = "abort"; + + // Install callbacks on deferreds + completeDeferred.add( s.complete ); + jqXHR.done( s.success ); + jqXHR.fail( s.error ); + + // Get transport + transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); + + // If no transport, we auto-abort + if ( !transport ) { + done( -1, "No Transport" ); + } else { + jqXHR.readyState = 1; + + // Send global event + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); + } + + // If request was aborted inside ajaxSend, stop there + if ( completed ) { + return jqXHR; + } + + // Timeout + if ( s.async && s.timeout > 0 ) { + timeoutTimer = window.setTimeout( function() { + jqXHR.abort( "timeout" ); + }, s.timeout ); + } + + try { + completed = false; + transport.send( requestHeaders, done ); + } catch ( e ) { + + // Rethrow post-completion exceptions + if ( completed ) { + throw e; + } + + // Propagate others as results + done( -1, e ); + } + } + + // Callback for when everything is done + function done( status, nativeStatusText, responses, headers ) { + var isSuccess, success, error, response, modified, + statusText = nativeStatusText; + + // Ignore repeat invocations + if ( completed ) { + return; + } + + completed = true; + + // Clear timeout if it exists + if ( timeoutTimer ) { + window.clearTimeout( timeoutTimer ); + } + + // Dereference transport for early garbage collection + // (no matter how long the jqXHR object will be used) + transport = undefined; + + // Cache response headers + responseHeadersString = headers || ""; + + // Set readyState + jqXHR.readyState = status > 0 ? 4 : 0; + + // Determine if successful + isSuccess = status >= 200 && status < 300 || status === 304; + + // Get response data + if ( responses ) { + response = ajaxHandleResponses( s, jqXHR, responses ); + } + + // Convert no matter what (that way responseXXX fields are always set) + response = ajaxConvert( s, response, jqXHR, isSuccess ); + + // If successful, handle type chaining + if ( isSuccess ) { + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + modified = jqXHR.getResponseHeader( "Last-Modified" ); + if ( modified ) { + jQuery.lastModified[ cacheURL ] = modified; + } + modified = jqXHR.getResponseHeader( "etag" ); + if ( modified ) { + jQuery.etag[ cacheURL ] = modified; + } + } + + // if no content + if ( status === 204 || s.type === "HEAD" ) { + statusText = "nocontent"; + + // if not modified + } else if ( status === 304 ) { + statusText = "notmodified"; + + // If we have data, let's convert it + } else { + statusText = response.state; + success = response.data; + error = response.error; + isSuccess = !error; + } + } else { + + // Extract error from statusText and normalize for non-aborts + error = statusText; + if ( status || !statusText ) { + statusText = "error"; + if ( status < 0 ) { + status = 0; + } + } + } + + // Set data for the fake xhr object + jqXHR.status = status; + jqXHR.statusText = ( nativeStatusText || statusText ) + ""; + + // Success/Error + if ( isSuccess ) { + deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); + } else { + deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); + } + + // Status-dependent callbacks + jqXHR.statusCode( statusCode ); + statusCode = undefined; + + if ( fireGlobals ) { + globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", + [ jqXHR, s, isSuccess ? success : error ] ); + } + + // Complete + completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); + + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); + + // Handle the global AJAX counter + if ( !( --jQuery.active ) ) { + jQuery.event.trigger( "ajaxStop" ); + } + } + } + + return jqXHR; + }, + + getJSON: function( url, data, callback ) { + return jQuery.get( url, data, callback, "json" ); + }, + + getScript: function( url, callback ) { + return jQuery.get( url, undefined, callback, "script" ); + } +} ); + +jQuery.each( [ "get", "post" ], function( i, method ) { + jQuery[ method ] = function( url, data, callback, type ) { + + // Shift arguments if data argument was omitted + if ( isFunction( data ) ) { + type = type || callback; + callback = data; + data = undefined; + } + + // The url can be an options object (which then must have .url) + return jQuery.ajax( jQuery.extend( { + url: url, + type: method, + dataType: type, + data: data, + success: callback + }, jQuery.isPlainObject( url ) && url ) ); + }; +} ); + + +jQuery._evalUrl = function( url, options ) { + return jQuery.ajax( { + url: url, + + // Make this explicit, since user can override this through ajaxSetup (#11264) + type: "GET", + dataType: "script", + cache: true, + async: false, + global: false, + + // Only evaluate the response if it is successful (gh-4126) + // dataFilter is not invoked for failure responses, so using it instead + // of the default converter is kludgy but it works. + converters: { + "text script": function() {} + }, + dataFilter: function( response ) { + jQuery.globalEval( response, options ); + } + } ); +}; + + +jQuery.fn.extend( { + wrapAll: function( html ) { + var wrap; + + if ( this[ 0 ] ) { + if ( isFunction( html ) ) { + html = html.call( this[ 0 ] ); + } + + // The elements to wrap the target around + wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); + + if ( this[ 0 ].parentNode ) { + wrap.insertBefore( this[ 0 ] ); + } + + wrap.map( function() { + var elem = this; + + while ( elem.firstElementChild ) { + elem = elem.firstElementChild; + } + + return elem; + } ).append( this ); + } + + return this; + }, + + wrapInner: function( html ) { + if ( isFunction( html ) ) { + return this.each( function( i ) { + jQuery( this ).wrapInner( html.call( this, i ) ); + } ); + } + + return this.each( function() { + var self = jQuery( this ), + contents = self.contents(); + + if ( contents.length ) { + contents.wrapAll( html ); + + } else { + self.append( html ); + } + } ); + }, + + wrap: function( html ) { + var htmlIsFunction = isFunction( html ); + + return this.each( function( i ) { + jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); + } ); + }, + + unwrap: function( selector ) { + this.parent( selector ).not( "body" ).each( function() { + jQuery( this ).replaceWith( this.childNodes ); + } ); + return this; + } +} ); + + +jQuery.expr.pseudos.hidden = function( elem ) { + return !jQuery.expr.pseudos.visible( elem ); +}; +jQuery.expr.pseudos.visible = function( elem ) { + return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); +}; + + + + +jQuery.ajaxSettings.xhr = function() { + try { + return new window.XMLHttpRequest(); + } catch ( e ) {} +}; + +var xhrSuccessStatus = { + + // File protocol always yields status code 0, assume 200 + 0: 200, + + // Support: IE <=9 only + // #1450: sometimes IE returns 1223 when it should be 204 + 1223: 204 + }, + xhrSupported = jQuery.ajaxSettings.xhr(); + +support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); +support.ajax = xhrSupported = !!xhrSupported; + +jQuery.ajaxTransport( function( options ) { + var callback, errorCallback; + + // Cross domain only allowed if supported through XMLHttpRequest + if ( support.cors || xhrSupported && !options.crossDomain ) { + return { + send: function( headers, complete ) { + var i, + xhr = options.xhr(); + + xhr.open( + options.type, + options.url, + options.async, + options.username, + options.password + ); + + // Apply custom fields if provided + if ( options.xhrFields ) { + for ( i in options.xhrFields ) { + xhr[ i ] = options.xhrFields[ i ]; + } + } + + // Override mime type if needed + if ( options.mimeType && xhr.overrideMimeType ) { + xhr.overrideMimeType( options.mimeType ); + } + + // X-Requested-With header + // For cross-domain requests, seeing as conditions for a preflight are + // akin to a jigsaw puzzle, we simply never set it to be sure. + // (it can always be set on a per-request basis or even using ajaxSetup) + // For same-domain requests, won't change header if already provided. + if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { + headers[ "X-Requested-With" ] = "XMLHttpRequest"; + } + + // Set headers + for ( i in headers ) { + xhr.setRequestHeader( i, headers[ i ] ); + } + + // Callback + callback = function( type ) { + return function() { + if ( callback ) { + callback = errorCallback = xhr.onload = + xhr.onerror = xhr.onabort = xhr.ontimeout = + xhr.onreadystatechange = null; + + if ( type === "abort" ) { + xhr.abort(); + } else if ( type === "error" ) { + + // Support: IE <=9 only + // On a manual native abort, IE9 throws + // errors on any property access that is not readyState + if ( typeof xhr.status !== "number" ) { + complete( 0, "error" ); + } else { + complete( + + // File: protocol always yields status 0; see #8605, #14207 + xhr.status, + xhr.statusText + ); + } + } else { + complete( + xhrSuccessStatus[ xhr.status ] || xhr.status, + xhr.statusText, + + // Support: IE <=9 only + // IE9 has no XHR2 but throws on binary (trac-11426) + // For XHR2 non-text, let the caller handle it (gh-2498) + ( xhr.responseType || "text" ) !== "text" || + typeof xhr.responseText !== "string" ? + { binary: xhr.response } : + { text: xhr.responseText }, + xhr.getAllResponseHeaders() + ); + } + } + }; + }; + + // Listen to events + xhr.onload = callback(); + errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); + + // Support: IE 9 only + // Use onreadystatechange to replace onabort + // to handle uncaught aborts + if ( xhr.onabort !== undefined ) { + xhr.onabort = errorCallback; + } else { + xhr.onreadystatechange = function() { + + // Check readyState before timeout as it changes + if ( xhr.readyState === 4 ) { + + // Allow onerror to be called first, + // but that will not handle a native abort + // Also, save errorCallback to a variable + // as xhr.onerror cannot be accessed + window.setTimeout( function() { + if ( callback ) { + errorCallback(); + } + } ); + } + }; + } + + // Create the abort callback + callback = callback( "abort" ); + + try { + + // Do send the request (this may raise an exception) + xhr.send( options.hasContent && options.data || null ); + } catch ( e ) { + + // #14683: Only rethrow if this hasn't been notified as an error yet + if ( callback ) { + throw e; + } + } + }, + + abort: function() { + if ( callback ) { + callback(); + } + } + }; + } +} ); + + + + +// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) +jQuery.ajaxPrefilter( function( s ) { + if ( s.crossDomain ) { + s.contents.script = false; + } +} ); + +// Install script dataType +jQuery.ajaxSetup( { + accepts: { + script: "text/javascript, application/javascript, " + + "application/ecmascript, application/x-ecmascript" + }, + contents: { + script: /\b(?:java|ecma)script\b/ + }, + converters: { + "text script": function( text ) { + jQuery.globalEval( text ); + return text; + } + } +} ); + +// Handle cache's special case and crossDomain +jQuery.ajaxPrefilter( "script", function( s ) { + if ( s.cache === undefined ) { + s.cache = false; + } + if ( s.crossDomain ) { + s.type = "GET"; + } +} ); + +// Bind script tag hack transport +jQuery.ajaxTransport( "script", function( s ) { + + // This transport only deals with cross domain or forced-by-attrs requests + if ( s.crossDomain || s.scriptAttrs ) { + var script, callback; + return { + send: function( _, complete ) { + script = jQuery( " @@ -163,10 +409,56 @@ - + + + + + + \ No newline at end of file diff --git a/admin/list_produk.html b/admin/list_produk.html new file mode 100644 index 0000000..6004bcd --- /dev/null +++ b/admin/list_produk.html @@ -0,0 +1,464 @@ + + + + + Halaman List Produk - Admin + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
HexaBit +
+

Loading...

+
+
+ +
+ +
+ + + + + + +
+
+
+
+

Halaman List Produk

+
+
+
    +
    • +
  • Halaman List Produk
    • +
+
+
+
+ +
+ + +
+
+
+
+

List ProdukMasukkan Kode @ Nama Produk Pada Search Jika Ingin + Mencari Produk +

+ +
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
KodeNamaStokHarga PenjualanAksi
A4567Adidas Merah15Rp. 50,000 + +   + + + + +
A5678Adidas Putih15Rp. 50,000 + +   + + + + +
A6789Adidas Hijau15Rp. 50,000 + +   + + + + +
+
+
+
+
+ +
+ + +
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/admin/penambahan_produk.html b/admin/penambahan_produk.html new file mode 100644 index 0000000..a9161bd --- /dev/null +++ b/admin/penambahan_produk.html @@ -0,0 +1,262 @@ + + + + + Halaman Penambahan Produk Baru - Admin + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
HexaBit +
+

Loading...

+
+
+ +
+ +
+ + + + + + +
+
+
+
+

Halaman Penambahan Produk Baru

+
+
+
    +
    • +
  • Halaman Penambahan Produk Baru
    • +
+
+
+
+ +
+ + +
+
+ +
+
+
+
+ + +
+
+ + +
+ +
+ + +
+ +
+ +
+
+ Rp. +
+ +
+
+ +
+ + +
+ +
+ +
+
+ Rp. +
+ +
+
+ +
+ +
+
+
+
+ +
+
+ + + +
+
+ +
+ + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/admin/template_assets/images/baju/contoh_baju.jpg b/admin/template_assets/images/baju/contoh_baju.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1afdaeca03f77cc51c848866be0c84782ed0c74c GIT binary patch literal 19838 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%0DIlk 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 YoH7ogWuyUFL%GZox4hwz^6Sn20bR~;DgXcg literal 0 HcmV?d00001 diff --git a/admin/template_assets/images/baju/lightbox2-2.11.3.zip b/admin/template_assets/images/baju/lightbox2-2.11.3.zip new file mode 100644 index 0000000000000000000000000000000000000000..641dda3d48df20902089050e6873b9de3feac985 GIT binary patch literal 237610 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�=OB_A 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

bG@r5BD{1Mwft+fZ9YxWrL>>yf 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 Npcm~pI literal 0 HcmV?d00001 diff --git a/admin/template_assets/vendor/sweetalert/sweetalert-dev.js b/admin/template_assets/vendor/sweetalert/sweetalert-dev.js deleted file mode 100644 index 7e294b8..0000000 --- a/admin/template_assets/vendor/sweetalert/sweetalert-dev.js +++ /dev/null @@ -1,1285 +0,0 @@ -;(function(window, document, undefined) { - "use strict"; - - (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o call showInputError with errorMessage - */ -sweetAlert.showInputError = swal.showInputError = function (errorMessage) { - var modal = _sweetAlertInitialize$getModal$getOverlay$getInput$setFocusStyle$openModal$resetInput$fixVerticalPosition.getModal(); - - var $errorIcon = modal.querySelector('.sa-input-error'); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide$isDescendant$getTopMargin$fadeIn$fadeOut$fireClick$stopEventPropagation.addClass($errorIcon, 'show'); - - var $errorContainer = modal.querySelector('.sa-error-container'); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide$isDescendant$getTopMargin$fadeIn$fadeOut$fireClick$stopEventPropagation.addClass($errorContainer, 'show'); - - $errorContainer.querySelector('p').innerHTML = errorMessage; - - setTimeout(function () { - sweetAlert.enableButtons(); - }, 1); - - modal.querySelector('input').focus(); -}; - -/* - * Reset input error DOM elements - */ -sweetAlert.resetInputError = swal.resetInputError = function (event) { - // If press enter => ignore - if (event && event.keyCode === 13) { - return false; - } - - var $modal = _sweetAlertInitialize$getModal$getOverlay$getInput$setFocusStyle$openModal$resetInput$fixVerticalPosition.getModal(); - - var $errorIcon = $modal.querySelector('.sa-input-error'); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide$isDescendant$getTopMargin$fadeIn$fadeOut$fireClick$stopEventPropagation.removeClass($errorIcon, 'show'); - - var $errorContainer = $modal.querySelector('.sa-error-container'); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide$isDescendant$getTopMargin$fadeIn$fadeOut$fireClick$stopEventPropagation.removeClass($errorContainer, 'show'); -}; - -/* - * Disable confirm and cancel buttons - */ -sweetAlert.disableButtons = swal.disableButtons = function (event) { - var modal = _sweetAlertInitialize$getModal$getOverlay$getInput$setFocusStyle$openModal$resetInput$fixVerticalPosition.getModal(); - var $confirmButton = modal.querySelector('button.confirm'); - var $cancelButton = modal.querySelector('button.cancel'); - $confirmButton.disabled = true; - $cancelButton.disabled = true; -}; - -/* - * Enable confirm and cancel buttons - */ -sweetAlert.enableButtons = swal.enableButtons = function (event) { - var modal = _sweetAlertInitialize$getModal$getOverlay$getInput$setFocusStyle$openModal$resetInput$fixVerticalPosition.getModal(); - var $confirmButton = modal.querySelector('button.confirm'); - var $cancelButton = modal.querySelector('button.cancel'); - $confirmButton.disabled = false; - $cancelButton.disabled = false; -}; - -if (typeof window !== 'undefined') { - // The 'handle-click' module requires - // that 'sweetAlert' was set as global. - window.sweetAlert = window.swal = sweetAlert; -} else { - _extend$hexToRgb$isIE8$logStr$colorLuminance.logStr('SweetAlert is a frontend module!'); -} -module.exports = exports['default']; - -},{"./modules/default-params":2,"./modules/handle-click":3,"./modules/handle-dom":4,"./modules/handle-key":5,"./modules/handle-swal-dom":6,"./modules/set-params":8,"./modules/utils":9}],2:[function(require,module,exports){ -'use strict'; - -Object.defineProperty(exports, '__esModule', { - value: true -}); -var defaultParams = { - title: '', - text: '', - type: null, - allowOutsideClick: false, - showConfirmButton: true, - showCancelButton: false, - closeOnConfirm: true, - closeOnCancel: true, - confirmButtonText: 'OK', - confirmButtonColor: '#8CD4F5', - cancelButtonText: 'Cancel', - imageUrl: null, - imageSize: null, - timer: null, - customClass: '', - html: false, - animation: true, - allowEscapeKey: true, - inputType: 'text', - inputPlaceholder: '', - inputValue: '', - showLoaderOnConfirm: false -}; - -exports['default'] = defaultParams; -module.exports = exports['default']; - -},{}],3:[function(require,module,exports){ -'use strict'; - -Object.defineProperty(exports, '__esModule', { - value: true -}); - -var _colorLuminance = require('./utils'); - -var _getModal = require('./handle-swal-dom'); - -var _hasClass$isDescendant = require('./handle-dom'); - -/* - * User clicked on "Confirm"/"OK" or "Cancel" - */ -var handleButton = function handleButton(event, params, modal) { - var e = event || window.event; - var target = e.target || e.srcElement; - - var targetedConfirm = target.className.indexOf('confirm') !== -1; - var targetedOverlay = target.className.indexOf('sweet-overlay') !== -1; - var modalIsVisible = _hasClass$isDescendant.hasClass(modal, 'visible'); - var doneFunctionExists = params.doneFunction && modal.getAttribute('data-has-done-function') === 'true'; - - // Since the user can change the background-color of the confirm button programmatically, - // we must calculate what the color should be on hover/active - var normalColor, hoverColor, activeColor; - if (targetedConfirm && params.confirmButtonColor) { - normalColor = params.confirmButtonColor; - hoverColor = _colorLuminance.colorLuminance(normalColor, -0.04); - activeColor = _colorLuminance.colorLuminance(normalColor, -0.14); - } - - function shouldSetConfirmButtonColor(color) { - if (targetedConfirm && params.confirmButtonColor) { - target.style.backgroundColor = color; - } - } - - switch (e.type) { - case 'mouseover': - shouldSetConfirmButtonColor(hoverColor); - break; - - case 'mouseout': - shouldSetConfirmButtonColor(normalColor); - break; - - case 'mousedown': - shouldSetConfirmButtonColor(activeColor); - break; - - case 'mouseup': - shouldSetConfirmButtonColor(hoverColor); - break; - - case 'focus': - var $confirmButton = modal.querySelector('button.confirm'); - var $cancelButton = modal.querySelector('button.cancel'); - - if (targetedConfirm) { - $cancelButton.style.boxShadow = 'none'; - } else { - $confirmButton.style.boxShadow = 'none'; - } - break; - - case 'click': - var clickedOnModal = modal === target; - var clickedOnModalChild = _hasClass$isDescendant.isDescendant(modal, target); - - // Ignore click outside if allowOutsideClick is false - if (!clickedOnModal && !clickedOnModalChild && modalIsVisible && !params.allowOutsideClick) { - break; - } - - if (targetedConfirm && doneFunctionExists && modalIsVisible) { - handleConfirm(modal, params); - } else if (doneFunctionExists && modalIsVisible || targetedOverlay) { - handleCancel(modal, params); - } else if (_hasClass$isDescendant.isDescendant(modal, target) && target.tagName === 'BUTTON') { - sweetAlert.close(); - } - break; - } -}; - -/* - * User clicked on "Confirm"/"OK" - */ -var handleConfirm = function handleConfirm(modal, params) { - var callbackValue = true; - - if (_hasClass$isDescendant.hasClass(modal, 'show-input')) { - callbackValue = modal.querySelector('input').value; - - if (!callbackValue) { - callbackValue = ''; - } - } - - params.doneFunction(callbackValue); - - if (params.closeOnConfirm) { - sweetAlert.close(); - } - // Disable cancel and confirm button if the parameter is true - if (params.showLoaderOnConfirm) { - sweetAlert.disableButtons(); - } -}; - -/* - * User clicked on "Cancel" - */ -var handleCancel = function handleCancel(modal, params) { - // Check if callback function expects a parameter (to track cancel actions) - var functionAsStr = String(params.doneFunction).replace(/\s/g, ''); - var functionHandlesCancel = functionAsStr.substring(0, 9) === 'function(' && functionAsStr.substring(9, 10) !== ')'; - - if (functionHandlesCancel) { - params.doneFunction(false); - } - - if (params.closeOnCancel) { - sweetAlert.close(); - } -}; - -exports['default'] = { - handleButton: handleButton, - handleConfirm: handleConfirm, - handleCancel: handleCancel -}; -module.exports = exports['default']; - -},{"./handle-dom":4,"./handle-swal-dom":6,"./utils":9}],4:[function(require,module,exports){ -'use strict'; - -Object.defineProperty(exports, '__esModule', { - value: true -}); -var hasClass = function hasClass(elem, className) { - return new RegExp(' ' + className + ' ').test(' ' + elem.className + ' '); -}; - -var addClass = function addClass(elem, className) { - if (!hasClass(elem, className)) { - elem.className += ' ' + className; - } -}; - -var removeClass = function removeClass(elem, className) { - var newClass = ' ' + elem.className.replace(/[\t\r\n]/g, ' ') + ' '; - if (hasClass(elem, className)) { - while (newClass.indexOf(' ' + className + ' ') >= 0) { - newClass = newClass.replace(' ' + className + ' ', ' '); - } - elem.className = newClass.replace(/^\s+|\s+$/g, ''); - } -}; - -var escapeHtml = function escapeHtml(str) { - var div = document.createElement('div'); - div.appendChild(document.createTextNode(str)); - return div.innerHTML; -}; - -var _show = function _show(elem) { - elem.style.opacity = ''; - elem.style.display = 'block'; -}; - -var show = function show(elems) { - if (elems && !elems.length) { - return _show(elems); - } - for (var i = 0; i < elems.length; ++i) { - _show(elems[i]); - } -}; - -var _hide = function _hide(elem) { - elem.style.opacity = ''; - elem.style.display = 'none'; -}; - -var hide = function hide(elems) { - if (elems && !elems.length) { - return _hide(elems); - } - for (var i = 0; i < elems.length; ++i) { - _hide(elems[i]); - } -}; - -var isDescendant = function isDescendant(parent, child) { - var node = child.parentNode; - while (node !== null) { - if (node === parent) { - return true; - } - node = node.parentNode; - } - return false; -}; - -var getTopMargin = function getTopMargin(elem) { - elem.style.left = '-9999px'; - elem.style.display = 'block'; - - var height = elem.clientHeight, - padding; - if (typeof getComputedStyle !== 'undefined') { - // IE 8 - padding = parseInt(getComputedStyle(elem).getPropertyValue('padding-top'), 10); - } else { - padding = parseInt(elem.currentStyle.padding); - } - - elem.style.left = ''; - elem.style.display = 'none'; - return '-' + parseInt((height + padding) / 2) + 'px'; -}; - -var fadeIn = function fadeIn(elem, interval) { - if (+elem.style.opacity < 1) { - interval = interval || 16; - elem.style.opacity = 0; - elem.style.display = 'block'; - var last = +new Date(); - var tick = (function (_tick) { - function tick() { - return _tick.apply(this, arguments); - } - - tick.toString = function () { - return _tick.toString(); - }; - - return tick; - })(function () { - elem.style.opacity = +elem.style.opacity + (new Date() - last) / 100; - last = +new Date(); - - if (+elem.style.opacity < 1) { - setTimeout(tick, interval); - } - }); - tick(); - } - elem.style.display = 'block'; //fallback IE8 -}; - -var fadeOut = function fadeOut(elem, interval) { - interval = interval || 16; - elem.style.opacity = 1; - var last = +new Date(); - var tick = (function (_tick2) { - function tick() { - return _tick2.apply(this, arguments); - } - - tick.toString = function () { - return _tick2.toString(); - }; - - return tick; - })(function () { - elem.style.opacity = +elem.style.opacity - (new Date() - last) / 100; - last = +new Date(); - - if (+elem.style.opacity > 0) { - setTimeout(tick, interval); - } else { - elem.style.display = 'none'; - } - }); - tick(); -}; - -var fireClick = function fireClick(node) { - // Taken from http://www.nonobtrusive.com/2011/11/29/programatically-fire-crossbrowser-click-event-with-javascript/ - // Then fixed for today's Chrome browser. - if (typeof MouseEvent === 'function') { - // Up-to-date approach - var mevt = new MouseEvent('click', { - view: window, - bubbles: false, - cancelable: true - }); - node.dispatchEvent(mevt); - } else if (document.createEvent) { - // Fallback - var evt = document.createEvent('MouseEvents'); - evt.initEvent('click', false, false); - node.dispatchEvent(evt); - } else if (document.createEventObject) { - node.fireEvent('onclick'); - } else if (typeof node.onclick === 'function') { - node.onclick(); - } -}; - -var stopEventPropagation = function stopEventPropagation(e) { - // In particular, make sure the space bar doesn't scroll the main window. - if (typeof e.stopPropagation === 'function') { - e.stopPropagation(); - e.preventDefault(); - } else if (window.event && window.event.hasOwnProperty('cancelBubble')) { - window.event.cancelBubble = true; - } -}; - -exports.hasClass = hasClass; -exports.addClass = addClass; -exports.removeClass = removeClass; -exports.escapeHtml = escapeHtml; -exports._show = _show; -exports.show = show; -exports._hide = _hide; -exports.hide = hide; -exports.isDescendant = isDescendant; -exports.getTopMargin = getTopMargin; -exports.fadeIn = fadeIn; -exports.fadeOut = fadeOut; -exports.fireClick = fireClick; -exports.stopEventPropagation = stopEventPropagation; - -},{}],5:[function(require,module,exports){ -'use strict'; - -Object.defineProperty(exports, '__esModule', { - value: true -}); - -var _stopEventPropagation$fireClick = require('./handle-dom'); - -var _setFocusStyle = require('./handle-swal-dom'); - -var handleKeyDown = function handleKeyDown(event, params, modal) { - var e = event || window.event; - var keyCode = e.keyCode || e.which; - - var $okButton = modal.querySelector('button.confirm'); - var $cancelButton = modal.querySelector('button.cancel'); - var $modalButtons = modal.querySelectorAll('button[tabindex]'); - - if ([9, 13, 32, 27].indexOf(keyCode) === -1) { - // Don't do work on keys we don't care about. - return; - } - - var $targetElement = e.target || e.srcElement; - - var btnIndex = -1; // Find the button - note, this is a nodelist, not an array. - for (var i = 0; i < $modalButtons.length; i++) { - if ($targetElement === $modalButtons[i]) { - btnIndex = i; - break; - } - } - - if (keyCode === 9) { - // TAB - if (btnIndex === -1) { - // No button focused. Jump to the confirm button. - $targetElement = $okButton; - } else { - // Cycle to the next button - if (btnIndex === $modalButtons.length - 1) { - $targetElement = $modalButtons[0]; - } else { - $targetElement = $modalButtons[btnIndex + 1]; - } - } - - _stopEventPropagation$fireClick.stopEventPropagation(e); - $targetElement.focus(); - - if (params.confirmButtonColor) { - _setFocusStyle.setFocusStyle($targetElement, params.confirmButtonColor); - } - } else { - if (keyCode === 13) { - if ($targetElement.tagName === 'INPUT') { - $targetElement = $okButton; - $okButton.focus(); - } - - if (btnIndex === -1) { - // ENTER/SPACE clicked outside of a button. - $targetElement = $okButton; - } else { - // Do nothing - let the browser handle it. - $targetElement = undefined; - } - } else if (keyCode === 27 && params.allowEscapeKey === true) { - $targetElement = $cancelButton; - _stopEventPropagation$fireClick.fireClick($targetElement, e); - } else { - // Fallback - let the browser handle it. - $targetElement = undefined; - } - } -}; - -exports['default'] = handleKeyDown; -module.exports = exports['default']; - -},{"./handle-dom":4,"./handle-swal-dom":6}],6:[function(require,module,exports){ -'use strict'; - -var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }; - -Object.defineProperty(exports, '__esModule', { - value: true -}); - -var _hexToRgb = require('./utils'); - -var _removeClass$getTopMargin$fadeIn$show$addClass = require('./handle-dom'); - -var _defaultParams = require('./default-params'); - -var _defaultParams2 = _interopRequireWildcard(_defaultParams); - -/* - * Add modal + overlay to DOM - */ - -var _injectedHTML = require('./injected-html'); - -var _injectedHTML2 = _interopRequireWildcard(_injectedHTML); - -var modalClass = '.sweet-alert'; -var overlayClass = '.sweet-overlay'; - -var sweetAlertInitialize = function sweetAlertInitialize() { - var sweetWrap = document.createElement('div'); - sweetWrap.innerHTML = _injectedHTML2['default']; - - // Append elements to body - while (sweetWrap.firstChild) { - document.body.appendChild(sweetWrap.firstChild); - } -}; - -/* - * Get DOM element of modal - */ -var getModal = (function (_getModal) { - function getModal() { - return _getModal.apply(this, arguments); - } - - getModal.toString = function () { - return _getModal.toString(); - }; - - return getModal; -})(function () { - var $modal = document.querySelector(modalClass); - - if (!$modal) { - sweetAlertInitialize(); - $modal = getModal(); - } - - return $modal; -}); - -/* - * Get DOM element of input (in modal) - */ -var getInput = function getInput() { - var $modal = getModal(); - if ($modal) { - return $modal.querySelector('input'); - } -}; - -/* - * Get DOM element of overlay - */ -var getOverlay = function getOverlay() { - return document.querySelector(overlayClass); -}; - -/* - * Add box-shadow style to button (depending on its chosen bg-color) - */ -var setFocusStyle = function setFocusStyle($button, bgColor) { - var rgbColor = _hexToRgb.hexToRgb(bgColor); - $button.style.boxShadow = '0 0 2px rgba(' + rgbColor + ', 0.8), inset 0 0 0 1px rgba(0, 0, 0, 0.05)'; -}; - -/* - * Animation when opening modal - */ -var openModal = function openModal(callback) { - var $modal = getModal(); - _removeClass$getTopMargin$fadeIn$show$addClass.fadeIn(getOverlay(), 10); - _removeClass$getTopMargin$fadeIn$show$addClass.show($modal); - _removeClass$getTopMargin$fadeIn$show$addClass.addClass($modal, 'showSweetAlert'); - _removeClass$getTopMargin$fadeIn$show$addClass.removeClass($modal, 'hideSweetAlert'); - - window.previousActiveElement = document.activeElement; - var $okButton = $modal.querySelector('button.confirm'); - $okButton.focus(); - - setTimeout(function () { - _removeClass$getTopMargin$fadeIn$show$addClass.addClass($modal, 'visible'); - }, 500); - - var timer = $modal.getAttribute('data-timer'); - - if (timer !== 'null' && timer !== '') { - var timerCallback = callback; - $modal.timeout = setTimeout(function () { - var doneFunctionExists = (timerCallback || null) && $modal.getAttribute('data-has-done-function') === 'true'; - if (doneFunctionExists) { - timerCallback(null); - } else { - sweetAlert.close(); - } - }, timer); - } -}; - -/* - * Reset the styling of the input - * (for example if errors have been shown) - */ -var resetInput = function resetInput() { - var $modal = getModal(); - var $input = getInput(); - - _removeClass$getTopMargin$fadeIn$show$addClass.removeClass($modal, 'show-input'); - $input.value = _defaultParams2['default'].inputValue; - $input.setAttribute('type', _defaultParams2['default'].inputType); - $input.setAttribute('placeholder', _defaultParams2['default'].inputPlaceholder); - - resetInputError(); -}; - -var resetInputError = function resetInputError(event) { - // If press enter => ignore - if (event && event.keyCode === 13) { - return false; - } - - var $modal = getModal(); - - var $errorIcon = $modal.querySelector('.sa-input-error'); - _removeClass$getTopMargin$fadeIn$show$addClass.removeClass($errorIcon, 'show'); - - var $errorContainer = $modal.querySelector('.sa-error-container'); - _removeClass$getTopMargin$fadeIn$show$addClass.removeClass($errorContainer, 'show'); -}; - -/* - * Set "margin-top"-property on modal based on its computed height - */ -var fixVerticalPosition = function fixVerticalPosition() { - var $modal = getModal(); - $modal.style.marginTop = _removeClass$getTopMargin$fadeIn$show$addClass.getTopMargin(getModal()); -}; - -exports.sweetAlertInitialize = sweetAlertInitialize; -exports.getModal = getModal; -exports.getOverlay = getOverlay; -exports.getInput = getInput; -exports.setFocusStyle = setFocusStyle; -exports.openModal = openModal; -exports.resetInput = resetInput; -exports.resetInputError = resetInputError; -exports.fixVerticalPosition = fixVerticalPosition; - -},{"./default-params":2,"./handle-dom":4,"./injected-html":7,"./utils":9}],7:[function(require,module,exports){ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -var injectedHTML = - -// Dark overlay -"

" + - -// Modal -"
" + - -// Error icon -"
\n \n \n \n \n
" + - -// Warning icon -"
\n \n \n
" + - -// Info icon -"
" + - -// Success icon -"
\n \n \n\n
\n
\n
" + "
" + - -// Title, text and input -"

Title

\n

Text

\n
\n \n
\n
" + - -// Input errors -"
\n
!
\n

Not valid!

\n
" + - -// Cancel and confirm buttons -"
\n \n
\n " + - -// Loading animation -"
\n
\n
\n
\n
\n
\n
" + - -// End of modal -"
"; - -exports["default"] = injectedHTML; -module.exports = exports["default"]; - -},{}],8:[function(require,module,exports){ -'use strict'; - -Object.defineProperty(exports, '__esModule', { - value: true -}); - -var _isIE8 = require('./utils'); - -var _getModal$getInput$setFocusStyle = require('./handle-swal-dom'); - -var _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide = require('./handle-dom'); - -var alertTypes = ['error', 'warning', 'info', 'success', 'input', 'prompt']; - -/* - * Set type, text and actions on modal - */ -var setParameters = function setParameters(params) { - var modal = _getModal$getInput$setFocusStyle.getModal(); - - var $title = modal.querySelector('h2'); - var $text = modal.querySelector('p'); - var $cancelBtn = modal.querySelector('button.cancel'); - var $confirmBtn = modal.querySelector('button.confirm'); - - /* - * Title - */ - $title.innerHTML = params.html ? params.title : _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.escapeHtml(params.title).split('\n').join('
'); - - /* - * Text - */ - $text.innerHTML = params.html ? params.text : _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.escapeHtml(params.text || '').split('\n').join('
'); - if (params.text) _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.show($text); - - /* - * Custom class - */ - if (params.customClass) { - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.addClass(modal, params.customClass); - modal.setAttribute('data-custom-class', params.customClass); - } else { - // Find previously set classes and remove them - var customClass = modal.getAttribute('data-custom-class'); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.removeClass(modal, customClass); - modal.setAttribute('data-custom-class', ''); - } - - /* - * Icon - */ - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.hide(modal.querySelectorAll('.sa-icon')); - - if (params.type && !_isIE8.isIE8()) { - var _ret = (function () { - - var validType = false; - - for (var i = 0; i < alertTypes.length; i++) { - if (params.type === alertTypes[i]) { - validType = true; - break; - } - } - - if (!validType) { - logStr('Unknown alert type: ' + params.type); - return { - v: false - }; - } - - var typesWithIcons = ['success', 'error', 'warning', 'info']; - var $icon = undefined; - - if (typesWithIcons.indexOf(params.type) !== -1) { - $icon = modal.querySelector('.sa-icon.' + 'sa-' + params.type); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.show($icon); - } - - var $input = _getModal$getInput$setFocusStyle.getInput(); - - // Animate icon - switch (params.type) { - - case 'success': - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.addClass($icon, 'animate'); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.addClass($icon.querySelector('.sa-tip'), 'animateSuccessTip'); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.addClass($icon.querySelector('.sa-long'), 'animateSuccessLong'); - break; - - case 'error': - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.addClass($icon, 'animateErrorIcon'); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.addClass($icon.querySelector('.sa-x-mark'), 'animateXMark'); - break; - - case 'warning': - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.addClass($icon, 'pulseWarning'); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.addClass($icon.querySelector('.sa-body'), 'pulseWarningIns'); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.addClass($icon.querySelector('.sa-dot'), 'pulseWarningIns'); - break; - - case 'input': - case 'prompt': - $input.setAttribute('type', params.inputType); - $input.value = params.inputValue; - $input.setAttribute('placeholder', params.inputPlaceholder); - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.addClass(modal, 'show-input'); - setTimeout(function () { - $input.focus(); - $input.addEventListener('keyup', swal.resetInputError); - }, 400); - break; - } - })(); - - if (typeof _ret === 'object') { - return _ret.v; - } - } - - /* - * Custom image - */ - if (params.imageUrl) { - var $customIcon = modal.querySelector('.sa-icon.sa-custom'); - - $customIcon.style.backgroundImage = 'url(' + params.imageUrl + ')'; - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.show($customIcon); - - var _imgWidth = 80; - var _imgHeight = 80; - - if (params.imageSize) { - var dimensions = params.imageSize.toString().split('x'); - var imgWidth = dimensions[0]; - var imgHeight = dimensions[1]; - - if (!imgWidth || !imgHeight) { - logStr('Parameter imageSize expects value with format WIDTHxHEIGHT, got ' + params.imageSize); - } else { - _imgWidth = imgWidth; - _imgHeight = imgHeight; - } - } - - $customIcon.setAttribute('style', $customIcon.getAttribute('style') + 'width:' + _imgWidth + 'px; height:' + _imgHeight + 'px'); - } - - /* - * Show cancel button? - */ - modal.setAttribute('data-has-cancel-button', params.showCancelButton); - if (params.showCancelButton) { - $cancelBtn.style.display = 'inline-block'; - } else { - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.hide($cancelBtn); - } - - /* - * Show confirm button? - */ - modal.setAttribute('data-has-confirm-button', params.showConfirmButton); - if (params.showConfirmButton) { - $confirmBtn.style.display = 'inline-block'; - } else { - _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.hide($confirmBtn); - } - - /* - * Custom text on cancel/confirm buttons - */ - if (params.cancelButtonText) { - $cancelBtn.innerHTML = _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.escapeHtml(params.cancelButtonText); - } - if (params.confirmButtonText) { - $confirmBtn.innerHTML = _hasClass$addClass$removeClass$escapeHtml$_show$show$_hide$hide.escapeHtml(params.confirmButtonText); - } - - /* - * Custom color on confirm button - */ - if (params.confirmButtonColor) { - // Set confirm button to selected background color - $confirmBtn.style.backgroundColor = params.confirmButtonColor; - - // Set the confirm button color to the loading ring - $confirmBtn.style.borderLeftColor = params.confirmLoadingButtonColor; - $confirmBtn.style.borderRightColor = params.confirmLoadingButtonColor; - - // Set box-shadow to default focused button - _getModal$getInput$setFocusStyle.setFocusStyle($confirmBtn, params.confirmButtonColor); - } - - /* - * Allow outside click - */ - modal.setAttribute('data-allow-outside-click', params.allowOutsideClick); - - /* - * Callback function - */ - var hasDoneFunction = params.doneFunction ? true : false; - modal.setAttribute('data-has-done-function', hasDoneFunction); - - /* - * Animation - */ - if (!params.animation) { - modal.setAttribute('data-animation', 'none'); - } else if (typeof params.animation === 'string') { - modal.setAttribute('data-animation', params.animation); // Custom animation - } else { - modal.setAttribute('data-animation', 'pop'); - } - - /* - * Timer - */ - modal.setAttribute('data-timer', params.timer); -}; - -exports['default'] = setParameters; -module.exports = exports['default']; - -},{"./handle-dom":4,"./handle-swal-dom":6,"./utils":9}],9:[function(require,module,exports){ -'use strict'; - -Object.defineProperty(exports, '__esModule', { - value: true -}); -/* - * Allow user to pass their own params - */ -var extend = function extend(a, b) { - for (var key in b) { - if (b.hasOwnProperty(key)) { - a[key] = b[key]; - } - } - return a; -}; - -/* - * Convert HEX codes to RGB values (#000000 -> rgb(0,0,0)) - */ -var hexToRgb = function hexToRgb(hex) { - var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex); - return result ? parseInt(result[1], 16) + ', ' + parseInt(result[2], 16) + ', ' + parseInt(result[3], 16) : null; -}; - -/* - * Check if the user is using Internet Explorer 8 (for fallbacks) - */ -var isIE8 = function isIE8() { - return window.attachEvent && !window.addEventListener; -}; - -/* - * IE compatible logging for developers - */ -var logStr = function logStr(string) { - if (window.console) { - // IE... - window.console.log('SweetAlert: ' + string); - } -}; - -/* - * Set hover, active and focus-states for buttons - * (source: http://www.sitepoint.com/javascript-generate-lighter-darker-color) - */ -var colorLuminance = function colorLuminance(hex, lum) { - // Validate hex string - hex = String(hex).replace(/[^0-9a-f]/gi, ''); - if (hex.length < 6) { - hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2]; - } - lum = lum || 0; - - // Convert to decimal and change luminosity - var rgb = '#'; - var c; - var i; - - for (i = 0; i < 3; i++) { - c = parseInt(hex.substr(i * 2, 2), 16); - c = Math.round(Math.min(Math.max(0, c + c * lum), 255)).toString(16); - rgb += ('00' + c).substr(c.length); - } - - return rgb; -}; - -exports.extend = extend; -exports.hexToRgb = hexToRgb; -exports.isIE8 = isIE8; -exports.logStr = logStr; -exports.colorLuminance = colorLuminance; - -},{}]},{},[1]) -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","/Users/Tristan/dev/SweetAlert/dev/sweetalert.es6.js","/Users/Tristan/dev/SweetAlert/dev/modules/default-params.js","/Users/Tristan/dev/SweetAlert/dev/modules/handle-click.js","/Users/Tristan/dev/SweetAlert/dev/modules/handle-dom.js","/Users/Tristan/dev/SweetAlert/dev/modules/handle-key.js","/Users/Tristan/dev/SweetAlert/dev/modules/handle-swal-dom.js","/Users/Tristan/dev/SweetAlert/dev/modules/injected-html.js","/Users/Tristan/dev/SweetAlert/dev/modules/set-params.js","/Users/Tristan/dev/SweetAlert/dev/modules/utils.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","// SweetAlert\n// 2014-2015 (c) - Tristan Edwards\n// github.com/t4t5/sweetalert\n\n/*\n * jQuery-like functions for manipulating the DOM\n */\nimport {\n  hasClass, addClass, removeClass,\n  escapeHtml,\n  _show, show, _hide, hide,\n  isDescendant,\n  getTopMargin,\n  fadeIn, fadeOut,\n  fireClick,\n  stopEventPropagation\n} from './modules/handle-dom';\n\n/*\n * Handy utilities\n */\nimport {\n  extend,\n  hexToRgb,\n  isIE8,\n  logStr,\n  colorLuminance\n} from './modules/utils';\n\n/*\n *  Handle sweetAlert's DOM elements\n */\nimport {\n  sweetAlertInitialize,\n  getModal,\n  getOverlay,\n  getInput,\n  setFocusStyle,\n  openModal,\n  resetInput,\n  fixVerticalPosition\n} from './modules/handle-swal-dom';\n\n\n// Handle button events and keyboard events\nimport { handleButton, handleConfirm, handleCancel } from './modules/handle-click';\nimport handleKeyDown from './modules/handle-key';\n\n\n// Default values\nimport defaultParams from './modules/default-params';\nimport setParameters from './modules/set-params';\n\n/*\n * Remember state in cases where opening and handling a modal will fiddle with it.\n * (We also use window.previousActiveElement as a global variable)\n */\nvar previousWindowKeyDown;\nvar lastFocusedButton;\n\n\n/*\n * Global sweetAlert function\n * (this is what the user calls)\n */\nvar sweetAlert, swal;\n\nexport default sweetAlert = swal = function() {\n  var customizations = arguments[0];\n\n  addClass(document.body, 'stop-scrolling');\n  resetInput();\n\n  /*\n   * Use argument if defined or default value from params object otherwise.\n   * Supports the case where a default value is boolean true and should be\n   * overridden by a corresponding explicit argument which is boolean false.\n   */\n  function argumentOrDefault(key) {\n    var args = customizations;\n    return (args[key] === undefined) ?  defaultParams[key] : args[key];\n  }\n\n  if (customizations === undefined) {\n    logStr('SweetAlert expects at least 1 attribute!');\n    return false;\n  }\n\n  var params = extend({}, defaultParams);\n\n  switch (typeof customizations) {\n\n    // Ex: swal(\"Hello\", \"Just testing\", \"info\");\n    case 'string':\n      params.title = customizations;\n      params.text  = arguments[1] || '';\n      params.type  = arguments[2] || '';\n      break;\n\n    // Ex: swal({ title:\"Hello\", text: \"Just testing\", type: \"info\" });\n    case 'object':\n      if (customizations.title === undefined) {\n        logStr('Missing \"title\" argument!');\n        return false;\n      }\n\n      params.title = customizations.title;\n\n      for (let customName in defaultParams) {\n        params[customName] = argumentOrDefault(customName);\n      }\n\n      // Show \"Confirm\" instead of \"OK\" if cancel button is visible\n      params.confirmButtonText = params.showCancelButton ? 'Confirm' : defaultParams.confirmButtonText;\n      params.confirmButtonText = argumentOrDefault('confirmButtonText');\n\n      // Callback function when clicking on \"OK\"/\"Cancel\"\n      params.doneFunction = arguments[1] || null;\n\n      break;\n\n    default:\n      logStr('Unexpected type of argument! Expected \"string\" or \"object\", got ' + typeof customizations);\n      return false;\n\n  }\n\n  setParameters(params);\n  fixVerticalPosition();\n  openModal(arguments[1]);\n\n  // Modal interactions\n  var modal = getModal();\n\n\n  /*\n   * Make sure all modal buttons respond to all events\n   */\n  var $buttons = modal.querySelectorAll('button');\n  var buttonEvents = ['onclick', 'onmouseover', 'onmouseout', 'onmousedown', 'onmouseup', 'onfocus'];\n  var onButtonEvent = (e) => handleButton(e, params, modal);\n\n  for (let btnIndex = 0; btnIndex < $buttons.length; btnIndex++) {\n    for (let evtIndex = 0; evtIndex < buttonEvents.length; evtIndex++) {\n      let btnEvt = buttonEvents[evtIndex];\n      $buttons[btnIndex][btnEvt] = onButtonEvent;\n    }\n  }\n\n  // Clicking outside the modal dismisses it (if allowed by user)\n  getOverlay().onclick = onButtonEvent;\n\n  previousWindowKeyDown = window.onkeydown;\n\n  var onKeyEvent = (e) => handleKeyDown(e, params, modal);\n  window.onkeydown = onKeyEvent;\n\n  window.onfocus = function () {\n    // When the user has focused away and focused back from the whole window.\n    setTimeout(function () {\n      // Put in a timeout to jump out of the event sequence.\n      // Calling focus() in the event sequence confuses things.\n      if (lastFocusedButton !== undefined) {\n        lastFocusedButton.focus();\n        lastFocusedButton = undefined;\n      }\n    }, 0);\n  };\n  \n  // Show alert with enabled buttons always\n  swal.enableButtons();\n};\n\n\n\n/*\n * Set default params for each popup\n * @param {Object} userParams\n */\nsweetAlert.setDefaults = swal.setDefaults = function(userParams) {\n  if (!userParams) {\n    throw new Error('userParams is required');\n  }\n  if (typeof userParams !== 'object') {\n    throw new Error('userParams has to be a object');\n  }\n\n  extend(defaultParams, userParams);\n};\n\n\n/*\n * Animation when closing modal\n */\nsweetAlert.close = swal.close = function() {\n  var modal = getModal();\n\n  fadeOut(getOverlay(), 5);\n  fadeOut(modal, 5);\n  removeClass(modal, 'showSweetAlert');\n  addClass(modal, 'hideSweetAlert');\n  removeClass(modal, 'visible');\n\n  /*\n   * Reset icon animations\n   */\n  var $successIcon = modal.querySelector('.sa-icon.sa-success');\n  removeClass($successIcon, 'animate');\n  removeClass($successIcon.querySelector('.sa-tip'), 'animateSuccessTip');\n  removeClass($successIcon.querySelector('.sa-long'), 'animateSuccessLong');\n\n  var $errorIcon = modal.querySelector('.sa-icon.sa-error');\n  removeClass($errorIcon, 'animateErrorIcon');\n  removeClass($errorIcon.querySelector('.sa-x-mark'), 'animateXMark');\n\n  var $warningIcon = modal.querySelector('.sa-icon.sa-warning');\n  removeClass($warningIcon, 'pulseWarning');\n  removeClass($warningIcon.querySelector('.sa-body'), 'pulseWarningIns');\n  removeClass($warningIcon.querySelector('.sa-dot'), 'pulseWarningIns');\n\n  // Reset custom class (delay so that UI changes aren't visible)\n  setTimeout(function() {\n    var customClass = modal.getAttribute('data-custom-class');\n    removeClass(modal, customClass);\n  }, 300);\n\n  // Make page scrollable again\n  removeClass(document.body, 'stop-scrolling');\n\n  // Reset the page to its previous state\n  window.onkeydown = previousWindowKeyDown;\n  if (window.previousActiveElement) {\n    window.previousActiveElement.focus();\n  }\n  lastFocusedButton = undefined;\n  clearTimeout(modal.timeout);\n\n  return true;\n};\n\n\n/*\n * Validation of the input field is done by user\n * If something is wrong => call showInputError with errorMessage\n */\nsweetAlert.showInputError = swal.showInputError = function(errorMessage) {\n  var modal = getModal();\n\n  var $errorIcon = modal.querySelector('.sa-input-error');\n  addClass($errorIcon, 'show');\n\n  var $errorContainer = modal.querySelector('.sa-error-container');\n  addClass($errorContainer, 'show');\n\n  $errorContainer.querySelector('p').innerHTML = errorMessage;\n\n  setTimeout(function() {\n    sweetAlert.enableButtons();\n  }, 1);\n\n  modal.querySelector('input').focus();\n};\n\n\n/*\n * Reset input error DOM elements\n */\nsweetAlert.resetInputError = swal.resetInputError = function(event) {\n  // If press enter => ignore\n  if (event && event.keyCode === 13) {\n    return false;\n  }\n\n  var $modal = getModal();\n\n  var $errorIcon = $modal.querySelector('.sa-input-error');\n  removeClass($errorIcon, 'show');\n\n  var $errorContainer = $modal.querySelector('.sa-error-container');\n  removeClass($errorContainer, 'show');\n};\n\n/*\n * Disable confirm and cancel buttons\n */\nsweetAlert.disableButtons = swal.disableButtons = function(event) {\n  var modal = getModal();\n  var $confirmButton = modal.querySelector('button.confirm');\n  var $cancelButton = modal.querySelector('button.cancel');\n  $confirmButton.disabled = true;\n  $cancelButton.disabled = true;\n};\n\n/*\n * Enable confirm and cancel buttons\n */\nsweetAlert.enableButtons = swal.enableButtons = function(event) {\n  var modal = getModal();\n  var $confirmButton = modal.querySelector('button.confirm');\n  var $cancelButton = modal.querySelector('button.cancel');\n  $confirmButton.disabled = false;\n  $cancelButton.disabled = false;\n};\n\nif (typeof window !== 'undefined') {\n  // The 'handle-click' module requires\n  // that 'sweetAlert' was set as global.\n  window.sweetAlert = window.swal = sweetAlert;\n} else {\n  logStr('SweetAlert is a frontend module!');\n}\n","var defaultParams = {\n  title: '',\n  text: '',\n  type: null,\n  allowOutsideClick: false,\n  showConfirmButton: true,\n  showCancelButton: false,\n  closeOnConfirm: true,\n  closeOnCancel: true,\n  confirmButtonText: 'OK',\n  confirmButtonColor: '#8CD4F5',\n  cancelButtonText: 'Cancel',\n  imageUrl: null,\n  imageSize: null,\n  timer: null,\n  customClass: '',\n  html: false,\n  animation: true,\n  allowEscapeKey: true,\n  inputType: 'text',\n  inputPlaceholder: '',\n  inputValue: '',\n  showLoaderOnConfirm: false\n};\n\nexport default defaultParams;\n","import { colorLuminance } from './utils';\nimport { getModal } from './handle-swal-dom';\nimport { hasClass, isDescendant } from './handle-dom';\n\n\n/*\n * User clicked on \"Confirm\"/\"OK\" or \"Cancel\"\n */\nvar handleButton = function(event, params, modal) {\n  var e = event || window.event;\n  var target = e.target || e.srcElement;\n\n  var targetedConfirm = target.className.indexOf('confirm') !== -1;\n  var targetedOverlay = target.className.indexOf('sweet-overlay') !== -1;\n  var modalIsVisible  = hasClass(modal, 'visible');\n  var doneFunctionExists = (params.doneFunction && modal.getAttribute('data-has-done-function') === 'true');\n\n  // Since the user can change the background-color of the confirm button programmatically,\n  // we must calculate what the color should be on hover/active\n  var normalColor, hoverColor, activeColor;\n  if (targetedConfirm && params.confirmButtonColor) {\n    normalColor  = params.confirmButtonColor;\n    hoverColor   = colorLuminance(normalColor, -0.04);\n    activeColor  = colorLuminance(normalColor, -0.14);\n  }\n\n  function shouldSetConfirmButtonColor(color) {\n    if (targetedConfirm && params.confirmButtonColor) {\n      target.style.backgroundColor = color;\n    }\n  }\n\n  switch (e.type) {\n    case 'mouseover':\n      shouldSetConfirmButtonColor(hoverColor);\n      break;\n\n    case 'mouseout':\n      shouldSetConfirmButtonColor(normalColor);\n      break;\n\n    case 'mousedown':\n      shouldSetConfirmButtonColor(activeColor);\n      break;\n\n    case 'mouseup':\n      shouldSetConfirmButtonColor(hoverColor);\n      break;\n\n    case 'focus':\n      let $confirmButton = modal.querySelector('button.confirm');\n      let $cancelButton  = modal.querySelector('button.cancel');\n\n      if (targetedConfirm) {\n        $cancelButton.style.boxShadow = 'none';\n      } else {\n        $confirmButton.style.boxShadow = 'none';\n      }\n      break;\n\n    case 'click':\n      let clickedOnModal = (modal === target);\n      let clickedOnModalChild = isDescendant(modal, target);\n\n      // Ignore click outside if allowOutsideClick is false\n      if (!clickedOnModal && !clickedOnModalChild && modalIsVisible && !params.allowOutsideClick) {\n        break;\n      }\n\n      if (targetedConfirm && doneFunctionExists && modalIsVisible) {\n        handleConfirm(modal, params);\n      } else if (doneFunctionExists && modalIsVisible || targetedOverlay) {\n        handleCancel(modal, params);\n      } else if (isDescendant(modal, target) && target.tagName === 'BUTTON') {\n        sweetAlert.close();\n      }\n      break;\n  }\n};\n\n/*\n *  User clicked on \"Confirm\"/\"OK\"\n */\nvar handleConfirm = function(modal, params) {\n  var callbackValue = true;\n\n  if (hasClass(modal, 'show-input')) {\n    callbackValue = modal.querySelector('input').value;\n\n    if (!callbackValue) {\n      callbackValue = '';\n    }\n  }\n\n  params.doneFunction(callbackValue);\n\n  if (params.closeOnConfirm) {\n    sweetAlert.close();\n  }\n  // Disable cancel and confirm button if the parameter is true\n  if (params.showLoaderOnConfirm) {\n    sweetAlert.disableButtons();\n  }\n};\n\n/*\n *  User clicked on \"Cancel\"\n */\nvar handleCancel = function(modal, params) {\n  // Check if callback function expects a parameter (to track cancel actions)\n  var functionAsStr = String(params.doneFunction).replace(/\\s/g, '');\n  var functionHandlesCancel = functionAsStr.substring(0, 9) === 'function(' && functionAsStr.substring(9, 10) !== ')';\n\n  if (functionHandlesCancel) {\n    params.doneFunction(false);\n  }\n\n  if (params.closeOnCancel) {\n    sweetAlert.close();\n  }\n};\n\n\nexport default {\n  handleButton,\n  handleConfirm,\n  handleCancel\n};\n","var hasClass = function(elem, className) {\n  return new RegExp(' ' + className + ' ').test(' ' + elem.className + ' ');\n};\n\nvar addClass = function(elem, className) {\n  if (!hasClass(elem, className)) {\n    elem.className += ' ' + className;\n  }\n};\n\nvar removeClass = function(elem, className) {\n  var newClass = ' ' + elem.className.replace(/[\\t\\r\\n]/g, ' ') + ' ';\n  if (hasClass(elem, className)) {\n    while (newClass.indexOf(' ' + className + ' ') >= 0) {\n      newClass = newClass.replace(' ' + className + ' ', ' ');\n    }\n    elem.className = newClass.replace(/^\\s+|\\s+$/g, '');\n  }\n};\n\nvar escapeHtml = function(str) {\n  var div = document.createElement('div');\n  div.appendChild(document.createTextNode(str));\n  return div.innerHTML;\n};\n\nvar _show = function(elem) {\n  elem.style.opacity = '';\n  elem.style.display = 'block';\n};\n\nvar show = function(elems) {\n  if (elems && !elems.length) {\n    return _show(elems);\n  }\n  for (var i = 0; i < elems.length; ++i) {\n    _show(elems[i]);\n  }\n};\n\nvar _hide = function(elem) {\n  elem.style.opacity = '';\n  elem.style.display = 'none';\n};\n\nvar hide = function(elems) {\n  if (elems && !elems.length) {\n    return _hide(elems);\n  }\n  for (var i = 0; i < elems.length; ++i) {\n    _hide(elems[i]);\n  }\n};\n\nvar isDescendant = function(parent, child) {\n  var node = child.parentNode;\n  while (node !== null) {\n    if (node === parent) {\n      return true;\n    }\n    node = node.parentNode;\n  }\n  return false;\n};\n\nvar getTopMargin = function(elem) {\n  elem.style.left = '-9999px';\n  elem.style.display = 'block';\n\n  var height = elem.clientHeight,\n      padding;\n  if (typeof getComputedStyle !== \"undefined\") { // IE 8\n    padding = parseInt(getComputedStyle(elem).getPropertyValue('padding-top'), 10);\n  } else {\n    padding = parseInt(elem.currentStyle.padding);\n  }\n\n  elem.style.left = '';\n  elem.style.display = 'none';\n  return ('-' + parseInt((height + padding) / 2) + 'px');\n};\n\nvar fadeIn = function(elem, interval) {\n  if (+elem.style.opacity < 1) {\n    interval = interval || 16;\n    elem.style.opacity = 0;\n    elem.style.display = 'block';\n    var last = +new Date();\n    var tick = function() {\n      elem.style.opacity = +elem.style.opacity + (new Date() - last) / 100;\n      last = +new Date();\n\n      if (+elem.style.opacity < 1) {\n        setTimeout(tick, interval);\n      }\n    };\n    tick();\n  }\n  elem.style.display = 'block'; //fallback IE8\n};\n\nvar fadeOut = function(elem, interval) {\n  interval = interval || 16;\n  elem.style.opacity = 1;\n  var last = +new Date();\n  var tick = function() {\n    elem.style.opacity = +elem.style.opacity - (new Date() - last) / 100;\n    last = +new Date();\n\n    if (+elem.style.opacity > 0) {\n      setTimeout(tick, interval);\n    } else {\n      elem.style.display = 'none';\n    }\n  };\n  tick();\n};\n\nvar fireClick = function(node) {\n  // Taken from http://www.nonobtrusive.com/2011/11/29/programatically-fire-crossbrowser-click-event-with-javascript/\n  // Then fixed for today's Chrome browser.\n  if (typeof MouseEvent === 'function') {\n    // Up-to-date approach\n    var mevt = new MouseEvent('click', {\n      view: window,\n      bubbles: false,\n      cancelable: true\n    });\n    node.dispatchEvent(mevt);\n  } else if ( document.createEvent ) {\n    // Fallback\n    var evt = document.createEvent('MouseEvents');\n    evt.initEvent('click', false, false);\n    node.dispatchEvent(evt);\n  } else if (document.createEventObject) {\n    node.fireEvent('onclick') ;\n  } else if (typeof node.onclick === 'function' ) {\n    node.onclick();\n  }\n};\n\nvar stopEventPropagation = function(e) {\n  // In particular, make sure the space bar doesn't scroll the main window.\n  if (typeof e.stopPropagation === 'function') {\n    e.stopPropagation();\n    e.preventDefault();\n  } else if (window.event && window.event.hasOwnProperty('cancelBubble')) {\n    window.event.cancelBubble = true;\n  }\n};\n\nexport { \n  hasClass, addClass, removeClass, \n  escapeHtml, \n  _show, show, _hide, hide, \n  isDescendant, \n  getTopMargin,\n  fadeIn, fadeOut,\n  fireClick,\n  stopEventPropagation\n};\n","import { stopEventPropagation, fireClick } from './handle-dom';\nimport { setFocusStyle } from './handle-swal-dom';\n\n\nvar handleKeyDown = function(event, params, modal) {\n  var e = event || window.event;\n  var keyCode = e.keyCode || e.which;\n\n  var $okButton     = modal.querySelector('button.confirm');\n  var $cancelButton = modal.querySelector('button.cancel');\n  var $modalButtons = modal.querySelectorAll('button[tabindex]');\n\n\n  if ([9, 13, 32, 27].indexOf(keyCode) === -1) {\n    // Don't do work on keys we don't care about.\n    return;\n  }\n\n  var $targetElement = e.target || e.srcElement;\n\n  var btnIndex = -1; // Find the button - note, this is a nodelist, not an array.\n  for (var i = 0; i < $modalButtons.length; i++) {\n    if ($targetElement === $modalButtons[i]) {\n      btnIndex = i;\n      break;\n    }\n  }\n\n  if (keyCode === 9) {\n    // TAB\n    if (btnIndex === -1) {\n      // No button focused. Jump to the confirm button.\n      $targetElement = $okButton;\n    } else {\n      // Cycle to the next button\n      if (btnIndex === $modalButtons.length - 1) {\n        $targetElement = $modalButtons[0];\n      } else {\n        $targetElement = $modalButtons[btnIndex + 1];\n      }\n    }\n\n    stopEventPropagation(e);\n    $targetElement.focus();\n\n    if (params.confirmButtonColor) {\n      setFocusStyle($targetElement, params.confirmButtonColor);\n    }\n  } else {\n    if (keyCode === 13) {\n      if ($targetElement.tagName === 'INPUT') {\n        $targetElement = $okButton;\n        $okButton.focus();\n      }\n\n      if (btnIndex === -1) {\n        // ENTER/SPACE clicked outside of a button.\n        $targetElement = $okButton;\n      } else {\n        // Do nothing - let the browser handle it.\n        $targetElement = undefined;\n      }\n    } else if (keyCode === 27 && params.allowEscapeKey === true) {\n      $targetElement = $cancelButton;\n      fireClick($targetElement, e);\n    } else {\n      // Fallback - let the browser handle it.\n      $targetElement = undefined;\n    }\n  }\n};\n\nexport default handleKeyDown;\n","import { hexToRgb } from './utils';\nimport { removeClass, getTopMargin, fadeIn, show, addClass } from './handle-dom';\nimport defaultParams from './default-params';\n\nvar modalClass   = '.sweet-alert';\nvar overlayClass = '.sweet-overlay';\n\n/*\n * Add modal + overlay to DOM\n */\nimport injectedHTML from './injected-html';\n\nvar sweetAlertInitialize = function() {\n  var sweetWrap = document.createElement('div');\n  sweetWrap.innerHTML = injectedHTML;\n\n  // Append elements to body\n  while (sweetWrap.firstChild) {\n    document.body.appendChild(sweetWrap.firstChild);\n  }\n};\n\n/*\n * Get DOM element of modal\n */\nvar getModal = function() {\n  var $modal = document.querySelector(modalClass);\n\n  if (!$modal) {\n    sweetAlertInitialize();\n    $modal = getModal();\n  }\n\n  return $modal;\n};\n\n/*\n * Get DOM element of input (in modal)\n */\nvar getInput = function() {\n  var $modal = getModal();\n  if ($modal) {\n    return $modal.querySelector('input');\n  }\n};\n\n/*\n * Get DOM element of overlay\n */\nvar getOverlay = function() {\n  return document.querySelector(overlayClass);\n};\n\n/*\n * Add box-shadow style to button (depending on its chosen bg-color)\n */\nvar setFocusStyle = function($button, bgColor) {\n  var rgbColor = hexToRgb(bgColor);\n  $button.style.boxShadow = '0 0 2px rgba(' + rgbColor + ', 0.8), inset 0 0 0 1px rgba(0, 0, 0, 0.05)';\n};\n\n/*\n * Animation when opening modal\n */\nvar openModal = function(callback) {\n  var $modal = getModal();\n  fadeIn(getOverlay(), 10);\n  show($modal);\n  addClass($modal, 'showSweetAlert');\n  removeClass($modal, 'hideSweetAlert');\n\n  window.previousActiveElement = document.activeElement;\n  var $okButton = $modal.querySelector('button.confirm');\n  $okButton.focus();\n\n  setTimeout(function () {\n    addClass($modal, 'visible');\n  }, 500);\n\n  var timer = $modal.getAttribute('data-timer');\n\n  if (timer !== 'null' && timer !== '') {\n    var timerCallback = callback;\n    $modal.timeout = setTimeout(function() {\n      var doneFunctionExists = ((timerCallback || null) && $modal.getAttribute('data-has-done-function') === 'true');\n      if (doneFunctionExists) { \n        timerCallback(null);\n      }\n      else {\n        sweetAlert.close();\n      }\n    }, timer);\n  }\n};\n\n/*\n * Reset the styling of the input\n * (for example if errors have been shown)\n */\nvar resetInput = function() {\n  var $modal = getModal();\n  var $input = getInput();\n\n  removeClass($modal, 'show-input');\n  $input.value = defaultParams.inputValue;\n  $input.setAttribute('type', defaultParams.inputType);\n  $input.setAttribute('placeholder', defaultParams.inputPlaceholder);\n\n  resetInputError();\n};\n\n\nvar resetInputError = function(event) {\n  // If press enter => ignore\n  if (event && event.keyCode === 13) {\n    return false;\n  }\n\n  var $modal = getModal();\n\n  var $errorIcon = $modal.querySelector('.sa-input-error');\n  removeClass($errorIcon, 'show');\n\n  var $errorContainer = $modal.querySelector('.sa-error-container');\n  removeClass($errorContainer, 'show');\n};\n\n\n/*\n * Set \"margin-top\"-property on modal based on its computed height\n */\nvar fixVerticalPosition = function() {\n  var $modal = getModal();\n  $modal.style.marginTop = getTopMargin(getModal());\n};\n\n\nexport { \n  sweetAlertInitialize,\n  getModal,\n  getOverlay,\n  getInput,\n  setFocusStyle,\n  openModal,\n  resetInput,\n  resetInputError,\n  fixVerticalPosition\n};\n","var injectedHTML = \n\n  // Dark overlay\n  `<div class=\"sweet-overlay\" tabIndex=\"-1\"></div>` +\n\n  // Modal\n  `<div class=\"sweet-alert\">` +\n\n    // Error icon\n    `<div class=\"sa-icon sa-error\">\n      <span class=\"sa-x-mark\">\n        <span class=\"sa-line sa-left\"></span>\n        <span class=\"sa-line sa-right\"></span>\n      </span>\n    </div>` +\n\n    // Warning icon\n    `<div class=\"sa-icon sa-warning\">\n      <span class=\"sa-body\"></span>\n      <span class=\"sa-dot\"></span>\n    </div>` +\n\n    // Info icon\n    `<div class=\"sa-icon sa-info\"></div>` +\n\n    // Success icon\n    `<div class=\"sa-icon sa-success\">\n      <span class=\"sa-line sa-tip\"></span>\n      <span class=\"sa-line sa-long\"></span>\n\n      <div class=\"sa-placeholder\"></div>\n      <div class=\"sa-fix\"></div>\n    </div>` +\n\n    `<div class=\"sa-icon sa-custom\"></div>` +\n\n    // Title, text and input\n    `<h2>Title</h2>\n    <p>Text</p>\n    <fieldset>\n      <input type=\"text\" tabIndex=\"3\" />\n      <div class=\"sa-input-error\"></div>\n    </fieldset>` +\n\n    // Input errors\n    `<div class=\"sa-error-container\">\n      <div class=\"icon\">!</div>\n      <p>Not valid!</p>\n    </div>` +\n\n    // Cancel and confirm buttons\n    `<div class=\"sa-button-container\">\n      <button class=\"cancel\" tabIndex=\"2\">Cancel</button>\n      <div class=\"sa-confirm-button-container\">\n        <button class=\"confirm\" tabIndex=\"1\">OK</button>` + \n\n        // Loading animation\n        `<div class=\"la-ball-fall\">\n          <div></div>\n          <div></div>\n          <div></div>\n        </div>\n      </div>\n    </div>` +\n\n  // End of modal\n  `</div>`;\n\nexport default injectedHTML;\n","var alertTypes = ['error', 'warning', 'info', 'success', 'input', 'prompt'];\n\nimport {\n  isIE8\n} from './utils';\n\nimport {\n  getModal,\n  getInput,\n  setFocusStyle\n} from './handle-swal-dom';\n\nimport {\n  hasClass, addClass, removeClass,\n  escapeHtml,\n  _show, show, _hide, hide\n} from './handle-dom';\n\n\n/*\n * Set type, text and actions on modal\n */\nvar setParameters = function(params) {\n  var modal = getModal();\n\n  var $title = modal.querySelector('h2');\n  var $text = modal.querySelector('p');\n  var $cancelBtn = modal.querySelector('button.cancel');\n  var $confirmBtn = modal.querySelector('button.confirm');\n\n  /*\n   * Title\n   */\n  $title.innerHTML = params.html ? params.title : escapeHtml(params.title).split('\\n').join('<br>');\n\n  /*\n   * Text\n   */\n  $text.innerHTML = params.html ? params.text : escapeHtml(params.text || '').split('\\n').join('<br>');\n  if (params.text) show($text);\n\n  /*\n   * Custom class\n   */\n  if (params.customClass) {\n    addClass(modal, params.customClass);\n    modal.setAttribute('data-custom-class', params.customClass);\n  } else {\n    // Find previously set classes and remove them\n    let customClass = modal.getAttribute('data-custom-class');\n    removeClass(modal, customClass);\n    modal.setAttribute('data-custom-class', '');\n  }\n\n  /*\n   * Icon\n   */\n  hide(modal.querySelectorAll('.sa-icon'));\n\n  if (params.type && !isIE8()) {\n\n    let validType = false;\n\n    for (let i = 0; i < alertTypes.length; i++) {\n      if (params.type === alertTypes[i]) {\n        validType = true;\n        break;\n      }\n    }\n\n    if (!validType) {\n      logStr('Unknown alert type: ' + params.type);\n      return false;\n    }\n\n    let typesWithIcons = ['success', 'error', 'warning', 'info'];\n    let $icon;\n\n    if (typesWithIcons.indexOf(params.type) !== -1) {\n      $icon = modal.querySelector('.sa-icon.' + 'sa-' + params.type);\n      show($icon);\n    }\n\n    let $input = getInput();\n\n    // Animate icon\n    switch (params.type) {\n\n      case 'success':\n        addClass($icon, 'animate');\n        addClass($icon.querySelector('.sa-tip'), 'animateSuccessTip');\n        addClass($icon.querySelector('.sa-long'), 'animateSuccessLong');\n        break;\n\n      case 'error':\n        addClass($icon, 'animateErrorIcon');\n        addClass($icon.querySelector('.sa-x-mark'), 'animateXMark');\n        break;\n\n      case 'warning':\n        addClass($icon, 'pulseWarning');\n        addClass($icon.querySelector('.sa-body'), 'pulseWarningIns');\n        addClass($icon.querySelector('.sa-dot'), 'pulseWarningIns');\n        break;\n\n      case 'input':\n      case 'prompt':\n        $input.setAttribute('type', params.inputType);\n        $input.value = params.inputValue;\n        $input.setAttribute('placeholder', params.inputPlaceholder);\n        addClass(modal, 'show-input');\n        setTimeout(function () {\n          $input.focus();\n          $input.addEventListener('keyup', swal.resetInputError);\n        }, 400);\n        break;\n    }\n  }\n\n  /*\n   * Custom image\n   */\n  if (params.imageUrl) {\n    let $customIcon = modal.querySelector('.sa-icon.sa-custom');\n\n    $customIcon.style.backgroundImage = 'url(' + params.imageUrl + ')';\n    show($customIcon);\n\n    let _imgWidth = 80;\n    let _imgHeight = 80;\n\n    if (params.imageSize) {\n      let dimensions = params.imageSize.toString().split('x');\n      let imgWidth = dimensions[0];\n      let imgHeight = dimensions[1];\n\n      if (!imgWidth || !imgHeight) {\n        logStr('Parameter imageSize expects value with format WIDTHxHEIGHT, got ' + params.imageSize);\n      } else {\n        _imgWidth = imgWidth;\n        _imgHeight = imgHeight;\n      }\n    }\n\n    $customIcon.setAttribute('style', $customIcon.getAttribute('style') + 'width:' + _imgWidth + 'px; height:' + _imgHeight + 'px');\n  }\n\n  /*\n   * Show cancel button?\n   */\n  modal.setAttribute('data-has-cancel-button', params.showCancelButton);\n  if (params.showCancelButton) {\n    $cancelBtn.style.display = 'inline-block';\n  } else {\n    hide($cancelBtn);\n  }\n\n  /*\n   * Show confirm button?\n   */\n  modal.setAttribute('data-has-confirm-button', params.showConfirmButton);\n  if (params.showConfirmButton) {\n    $confirmBtn.style.display = 'inline-block';\n  } else {\n    hide($confirmBtn);\n  }\n\n  /*\n   * Custom text on cancel/confirm buttons\n   */\n  if (params.cancelButtonText) {\n    $cancelBtn.innerHTML = escapeHtml(params.cancelButtonText);\n  }\n  if (params.confirmButtonText) {\n    $confirmBtn.innerHTML = escapeHtml(params.confirmButtonText);\n  }\n\n  /*\n   * Custom color on confirm button\n   */\n  if (params.confirmButtonColor) {\n    // Set confirm button to selected background color\n    $confirmBtn.style.backgroundColor = params.confirmButtonColor;\n\n    // Set the confirm button color to the loading ring\n    $confirmBtn.style.borderLeftColor = params.confirmLoadingButtonColor;\n    $confirmBtn.style.borderRightColor = params.confirmLoadingButtonColor;\n\n    // Set box-shadow to default focused button\n    setFocusStyle($confirmBtn, params.confirmButtonColor);\n  }\n\n  /*\n   * Allow outside click\n   */\n  modal.setAttribute('data-allow-outside-click', params.allowOutsideClick);\n\n  /*\n   * Callback function\n   */\n  var hasDoneFunction = params.doneFunction ? true : false;\n  modal.setAttribute('data-has-done-function', hasDoneFunction);\n\n  /*\n   * Animation\n   */\n  if (!params.animation) {\n    modal.setAttribute('data-animation', 'none');\n  } else if (typeof params.animation === 'string') {\n    modal.setAttribute('data-animation', params.animation); // Custom animation\n  } else {\n    modal.setAttribute('data-animation', 'pop');\n  }\n\n  /*\n   * Timer\n   */\n  modal.setAttribute('data-timer', params.timer);\n};\n\nexport default setParameters;\n","/*\n * Allow user to pass their own params\n */\nvar extend = function(a, b) {\n  for (var key in b) {\n    if (b.hasOwnProperty(key)) {\n      a[key] = b[key];\n    }\n  }\n  return a;\n};\n\n/*\n * Convert HEX codes to RGB values (#000000 -> rgb(0,0,0))\n */\nvar hexToRgb = function(hex) {\n  var result = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(hex);\n  return result ? parseInt(result[1], 16) + ', ' + parseInt(result[2], 16) + ', ' + parseInt(result[3], 16) : null;\n};\n\n/*\n * Check if the user is using Internet Explorer 8 (for fallbacks)\n */\nvar isIE8 = function() {\n  return (window.attachEvent && !window.addEventListener);\n};\n\n/*\n * IE compatible logging for developers\n */\nvar logStr = function(string) {\n  if (window.console) {\n    // IE...\n    window.console.log('SweetAlert: ' + string);\n  }\n};\n\n/*\n * Set hover, active and focus-states for buttons \n * (source: http://www.sitepoint.com/javascript-generate-lighter-darker-color)\n */\nvar colorLuminance = function(hex, lum) {\n  // Validate hex string\n  hex = String(hex).replace(/[^0-9a-f]/gi, '');\n  if (hex.length < 6) {\n    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];\n  }\n  lum = lum || 0;\n\n  // Convert to decimal and change luminosity\n  var rgb = '#';\n  var c;\n  var i;\n\n  for (i = 0; i < 3; i++) {\n    c = parseInt(hex.substr(i * 2, 2), 16);\n    c = Math.round(Math.min(Math.max(0, c + c * lum), 255)).toString(16);\n    rgb += ('00' + c).substr(c.length);\n  }\n\n  return rgb;\n};\n\n\nexport {\n  extend,\n  hexToRgb,\n  isIE8,\n  logStr,\n  colorLuminance\n};\n"]} - - - /* - * Use SweetAlert with RequireJS - */ - - if (typeof define === 'function' && define.amd) { - define(function () { - return sweetAlert; - }); - } else if (typeof module !== 'undefined' && module.exports) { - module.exports = sweetAlert; - } - -})(window, document); \ No newline at end of file diff --git a/admin/template_assets/vendor/sweetalert/sweetalert.css b/admin/template_assets/vendor/sweetalert/sweetalert.css index d2936e6..bfbaad3 100644 --- a/admin/template_assets/vendor/sweetalert/sweetalert.css +++ b/admin/template_assets/vendor/sweetalert/sweetalert.css @@ -1,929 +1,932 @@ body.stop-scrolling { -height: 100%; -overflow: hidden; } + height: 100%; + overflow: hidden; } .sweet-overlay { -background-color: black; -/* IE8 */ --ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=40)"; -/* IE8 */ -background-color: rgba(0, 0, 0, 0.4); -position: fixed; -left: 0; -right: 0; -top: 0; -bottom: 0; -display: none; -z-index: 10000; } + background-color: black; + /* IE8 */ + -ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=40)"; + /* IE8 */ + background-color: rgba(0, 0, 0, 0.4); + position: fixed; + left: 0; + right: 0; + top: 0; + bottom: 0; + display: none; + z-index: 10000; } .sweet-alert { -background-color: white; -font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; -width: 478px; -padding: 17px; -border-radius: 5px; -text-align: center; -position: fixed; -left: 50%; -top: 50%; -margin-left: -256px; -margin-top: -200px; -overflow: hidden; -display: none; -z-index: 99999; } -@media all and (max-width: 540px) { -.sweet-alert { -width: auto; -margin-left: 0; -margin-right: 0; -left: 15px; -right: 15px; } } -.sweet-alert h2 { -color: #575757; -font-size: 30px; -text-align: center; -font-weight: 600; -text-transform: none; -position: relative; -margin: 25px 0; -padding: 0; -line-height: 40px; -display: block; } -.sweet-alert p { -font-size: 16px; -text-align: center; -position: relative; -text-align: inherit; -float: none; -margin: 0; -padding: 0; -line-height: normal; } -.sweet-alert fieldset { -border: none; -position: relative; } -.sweet-alert .sa-error-container { -background-color: #f1f1f1; -margin-left: -17px; -margin-right: -17px; -overflow: hidden; -padding: 0 10px; -max-height: 0; -webkit-transition: padding 0.15s, max-height 0.15s; -transition: padding 0.15s, max-height 0.15s; } -.sweet-alert .sa-error-container.show { -padding: 10px 0; -max-height: 100px; -webkit-transition: padding 0.2s, max-height 0.2s; -transition: padding 0.25s, max-height 0.25s; } -.sweet-alert .sa-error-container .icon { -display: inline-block; -width: 24px; -height: 24px; -border-radius: 50%; -background-color: #ea7d7d; -color: white; -line-height: 24px; -text-align: center; -margin-right: 3px; } -.sweet-alert .sa-error-container p { -display: inline-block; } -.sweet-alert .sa-input-error { -position: absolute; -top: 22px; -right: 16px; -width: 20px; -height: 20px; -opacity: 0; --webkit-transform: scale(0.5); -transform: scale(0.5); --webkit-transform-origin: 50% 50%; -transform-origin: 50% 50%; --webkit-transition: all 0.1s; -transition: all 0.1s; } -.sweet-alert .sa-input-error::before, .sweet-alert .sa-input-error::after { -content: ""; -width: 20px; -height: 6px; -background-color: #f06e57; -border-radius: 3px; -position: absolute; -top: 50%; -margin-top: -4px; -left: 50%; -margin-left: -9px; } -.sweet-alert .sa-input-error::before { --webkit-transform: rotate(-45deg); -transform: rotate(-45deg); } -.sweet-alert .sa-input-error::after { --webkit-transform: rotate(45deg); -transform: rotate(45deg); } -.sweet-alert .sa-input-error.show { -opacity: 1; --webkit-transform: scale(1); -transform: scale(1); } -.sweet-alert input { -width: 100%; -box-sizing: border-box; -border-radius: 4px; -border: 1px solid #d7d7d7; -height: 43px; -margin-top: 10px; -margin-bottom: 17px; -font-size: 14px; -padding: 0 12px; -display: none; --webkit-transition: all 0.3s; -transition: all 0.3s; } -.sweet-alert input:focus { -outline: none; -box-shadow: 0px 0px 3px #c4e6f5; -border: 1px solid #b4dbed; } -.sweet-alert input:focus::-moz-placeholder { - transition: opacity 0.3s 0.03s ease; - opacity: 0.5; } -.sweet-alert input:focus:-ms-input-placeholder { - transition: opacity 0.3s 0.03s ease; - opacity: 0.5; } -.sweet-alert input:focus::-webkit-input-placeholder { - transition: opacity 0.3s 0.03s ease; - opacity: 0.5; } -.sweet-alert input::-moz-placeholder { -color: #bdbdbd; } -.sweet-alert input:-ms-input-placeholder { -color: #bdbdbd; } -.sweet-alert input::-webkit-input-placeholder { -color: #bdbdbd; } -.sweet-alert.show-input input { -display: block; } -.sweet-alert .sa-confirm-button-container { -display: inline-block; -position: relative; } -.sweet-alert .la-ball-fall { -position: absolute; -left: 50%; -top: 50%; -margin-left: -27px; -margin-top: 4px; -opacity: 0; -visibility: hidden; } -.sweet-alert button { + background-color: white; + font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; + width: 478px; + padding: 17px; + border-radius: 5px; + text-align: center; + position: fixed; + left: 50%; + top: 50%; + margin-left: -256px; + margin-top: -200px; + overflow: hidden; + display: none; + z-index: 99999; } + @media all and (max-width: 540px) { + .sweet-alert { + width: auto; + margin-left: 0; + margin-right: 0; + left: 15px; + right: 15px; } } + .sweet-alert h2 { + color: #575757; + font-size: 30px; + text-align: center; + font-weight: 600; + text-transform: none; + position: relative; + margin: 25px 0; + padding: 0; + line-height: 40px; + display: block; } + .sweet-alert p { + color: #797979; + font-size: 16px; + text-align: center; + font-weight: 300; + position: relative; + text-align: inherit; + float: none; + margin: 0; + padding: 0; + line-height: normal; } + .sweet-alert fieldset { + border: none; + position: relative; } + .sweet-alert .sa-error-container { + background-color: #f1f1f1; + margin-left: -17px; + margin-right: -17px; + overflow: hidden; + padding: 0 10px; + max-height: 0; + webkit-transition: padding 0.15s, max-height 0.15s; + transition: padding 0.15s, max-height 0.15s; } + .sweet-alert .sa-error-container.show { + padding: 10px 0; + max-height: 100px; + webkit-transition: padding 0.2s, max-height 0.2s; + transition: padding 0.25s, max-height 0.25s; } + .sweet-alert .sa-error-container .icon { + display: inline-block; + width: 24px; + height: 24px; + border-radius: 50%; + background-color: #ea7d7d; + color: white; + line-height: 24px; + text-align: center; + margin-right: 3px; } + .sweet-alert .sa-error-container p { + display: inline-block; } + .sweet-alert .sa-input-error { + position: absolute; + top: 29px; + right: 26px; + width: 20px; + height: 20px; + opacity: 0; + -webkit-transform: scale(0.5); + transform: scale(0.5); + -webkit-transform-origin: 50% 50%; + transform-origin: 50% 50%; + -webkit-transition: all 0.1s; + transition: all 0.1s; } + .sweet-alert .sa-input-error::before, .sweet-alert .sa-input-error::after { + content: ""; + width: 20px; + height: 6px; + background-color: #f06e57; + border-radius: 3px; + position: absolute; + top: 50%; + margin-top: -4px; + left: 50%; + margin-left: -9px; } + .sweet-alert .sa-input-error::before { + -webkit-transform: rotate(-45deg); + transform: rotate(-45deg); } + .sweet-alert .sa-input-error::after { + -webkit-transform: rotate(45deg); + transform: rotate(45deg); } + .sweet-alert .sa-input-error.show { + opacity: 1; + -webkit-transform: scale(1); + transform: scale(1); } + .sweet-alert input { + width: 100%; + box-sizing: border-box; + border-radius: 3px; + border: 1px solid #d7d7d7; + height: 43px; + margin-top: 10px; + margin-bottom: 17px; + font-size: 18px; + box-shadow: inset 0px 1px 1px rgba(0, 0, 0, 0.06); + padding: 0 12px; + display: none; + -webkit-transition: all 0.3s; + transition: all 0.3s; } + .sweet-alert input:focus { + outline: none; + box-shadow: 0px 0px 3px #c4e6f5; + border: 1px solid #b4dbed; } + .sweet-alert input:focus::-moz-placeholder { + transition: opacity 0.3s 0.03s ease; + opacity: 0.5; } + .sweet-alert input:focus:-ms-input-placeholder { + transition: opacity 0.3s 0.03s ease; + opacity: 0.5; } + .sweet-alert input:focus::-webkit-input-placeholder { + transition: opacity 0.3s 0.03s ease; + opacity: 0.5; } + .sweet-alert input::-moz-placeholder { + color: #bdbdbd; } + .sweet-alert input:-ms-input-placeholder { + color: #bdbdbd; } + .sweet-alert input::-webkit-input-placeholder { + color: #bdbdbd; } + .sweet-alert.show-input input { + display: block; } + .sweet-alert .sa-confirm-button-container { + display: inline-block; + position: relative; } + .sweet-alert .la-ball-fall { + position: absolute; + left: 50%; + top: 50%; + margin-left: -27px; + margin-top: 4px; + opacity: 0; + visibility: hidden; } + .sweet-alert button { background-color: #8CD4F5; color: white; border: none; box-shadow: none; - font-size: 14px; - border-radius: 4px; + font-size: 17px; + font-weight: 500; -webkit-border-radius: 4px; - padding: 8px 30px; + border-radius: 5px; + padding: 10px 32px; margin: 26px 5px 0 5px; - cursor: pointer; -} -.sweet-alert button:focus { -outline: none; -box-shadow: 0 0 2px rgba(128, 179, 235, 0.5), inset 0 0 0 1px rgba(0, 0, 0, 0.05); } -.sweet-alert button:hover { -background-color: #7ecff4; } -.sweet-alert button:active { -background-color: #5dc2f1; } -.sweet-alert button.cancel { -background-color: #6c757d; } -.sweet-alert button.cancel:hover { - background-color: #b9b9b9; } -.sweet-alert button.cancel:active { - background-color: #a8a8a8; } -.sweet-alert button.cancel:focus { - box-shadow: rgba(197, 205, 211, 0.8) 0px 0px 2px, rgba(0, 0, 0, 0.0470588) 0px 0px 0px 1px inset !important; } -.sweet-alert button[disabled] { -opacity: .6; -cursor: default; } -.sweet-alert button.confirm[disabled] { -color: transparent; } -.sweet-alert button.confirm[disabled] ~ .la-ball-fall { - opacity: 1; - visibility: visible; - transition-delay: 0s; } -.sweet-alert button::-moz-focus-inner { -border: 0; } -.sweet-alert[data-has-cancel-button=false] button { -box-shadow: none !important; } -.sweet-alert[data-has-confirm-button=false][data-has-cancel-button=false] { -padding-bottom: 40px; } -.sweet-alert .sa-icon { -width: 80px; -height: 80px; -border: 4px solid gray; --webkit-border-radius: 40px; -border-radius: 40px; -border-radius: 50%; -margin: 20px auto; -padding: 0; -position: relative; -box-sizing: content-box; } -.sweet-alert .sa-icon.sa-error { -border-color: #F27474; } -.sweet-alert .sa-icon.sa-error .sa-x-mark { - position: relative; - display: block; } -.sweet-alert .sa-icon.sa-error .sa-line { - position: absolute; - height: 5px; - width: 47px; - background-color: #F27474; - display: block; - top: 37px; - border-radius: 2px; } - .sweet-alert .sa-icon.sa-error .sa-line.sa-left { - -webkit-transform: rotate(45deg); - transform: rotate(45deg); - left: 17px; } - .sweet-alert .sa-icon.sa-error .sa-line.sa-right { - -webkit-transform: rotate(-45deg); - transform: rotate(-45deg); - right: 16px; } -.sweet-alert .sa-icon.sa-warning { -border-color: #F8BB86; } -.sweet-alert .sa-icon.sa-warning .sa-body { - position: absolute; - width: 5px; - height: 47px; - left: 50%; - top: 10px; - -webkit-border-radius: 2px; - border-radius: 2px; - margin-left: -2px; - background-color: #F8BB86; } -.sweet-alert .sa-icon.sa-warning .sa-dot { - position: absolute; - width: 7px; - height: 7px; - -webkit-border-radius: 50%; - border-radius: 50%; - margin-left: -3px; - left: 50%; - bottom: 10px; - background-color: #F8BB86; } -.sweet-alert .sa-icon.sa-info { -border-color: #C9DAE1; } -.sweet-alert .sa-icon.sa-info::before { - content: ""; - position: absolute; - width: 5px; - height: 29px; - left: 50%; - bottom: 17px; - border-radius: 2px; - margin-left: -2px; - background-color: #C9DAE1; } -.sweet-alert .sa-icon.sa-info::after { - content: ""; - position: absolute; - width: 7px; - height: 7px; - border-radius: 50%; - margin-left: -3px; - top: 19px; - background-color: #C9DAE1; } -.sweet-alert .sa-icon.sa-success { -border-color: #A5DC86; } -.sweet-alert .sa-icon.sa-success::before, .sweet-alert .sa-icon.sa-success::after { - content: ''; - -webkit-border-radius: 40px; - border-radius: 40px; - border-radius: 50%; - position: absolute; - width: 60px; - height: 120px; - background: white; - -webkit-transform: rotate(45deg); - transform: rotate(45deg); } -.sweet-alert .sa-icon.sa-success::before { - -webkit-border-radius: 120px 0 0 120px; - border-radius: 120px 0 0 120px; - top: -7px; - left: -33px; - -webkit-transform: rotate(-45deg); - transform: rotate(-45deg); - -webkit-transform-origin: 60px 60px; - transform-origin: 60px 60px; } -.sweet-alert .sa-icon.sa-success::after { - -webkit-border-radius: 0 120px 120px 0; - border-radius: 0 120px 120px 0; - top: -11px; - left: 30px; - -webkit-transform: rotate(-45deg); - transform: rotate(-45deg); - -webkit-transform-origin: 0px 60px; - transform-origin: 0px 60px; } -.sweet-alert .sa-icon.sa-success .sa-placeholder { + cursor: pointer; } + .sweet-alert button:focus { + outline: none; + box-shadow: 0 0 2px rgba(128, 179, 235, 0.5), inset 0 0 0 1px rgba(0, 0, 0, 0.05); } + .sweet-alert button:hover { + background-color: #7ecff4; } + .sweet-alert button:active { + background-color: #5dc2f1; } + .sweet-alert button.cancel { + background-color: #C1C1C1; } + .sweet-alert button.cancel:hover { + background-color: #b9b9b9; } + .sweet-alert button.cancel:active { + background-color: #a8a8a8; } + .sweet-alert button.cancel:focus { + box-shadow: rgba(197, 205, 211, 0.8) 0px 0px 2px, rgba(0, 0, 0, 0.0470588) 0px 0px 0px 1px inset !important; } + .sweet-alert button[disabled] { + opacity: .6; + cursor: default; } + .sweet-alert button.confirm[disabled] { + color: transparent; } + .sweet-alert button.confirm[disabled] ~ .la-ball-fall { + opacity: 1; + visibility: visible; + transition-delay: 0s; } + .sweet-alert button::-moz-focus-inner { + border: 0; } + .sweet-alert[data-has-cancel-button=false] button { + box-shadow: none !important; } + .sweet-alert[data-has-confirm-button=false][data-has-cancel-button=false] { + padding-bottom: 40px; } + .sweet-alert .sa-icon { width: 80px; height: 80px; - border: 4px solid rgba(165, 220, 134, 0.2); + border: 4px solid gray; -webkit-border-radius: 40px; border-radius: 40px; border-radius: 50%; - box-sizing: content-box; - position: absolute; - left: -4px; - top: -4px; - z-index: 2; } -.sweet-alert .sa-icon.sa-success .sa-fix { - width: 5px; - height: 90px; - background-color: white; - position: absolute; - left: 28px; - top: 8px; - z-index: 1; - -webkit-transform: rotate(-45deg); - transform: rotate(-45deg); } -.sweet-alert .sa-icon.sa-success .sa-line { - height: 5px; - background-color: #A5DC86; - display: block; - border-radius: 2px; - position: absolute; - z-index: 2; } - .sweet-alert .sa-icon.sa-success .sa-line.sa-tip { - width: 25px; - left: 14px; - top: 46px; - -webkit-transform: rotate(45deg); - transform: rotate(45deg); } - .sweet-alert .sa-icon.sa-success .sa-line.sa-long { - width: 47px; - right: 8px; - top: 38px; - -webkit-transform: rotate(-45deg); - transform: rotate(-45deg); } -.sweet-alert .sa-icon.sa-custom { -background-size: contain; -border-radius: 0; -border: none; -background-position: center center; -background-repeat: no-repeat; } + margin: 20px auto; + padding: 0; + position: relative; + box-sizing: content-box; } + .sweet-alert .sa-icon.sa-error { + border-color: #F27474; } + .sweet-alert .sa-icon.sa-error .sa-x-mark { + position: relative; + display: block; } + .sweet-alert .sa-icon.sa-error .sa-line { + position: absolute; + height: 5px; + width: 47px; + background-color: #F27474; + display: block; + top: 37px; + border-radius: 2px; } + .sweet-alert .sa-icon.sa-error .sa-line.sa-left { + -webkit-transform: rotate(45deg); + transform: rotate(45deg); + left: 17px; } + .sweet-alert .sa-icon.sa-error .sa-line.sa-right { + -webkit-transform: rotate(-45deg); + transform: rotate(-45deg); + right: 16px; } + .sweet-alert .sa-icon.sa-warning { + border-color: #F8BB86; } + .sweet-alert .sa-icon.sa-warning .sa-body { + position: absolute; + width: 5px; + height: 47px; + left: 50%; + top: 10px; + -webkit-border-radius: 2px; + border-radius: 2px; + margin-left: -2px; + background-color: #F8BB86; } + .sweet-alert .sa-icon.sa-warning .sa-dot { + position: absolute; + width: 7px; + height: 7px; + -webkit-border-radius: 50%; + border-radius: 50%; + margin-left: -3px; + left: 50%; + bottom: 10px; + background-color: #F8BB86; } + .sweet-alert .sa-icon.sa-info { + border-color: #C9DAE1; } + .sweet-alert .sa-icon.sa-info::before { + content: ""; + position: absolute; + width: 5px; + height: 29px; + left: 50%; + bottom: 17px; + border-radius: 2px; + margin-left: -2px; + background-color: #C9DAE1; } + .sweet-alert .sa-icon.sa-info::after { + content: ""; + position: absolute; + width: 7px; + height: 7px; + border-radius: 50%; + margin-left: -3px; + top: 19px; + background-color: #C9DAE1; } + .sweet-alert .sa-icon.sa-success { + border-color: #A5DC86; } + .sweet-alert .sa-icon.sa-success::before, .sweet-alert .sa-icon.sa-success::after { + content: ''; + -webkit-border-radius: 40px; + border-radius: 40px; + border-radius: 50%; + position: absolute; + width: 60px; + height: 120px; + background: white; + -webkit-transform: rotate(45deg); + transform: rotate(45deg); } + .sweet-alert .sa-icon.sa-success::before { + -webkit-border-radius: 120px 0 0 120px; + border-radius: 120px 0 0 120px; + top: -7px; + left: -33px; + -webkit-transform: rotate(-45deg); + transform: rotate(-45deg); + -webkit-transform-origin: 60px 60px; + transform-origin: 60px 60px; } + .sweet-alert .sa-icon.sa-success::after { + -webkit-border-radius: 0 120px 120px 0; + border-radius: 0 120px 120px 0; + top: -11px; + left: 30px; + -webkit-transform: rotate(-45deg); + transform: rotate(-45deg); + -webkit-transform-origin: 0px 60px; + transform-origin: 0px 60px; } + .sweet-alert .sa-icon.sa-success .sa-placeholder { + width: 80px; + height: 80px; + border: 4px solid rgba(165, 220, 134, 0.2); + -webkit-border-radius: 40px; + border-radius: 40px; + border-radius: 50%; + box-sizing: content-box; + position: absolute; + left: -4px; + top: -4px; + z-index: 2; } + .sweet-alert .sa-icon.sa-success .sa-fix { + width: 5px; + height: 90px; + background-color: white; + position: absolute; + left: 28px; + top: 8px; + z-index: 1; + -webkit-transform: rotate(-45deg); + transform: rotate(-45deg); } + .sweet-alert .sa-icon.sa-success .sa-line { + height: 5px; + background-color: #A5DC86; + display: block; + border-radius: 2px; + position: absolute; + z-index: 2; } + .sweet-alert .sa-icon.sa-success .sa-line.sa-tip { + width: 25px; + left: 14px; + top: 46px; + -webkit-transform: rotate(45deg); + transform: rotate(45deg); } + .sweet-alert .sa-icon.sa-success .sa-line.sa-long { + width: 47px; + right: 8px; + top: 38px; + -webkit-transform: rotate(-45deg); + transform: rotate(-45deg); } + .sweet-alert .sa-icon.sa-custom { + background-size: contain; + border-radius: 0; + border: none; + background-position: center center; + background-repeat: no-repeat; } /* -* Animations -*/ + * Animations + */ @-webkit-keyframes showSweetAlert { -0% { -transform: scale(0.7); --webkit-transform: scale(0.7); } -45% { -transform: scale(1.05); --webkit-transform: scale(1.05); } -80% { -transform: scale(0.95); --webkit-transform: scale(0.95); } -100% { -transform: scale(1); --webkit-transform: scale(1); } } + 0% { + transform: scale(0.7); + -webkit-transform: scale(0.7); } + 45% { + transform: scale(1.05); + -webkit-transform: scale(1.05); } + 80% { + transform: scale(0.95); + -webkit-transform: scale(0.95); } + 100% { + transform: scale(1); + -webkit-transform: scale(1); } } @keyframes showSweetAlert { -0% { -transform: scale(0.7); --webkit-transform: scale(0.7); } -45% { -transform: scale(1.05); --webkit-transform: scale(1.05); } -80% { -transform: scale(0.95); --webkit-transform: scale(0.95); } -100% { -transform: scale(1); --webkit-transform: scale(1); } } + 0% { + transform: scale(0.7); + -webkit-transform: scale(0.7); } + 45% { + transform: scale(1.05); + -webkit-transform: scale(1.05); } + 80% { + transform: scale(0.95); + -webkit-transform: scale(0.95); } + 100% { + transform: scale(1); + -webkit-transform: scale(1); } } @-webkit-keyframes hideSweetAlert { -0% { -transform: scale(1); --webkit-transform: scale(1); } -100% { -transform: scale(0.5); --webkit-transform: scale(0.5); } } + 0% { + transform: scale(1); + -webkit-transform: scale(1); } + 100% { + transform: scale(0.5); + -webkit-transform: scale(0.5); } } @keyframes hideSweetAlert { -0% { -transform: scale(1); --webkit-transform: scale(1); } -100% { -transform: scale(0.5); --webkit-transform: scale(0.5); } } + 0% { + transform: scale(1); + -webkit-transform: scale(1); } + 100% { + transform: scale(0.5); + -webkit-transform: scale(0.5); } } @-webkit-keyframes slideFromTop { -0% { -top: 0%; } -100% { -top: 50%; } } + 0% { + top: 0%; } + 100% { + top: 50%; } } @keyframes slideFromTop { -0% { -top: 0%; } -100% { -top: 50%; } } + 0% { + top: 0%; } + 100% { + top: 50%; } } @-webkit-keyframes slideToTop { -0% { -top: 50%; } -100% { -top: 0%; } } + 0% { + top: 50%; } + 100% { + top: 0%; } } @keyframes slideToTop { -0% { -top: 50%; } -100% { -top: 0%; } } + 0% { + top: 50%; } + 100% { + top: 0%; } } @-webkit-keyframes slideFromBottom { -0% { -top: 70%; } -100% { -top: 50%; } } + 0% { + top: 70%; } + 100% { + top: 50%; } } @keyframes slideFromBottom { -0% { -top: 70%; } -100% { -top: 50%; } } + 0% { + top: 70%; } + 100% { + top: 50%; } } @-webkit-keyframes slideToBottom { -0% { -top: 50%; } -100% { -top: 70%; } } + 0% { + top: 50%; } + 100% { + top: 70%; } } @keyframes slideToBottom { -0% { -top: 50%; } -100% { -top: 70%; } } + 0% { + top: 50%; } + 100% { + top: 70%; } } .showSweetAlert[data-animation=pop] { --webkit-animation: showSweetAlert 0.3s; -animation: showSweetAlert 0.3s; } + -webkit-animation: showSweetAlert 0.3s; + animation: showSweetAlert 0.3s; } .showSweetAlert[data-animation=none] { --webkit-animation: none; -animation: none; } + -webkit-animation: none; + animation: none; } .showSweetAlert[data-animation=slide-from-top] { --webkit-animation: slideFromTop 0.3s; -animation: slideFromTop 0.3s; } + -webkit-animation: slideFromTop 0.3s; + animation: slideFromTop 0.3s; } .showSweetAlert[data-animation=slide-from-bottom] { --webkit-animation: slideFromBottom 0.3s; -animation: slideFromBottom 0.3s; } + -webkit-animation: slideFromBottom 0.3s; + animation: slideFromBottom 0.3s; } .hideSweetAlert[data-animation=pop] { --webkit-animation: hideSweetAlert 0.2s; -animation: hideSweetAlert 0.2s; } + -webkit-animation: hideSweetAlert 0.2s; + animation: hideSweetAlert 0.2s; } .hideSweetAlert[data-animation=none] { --webkit-animation: none; -animation: none; } + -webkit-animation: none; + animation: none; } .hideSweetAlert[data-animation=slide-from-top] { --webkit-animation: slideToTop 0.4s; -animation: slideToTop 0.4s; } + -webkit-animation: slideToTop 0.4s; + animation: slideToTop 0.4s; } .hideSweetAlert[data-animation=slide-from-bottom] { --webkit-animation: slideToBottom 0.3s; -animation: slideToBottom 0.3s; } + -webkit-animation: slideToBottom 0.3s; + animation: slideToBottom 0.3s; } @-webkit-keyframes animateSuccessTip { -0% { -width: 0; -left: 1px; -top: 19px; } -54% { -width: 0; -left: 1px; -top: 19px; } -70% { -width: 50px; -left: -8px; -top: 37px; } -84% { -width: 17px; -left: 21px; -top: 48px; } -100% { -width: 25px; -left: 14px; -top: 45px; } } + 0% { + width: 0; + left: 1px; + top: 19px; } + 54% { + width: 0; + left: 1px; + top: 19px; } + 70% { + width: 50px; + left: -8px; + top: 37px; } + 84% { + width: 17px; + left: 21px; + top: 48px; } + 100% { + width: 25px; + left: 14px; + top: 45px; } } @keyframes animateSuccessTip { -0% { -width: 0; -left: 1px; -top: 19px; } -54% { -width: 0; -left: 1px; -top: 19px; } -70% { -width: 50px; -left: -8px; -top: 37px; } -84% { -width: 17px; -left: 21px; -top: 48px; } -100% { -width: 25px; -left: 14px; -top: 45px; } } + 0% { + width: 0; + left: 1px; + top: 19px; } + 54% { + width: 0; + left: 1px; + top: 19px; } + 70% { + width: 50px; + left: -8px; + top: 37px; } + 84% { + width: 17px; + left: 21px; + top: 48px; } + 100% { + width: 25px; + left: 14px; + top: 45px; } } @-webkit-keyframes animateSuccessLong { -0% { -width: 0; -right: 46px; -top: 54px; } -65% { -width: 0; -right: 46px; -top: 54px; } -84% { -width: 55px; -right: 0px; -top: 35px; } -100% { -width: 47px; -right: 8px; -top: 38px; } } + 0% { + width: 0; + right: 46px; + top: 54px; } + 65% { + width: 0; + right: 46px; + top: 54px; } + 84% { + width: 55px; + right: 0px; + top: 35px; } + 100% { + width: 47px; + right: 8px; + top: 38px; } } @keyframes animateSuccessLong { -0% { -width: 0; -right: 46px; -top: 54px; } -65% { -width: 0; -right: 46px; -top: 54px; } -84% { -width: 55px; -right: 0px; -top: 35px; } -100% { -width: 47px; -right: 8px; -top: 38px; } } + 0% { + width: 0; + right: 46px; + top: 54px; } + 65% { + width: 0; + right: 46px; + top: 54px; } + 84% { + width: 55px; + right: 0px; + top: 35px; } + 100% { + width: 47px; + right: 8px; + top: 38px; } } @-webkit-keyframes rotatePlaceholder { -0% { -transform: rotate(-45deg); --webkit-transform: rotate(-45deg); } -5% { -transform: rotate(-45deg); --webkit-transform: rotate(-45deg); } -12% { -transform: rotate(-405deg); --webkit-transform: rotate(-405deg); } -100% { -transform: rotate(-405deg); --webkit-transform: rotate(-405deg); } } + 0% { + transform: rotate(-45deg); + -webkit-transform: rotate(-45deg); } + 5% { + transform: rotate(-45deg); + -webkit-transform: rotate(-45deg); } + 12% { + transform: rotate(-405deg); + -webkit-transform: rotate(-405deg); } + 100% { + transform: rotate(-405deg); + -webkit-transform: rotate(-405deg); } } @keyframes rotatePlaceholder { -0% { -transform: rotate(-45deg); --webkit-transform: rotate(-45deg); } -5% { -transform: rotate(-45deg); --webkit-transform: rotate(-45deg); } -12% { -transform: rotate(-405deg); --webkit-transform: rotate(-405deg); } -100% { -transform: rotate(-405deg); --webkit-transform: rotate(-405deg); } } + 0% { + transform: rotate(-45deg); + -webkit-transform: rotate(-45deg); } + 5% { + transform: rotate(-45deg); + -webkit-transform: rotate(-45deg); } + 12% { + transform: rotate(-405deg); + -webkit-transform: rotate(-405deg); } + 100% { + transform: rotate(-405deg); + -webkit-transform: rotate(-405deg); } } .animateSuccessTip { --webkit-animation: animateSuccessTip 0.75s; -animation: animateSuccessTip 0.75s; } + -webkit-animation: animateSuccessTip 0.75s; + animation: animateSuccessTip 0.75s; } .animateSuccessLong { --webkit-animation: animateSuccessLong 0.75s; -animation: animateSuccessLong 0.75s; } + -webkit-animation: animateSuccessLong 0.75s; + animation: animateSuccessLong 0.75s; } .sa-icon.sa-success.animate::after { --webkit-animation: rotatePlaceholder 4.25s ease-in; -animation: rotatePlaceholder 4.25s ease-in; } + -webkit-animation: rotatePlaceholder 4.25s ease-in; + animation: rotatePlaceholder 4.25s ease-in; } @-webkit-keyframes animateErrorIcon { -0% { -transform: rotateX(100deg); --webkit-transform: rotateX(100deg); -opacity: 0; } -100% { -transform: rotateX(0deg); --webkit-transform: rotateX(0deg); -opacity: 1; } } + 0% { + transform: rotateX(100deg); + -webkit-transform: rotateX(100deg); + opacity: 0; } + 100% { + transform: rotateX(0deg); + -webkit-transform: rotateX(0deg); + opacity: 1; } } @keyframes animateErrorIcon { -0% { -transform: rotateX(100deg); --webkit-transform: rotateX(100deg); -opacity: 0; } -100% { -transform: rotateX(0deg); --webkit-transform: rotateX(0deg); -opacity: 1; } } + 0% { + transform: rotateX(100deg); + -webkit-transform: rotateX(100deg); + opacity: 0; } + 100% { + transform: rotateX(0deg); + -webkit-transform: rotateX(0deg); + opacity: 1; } } .animateErrorIcon { --webkit-animation: animateErrorIcon 0.5s; -animation: animateErrorIcon 0.5s; } + -webkit-animation: animateErrorIcon 0.5s; + animation: animateErrorIcon 0.5s; } @-webkit-keyframes animateXMark { -0% { -transform: scale(0.4); --webkit-transform: scale(0.4); -margin-top: 26px; -opacity: 0; } -50% { -transform: scale(0.4); --webkit-transform: scale(0.4); -margin-top: 26px; -opacity: 0; } -80% { -transform: scale(1.15); --webkit-transform: scale(1.15); -margin-top: -6px; } -100% { -transform: scale(1); --webkit-transform: scale(1); -margin-top: 0; -opacity: 1; } } + 0% { + transform: scale(0.4); + -webkit-transform: scale(0.4); + margin-top: 26px; + opacity: 0; } + 50% { + transform: scale(0.4); + -webkit-transform: scale(0.4); + margin-top: 26px; + opacity: 0; } + 80% { + transform: scale(1.15); + -webkit-transform: scale(1.15); + margin-top: -6px; } + 100% { + transform: scale(1); + -webkit-transform: scale(1); + margin-top: 0; + opacity: 1; } } @keyframes animateXMark { -0% { -transform: scale(0.4); --webkit-transform: scale(0.4); -margin-top: 26px; -opacity: 0; } -50% { -transform: scale(0.4); --webkit-transform: scale(0.4); -margin-top: 26px; -opacity: 0; } -80% { -transform: scale(1.15); --webkit-transform: scale(1.15); -margin-top: -6px; } -100% { -transform: scale(1); --webkit-transform: scale(1); -margin-top: 0; -opacity: 1; } } + 0% { + transform: scale(0.4); + -webkit-transform: scale(0.4); + margin-top: 26px; + opacity: 0; } + 50% { + transform: scale(0.4); + -webkit-transform: scale(0.4); + margin-top: 26px; + opacity: 0; } + 80% { + transform: scale(1.15); + -webkit-transform: scale(1.15); + margin-top: -6px; } + 100% { + transform: scale(1); + -webkit-transform: scale(1); + margin-top: 0; + opacity: 1; } } .animateXMark { --webkit-animation: animateXMark 0.5s; -animation: animateXMark 0.5s; } + -webkit-animation: animateXMark 0.5s; + animation: animateXMark 0.5s; } @-webkit-keyframes pulseWarning { -0% { -border-color: #F8D486; } -100% { -border-color: #F8BB86; } } + 0% { + border-color: #ffe000; } + 100% { + border-color: #ffa000; } } @keyframes pulseWarning { -0% { -border-color: #F8D486; } -100% { -border-color: #F8BB86; } } + 0% { + border-color: #ffe000; } + 100% { + border-color: #ffa000; } } .pulseWarning { --webkit-animation: pulseWarning 0.75s infinite alternate; -animation: pulseWarning 0.75s infinite alternate; } + -webkit-animation: pulseWarning 0.75s infinite alternate; + animation: pulseWarning 0.75s infinite alternate; } @-webkit-keyframes pulseWarningIns { -0% { -background-color: #F8D486; } -100% { -background-color: #F8BB86; } } + 0% { + background-color: #ffe000; } + 100% { + background-color: #ffa000; } } @keyframes pulseWarningIns { -0% { -background-color: #F8D486; } -100% { -background-color: #F8BB86; } } + 0% { + background-color: #ffe000; } + 100% { + background-color: #ffa000; } } .pulseWarningIns { --webkit-animation: pulseWarningIns 0.75s infinite alternate; -animation: pulseWarningIns 0.75s infinite alternate; } + -webkit-animation: pulseWarningIns 0.75s infinite alternate; + animation: pulseWarningIns 0.75s infinite alternate; } @-webkit-keyframes rotate-loading { -0% { -transform: rotate(0deg); } -100% { -transform: rotate(360deg); } } + 0% { + transform: rotate(0deg); } + 100% { + transform: rotate(360deg); } } @keyframes rotate-loading { -0% { -transform: rotate(0deg); } -100% { -transform: rotate(360deg); } } + 0% { + transform: rotate(0deg); } + 100% { + transform: rotate(360deg); } } /* Internet Explorer 9 has some special quirks that are fixed here */ /* The icons are not animated. */ /* This file is automatically merged into sweet-alert.min.js through Gulp */ /* Error icon */ .sweet-alert .sa-icon.sa-error .sa-line.sa-left { --ms-transform: rotate(45deg) \9; } + -ms-transform: rotate(45deg) \9; } .sweet-alert .sa-icon.sa-error .sa-line.sa-right { --ms-transform: rotate(-45deg) \9; } + -ms-transform: rotate(-45deg) \9; } /* Success icon */ .sweet-alert .sa-icon.sa-success { -border-color: transparent\9; } + border-color: transparent\9; } .sweet-alert .sa-icon.sa-success .sa-line.sa-tip { --ms-transform: rotate(45deg) \9; } + -ms-transform: rotate(45deg) \9; } .sweet-alert .sa-icon.sa-success .sa-line.sa-long { --ms-transform: rotate(-45deg) \9; } + -ms-transform: rotate(-45deg) \9; } /*! -* Load Awesome v1.1.0 (http://github.danielcardoso.net/load-awesome/) -* Copyright 2015 Daniel Cardoso <@DanielCardoso> -* Licensed under MIT -*/ + * Load Awesome v1.1.0 (http://github.danielcardoso.net/load-awesome/) + * Copyright 2015 Daniel Cardoso <@DanielCardoso> + * Licensed under MIT + */ .la-ball-fall, .la-ball-fall > div { -position: relative; --webkit-box-sizing: border-box; --moz-box-sizing: border-box; -box-sizing: border-box; } + position: relative; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; } .la-ball-fall { -display: block; -font-size: 0; -color: #fff; } + display: block; + font-size: 0; + color: #fff; } .la-ball-fall.la-dark { -color: #333; } + color: #333; } .la-ball-fall > div { -display: inline-block; -float: none; -background-color: currentColor; -border: 0 solid currentColor; } + display: inline-block; + float: none; + background-color: currentColor; + border: 0 solid currentColor; } .la-ball-fall { -width: 54px; -height: 18px; } + width: 54px; + height: 18px; } .la-ball-fall > div { -width: 10px; -height: 10px; -margin: 4px; -border-radius: 100%; -opacity: 0; --webkit-animation: ball-fall 1s ease-in-out infinite; --moz-animation: ball-fall 1s ease-in-out infinite; --o-animation: ball-fall 1s ease-in-out infinite; -animation: ball-fall 1s ease-in-out infinite; } + width: 10px; + height: 10px; + margin: 4px; + border-radius: 100%; + opacity: 0; + -webkit-animation: ball-fall 1s ease-in-out infinite; + -moz-animation: ball-fall 1s ease-in-out infinite; + -o-animation: ball-fall 1s ease-in-out infinite; + animation: ball-fall 1s ease-in-out infinite; } .la-ball-fall > div:nth-child(1) { --webkit-animation-delay: -200ms; --moz-animation-delay: -200ms; --o-animation-delay: -200ms; -animation-delay: -200ms; } + -webkit-animation-delay: -200ms; + -moz-animation-delay: -200ms; + -o-animation-delay: -200ms; + animation-delay: -200ms; } .la-ball-fall > div:nth-child(2) { --webkit-animation-delay: -100ms; --moz-animation-delay: -100ms; --o-animation-delay: -100ms; -animation-delay: -100ms; } + -webkit-animation-delay: -100ms; + -moz-animation-delay: -100ms; + -o-animation-delay: -100ms; + animation-delay: -100ms; } .la-ball-fall > div:nth-child(3) { --webkit-animation-delay: 0ms; --moz-animation-delay: 0ms; --o-animation-delay: 0ms; -animation-delay: 0ms; } + -webkit-animation-delay: 0ms; + -moz-animation-delay: 0ms; + -o-animation-delay: 0ms; + animation-delay: 0ms; } .la-ball-fall.la-sm { -width: 26px; -height: 8px; } + width: 26px; + height: 8px; } .la-ball-fall.la-sm > div { -width: 4px; -height: 4px; -margin: 2px; } + width: 4px; + height: 4px; + margin: 2px; } .la-ball-fall.la-2x { -width: 108px; -height: 36px; } + width: 108px; + height: 36px; } .la-ball-fall.la-2x > div { -width: 20px; -height: 20px; -margin: 8px; } + width: 20px; + height: 20px; + margin: 8px; } .la-ball-fall.la-3x { -width: 162px; -height: 54px; } + width: 162px; + height: 54px; } .la-ball-fall.la-3x > div { -width: 30px; -height: 30px; -margin: 12px; } + width: 30px; + height: 30px; + margin: 12px; } /* -* Animation -*/ + * Animation + */ @-webkit-keyframes ball-fall { -0% { -opacity: 0; --webkit-transform: translateY(-145%); -transform: translateY(-145%); } -10% { -opacity: .5; } -20% { -opacity: 1; --webkit-transform: translateY(0); -transform: translateY(0); } -80% { -opacity: 1; --webkit-transform: translateY(0); -transform: translateY(0); } -90% { -opacity: .5; } -100% { -opacity: 0; --webkit-transform: translateY(145%); -transform: translateY(145%); } } + 0% { + opacity: 0; + -webkit-transform: translateY(-145%); + transform: translateY(-145%); } + 10% { + opacity: .5; } + 20% { + opacity: 1; + -webkit-transform: translateY(0); + transform: translateY(0); } + 80% { + opacity: 1; + -webkit-transform: translateY(0); + transform: translateY(0); } + 90% { + opacity: .5; } + 100% { + opacity: 0; + -webkit-transform: translateY(145%); + transform: translateY(145%); } } @-moz-keyframes ball-fall { -0% { -opacity: 0; --moz-transform: translateY(-145%); -transform: translateY(-145%); } -10% { -opacity: .5; } -20% { -opacity: 1; --moz-transform: translateY(0); -transform: translateY(0); } -80% { -opacity: 1; --moz-transform: translateY(0); -transform: translateY(0); } -90% { -opacity: .5; } -100% { -opacity: 0; --moz-transform: translateY(145%); -transform: translateY(145%); } } + 0% { + opacity: 0; + -moz-transform: translateY(-145%); + transform: translateY(-145%); } + 10% { + opacity: .5; } + 20% { + opacity: 1; + -moz-transform: translateY(0); + transform: translateY(0); } + 80% { + opacity: 1; + -moz-transform: translateY(0); + transform: translateY(0); } + 90% { + opacity: .5; } + 100% { + opacity: 0; + -moz-transform: translateY(145%); + transform: translateY(145%); } } @-o-keyframes ball-fall { -0% { -opacity: 0; --o-transform: translateY(-145%); -transform: translateY(-145%); } -10% { -opacity: .5; } -20% { -opacity: 1; --o-transform: translateY(0); -transform: translateY(0); } -80% { -opacity: 1; --o-transform: translateY(0); -transform: translateY(0); } -90% { -opacity: .5; } -100% { -opacity: 0; --o-transform: translateY(145%); -transform: translateY(145%); } } + 0% { + opacity: 0; + -o-transform: translateY(-145%); + transform: translateY(-145%); } + 10% { + opacity: .5; } + 20% { + opacity: 1; + -o-transform: translateY(0); + transform: translateY(0); } + 80% { + opacity: 1; + -o-transform: translateY(0); + transform: translateY(0); } + 90% { + opacity: .5; } + 100% { + opacity: 0; + -o-transform: translateY(145%); + transform: translateY(145%); } } @keyframes ball-fall { -0% { -opacity: 0; --webkit-transform: translateY(-145%); --moz-transform: translateY(-145%); --o-transform: translateY(-145%); -transform: translateY(-145%); } -10% { -opacity: .5; } -20% { -opacity: 1; --webkit-transform: translateY(0); --moz-transform: translateY(0); --o-transform: translateY(0); -transform: translateY(0); } -80% { -opacity: 1; --webkit-transform: translateY(0); --moz-transform: translateY(0); --o-transform: translateY(0); -transform: translateY(0); } -90% { -opacity: .5; } -100% { -opacity: 0; --webkit-transform: translateY(145%); --moz-transform: translateY(145%); --o-transform: translateY(145%); -transform: translateY(145%); } } + 0% { + opacity: 0; + -webkit-transform: translateY(-145%); + -moz-transform: translateY(-145%); + -o-transform: translateY(-145%); + transform: translateY(-145%); } + 10% { + opacity: .5; } + 20% { + opacity: 1; + -webkit-transform: translateY(0); + -moz-transform: translateY(0); + -o-transform: translateY(0); + transform: translateY(0); } + 80% { + opacity: 1; + -webkit-transform: translateY(0); + -moz-transform: translateY(0); + -o-transform: translateY(0); + transform: translateY(0); } + 90% { + opacity: .5; } + 100% { + opacity: 0; + -webkit-transform: translateY(145%); + -moz-transform: translateY(145%); + -o-transform: translateY(145%); + transform: translateY(145%); } } diff --git a/admin/template_assets/vendor/sweetalert/sweetalert.js b/admin/template_assets/vendor/sweetalert/sweetalert.js new file mode 100644 index 0000000..dc8f5e7 --- /dev/null +++ b/admin/template_assets/vendor/sweetalert/sweetalert.js @@ -0,0 +1 @@ +!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.swal=e():t.swal=e()}(this,function(){return function(t){function e(o){if(n[o])return n[o].exports;var r=n[o]={i:o,l:!1,exports:{}};return t[o].call(r.exports,r,r.exports,e),r.l=!0,r.exports}var n={};return e.m=t,e.c=n,e.d=function(t,n,o){e.o(t,n)||Object.defineProperty(t,n,{configurable:!1,enumerable:!0,get:o})},e.n=function(t){var n=t&&t.__esModule?function(){return t.default}:function(){return t};return e.d(n,"a",n),n},e.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},e.p="",e(e.s=8)}([function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o="swal-button";e.CLASS_NAMES={MODAL:"swal-modal",OVERLAY:"swal-overlay",SHOW_MODAL:"swal-overlay--show-modal",MODAL_TITLE:"swal-title",MODAL_TEXT:"swal-text",ICON:"swal-icon",ICON_CUSTOM:"swal-icon--custom",CONTENT:"swal-content",FOOTER:"swal-footer",BUTTON_CONTAINER:"swal-button-container",BUTTON:o,CONFIRM_BUTTON:o+"--confirm",CANCEL_BUTTON:o+"--cancel",DANGER_BUTTON:o+"--danger",BUTTON_LOADING:o+"--loading",BUTTON_LOADER:o+"__loader"},e.default=e.CLASS_NAMES},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.getNode=function(t){var e="."+t;return document.querySelector(e)},e.stringToNode=function(t){var e=document.createElement("div");return e.innerHTML=t.trim(),e.firstChild},e.insertAfter=function(t,e){var n=e.nextSibling;e.parentNode.insertBefore(t,n)},e.removeNode=function(t){t.parentElement.removeChild(t)},e.throwErr=function(t){throw t=t.replace(/ +(?= )/g,""),"SweetAlert: "+(t=t.trim())},e.isPlainObject=function(t){if("[object Object]"!==Object.prototype.toString.call(t))return!1;var e=Object.getPrototypeOf(t);return null===e||e===Object.prototype},e.ordinalSuffixOf=function(t){var e=t%10,n=t%100;return 1===e&&11!==n?t+"st":2===e&&12!==n?t+"nd":3===e&&13!==n?t+"rd":t+"th"}},function(t,e,n){"use strict";function o(t){for(var n in t)e.hasOwnProperty(n)||(e[n]=t[n])}Object.defineProperty(e,"__esModule",{value:!0}),o(n(25));var r=n(26);e.overlayMarkup=r.default,o(n(27)),o(n(28)),o(n(29));var i=n(0),a=i.default.MODAL_TITLE,s=i.default.MODAL_TEXT,c=i.default.ICON,l=i.default.FOOTER;e.iconMarkup='\n
',e.titleMarkup='\n
\n',e.textMarkup='\n
',e.footerMarkup='\n
\n'},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(1);e.CONFIRM_KEY="confirm",e.CANCEL_KEY="cancel";var r={visible:!0,text:null,value:null,className:"",closeModal:!0},i=Object.assign({},r,{visible:!1,text:"Cancel",value:null}),a=Object.assign({},r,{text:"OK",value:!0});e.defaultButtonList={cancel:i,confirm:a};var s=function(t){switch(t){case e.CONFIRM_KEY:return a;case e.CANCEL_KEY:return i;default:var n=t.charAt(0).toUpperCase()+t.slice(1);return Object.assign({},r,{text:n,value:t})}},c=function(t,e){var n=s(t);return!0===e?Object.assign({},n,{visible:!0}):"string"==typeof e?Object.assign({},n,{visible:!0,text:e}):o.isPlainObject(e)?Object.assign({visible:!0},n,e):Object.assign({},n,{visible:!1})},l=function(t){for(var e={},n=0,o=Object.keys(t);n=0&&w.splice(e,1)}function s(t){var e=document.createElement("style");return t.attrs.type="text/css",l(e,t.attrs),i(t,e),e}function c(t){var e=document.createElement("link");return t.attrs.type="text/css",t.attrs.rel="stylesheet",l(e,t.attrs),i(t,e),e}function l(t,e){Object.keys(e).forEach(function(n){t.setAttribute(n,e[n])})}function u(t,e){var n,o,r,i;if(e.transform&&t.css){if(!(i=e.transform(t.css)))return function(){};t.css=i}if(e.singleton){var l=h++;n=g||(g=s(e)),o=f.bind(null,n,l,!1),r=f.bind(null,n,l,!0)}else t.sourceMap&&"function"==typeof URL&&"function"==typeof URL.createObjectURL&&"function"==typeof URL.revokeObjectURL&&"function"==typeof Blob&&"function"==typeof btoa?(n=c(e),o=p.bind(null,n,e),r=function(){a(n),n.href&&URL.revokeObjectURL(n.href)}):(n=s(e),o=d.bind(null,n),r=function(){a(n)});return o(t),function(e){if(e){if(e.css===t.css&&e.media===t.media&&e.sourceMap===t.sourceMap)return;o(t=e)}else r()}}function f(t,e,n,o){var r=n?"":o.css;if(t.styleSheet)t.styleSheet.cssText=x(e,r);else{var i=document.createTextNode(r),a=t.childNodes;a[e]&&t.removeChild(a[e]),a.length?t.insertBefore(i,a[e]):t.appendChild(i)}}function d(t,e){var n=e.css,o=e.media;if(o&&t.setAttribute("media",o),t.styleSheet)t.styleSheet.cssText=n;else{for(;t.firstChild;)t.removeChild(t.firstChild);t.appendChild(document.createTextNode(n))}}function p(t,e,n){var o=n.css,r=n.sourceMap,i=void 0===e.convertToAbsoluteUrls&&r;(e.convertToAbsoluteUrls||i)&&(o=y(o)),r&&(o+="\n/*# sourceMappingURL=data:application/json;base64,"+btoa(unescape(encodeURIComponent(JSON.stringify(r))))+" */");var a=new Blob([o],{type:"text/css"}),s=t.href;t.href=URL.createObjectURL(a),s&&URL.revokeObjectURL(s)}var m={},b=function(t){var e;return function(){return void 0===e&&(e=t.apply(this,arguments)),e}}(function(){return window&&document&&document.all&&!window.atob}),v=function(t){var e={};return function(n){return void 0===e[n]&&(e[n]=t.call(this,n)),e[n]}}(function(t){return document.querySelector(t)}),g=null,h=0,w=[],y=n(15);t.exports=function(t,e){if("undefined"!=typeof DEBUG&&DEBUG&&"object"!=typeof document)throw new Error("The style-loader cannot be used in a non-browser environment");e=e||{},e.attrs="object"==typeof e.attrs?e.attrs:{},e.singleton||(e.singleton=b()),e.insertInto||(e.insertInto="head"),e.insertAt||(e.insertAt="bottom");var n=r(t,e);return o(n,e),function(t){for(var i=[],a=0;athis.length)&&-1!==this.indexOf(t,e)}),Array.prototype.includes||Object.defineProperty(Array.prototype,"includes",{value:function(t,e){if(null==this)throw new TypeError('"this" is null or not defined');var n=Object(this),o=n.length>>>0;if(0===o)return!1;for(var r=0|e,i=Math.max(r>=0?r:o-Math.abs(r),0);i=0&&(t._idleTimeoutId=setTimeout(function(){t._onTimeout&&t._onTimeout()},e))},n(19),e.setImmediate=setImmediate,e.clearImmediate=clearImmediate},function(t,e,n){(function(t,e){!function(t,n){"use strict";function o(t){"function"!=typeof t&&(t=new Function(""+t));for(var e=new Array(arguments.length-1),n=0;n1)for(var n=1;n',e.default=e.modalMarkup},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(0),r=o.default.OVERLAY,i='
\n
';e.default=i},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(0),r=o.default.ICON;e.errorIconMarkup=function(){var t=r+"--error",e=t+"__line";return'\n
\n \n \n
\n '},e.warningIconMarkup=function(){var t=r+"--warning";return'\n \n \n \n '},e.successIconMarkup=function(){var t=r+"--success";return'\n \n \n\n
\n
\n '}},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(0),r=o.default.CONTENT;e.contentMarkup='\n
\n\n
\n'},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(0),r=o.default.BUTTON_CONTAINER,i=o.default.BUTTON,a=o.default.BUTTON_LOADER;e.buttonMarkup='\n
\n\n \n\n
\n
\n
\n
\n
\n\n
\n'},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(4),r=n(2),i=n(0),a=i.default.ICON,s=i.default.ICON_CUSTOM,c=["error","warning","success","info"],l={error:r.errorIconMarkup(),warning:r.warningIconMarkup(),success:r.successIconMarkup()},u=function(t,e){var n=a+"--"+t;e.classList.add(n);var o=l[t];o&&(e.innerHTML=o)},f=function(t,e){e.classList.add(s);var n=document.createElement("img");n.src=t,e.appendChild(n)},d=function(t){if(t){var e=o.injectElIntoModal(r.iconMarkup);c.includes(t)?u(t,e):f(t,e)}};e.default=d},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(2),r=n(4),i=function(t){navigator.userAgent.includes("AppleWebKit")&&(t.style.display="none",t.offsetHeight,t.style.display="")};e.initTitle=function(t){if(t){var e=r.injectElIntoModal(o.titleMarkup);e.textContent=t,i(e)}},e.initText=function(t){if(t){var e=document.createDocumentFragment();t.split("\n").forEach(function(t,n,o){e.appendChild(document.createTextNode(t)),n0}).forEach(function(t){b.classList.add(t)})}n&&t===c.CONFIRM_KEY&&b.classList.add(s),b.textContent=r;var g={};return g[t]=i,f.setActionValue(g),f.setActionOptionsFor(t,{closeModal:p}),b.addEventListener("click",function(){return u.onAction(t)}),m},p=function(t,e){var n=r.injectElIntoModal(l.footerMarkup);for(var o in t){var i=t[o],a=d(o,i,e);i.visible&&n.appendChild(a)}0===n.children.length&&n.remove()};e.default=p},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(3),r=n(4),i=n(2),a=n(5),s=n(6),c=n(0),l=c.default.CONTENT,u=function(t){t.addEventListener("input",function(t){var e=t.target,n=e.value;a.setActionValue(n)}),t.addEventListener("keyup",function(t){if("Enter"===t.key)return s.onAction(o.CONFIRM_KEY)}),setTimeout(function(){t.focus(),a.setActionValue("")},0)},f=function(t,e,n){var o=document.createElement(e),r=l+"__"+e;o.classList.add(r);for(var i in n){var a=n[i];o[i]=a}"input"===e&&u(o),t.appendChild(o)},d=function(t){if(t){var e=r.injectElIntoModal(i.contentMarkup),n=t.element,o=t.attributes;"string"==typeof n?f(e,n,o):e.appendChild(n)}};e.default=d},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(1),r=n(2),i=function(){var t=o.stringToNode(r.overlayMarkup);document.body.appendChild(t)};e.default=i},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(5),r=n(6),i=n(1),a=n(3),s=n(0),c=s.default.MODAL,l=s.default.BUTTON,u=s.default.OVERLAY,f=function(t){t.preventDefault(),v()},d=function(t){t.preventDefault(),g()},p=function(t){if(o.default.isOpen)switch(t.key){case"Escape":return r.onAction(a.CANCEL_KEY)}},m=function(t){if(o.default.isOpen)switch(t.key){case"Tab":return f(t)}},b=function(t){if(o.default.isOpen)return"Tab"===t.key&&t.shiftKey?d(t):void 0},v=function(){var t=i.getNode(l);t&&(t.tabIndex=0,t.focus())},g=function(){var t=i.getNode(c),e=t.querySelectorAll("."+l),n=e.length-1,o=e[n];o&&o.focus()},h=function(t){t[t.length-1].addEventListener("keydown",m)},w=function(t){t[0].addEventListener("keydown",b)},y=function(){var t=i.getNode(c),e=t.querySelectorAll("."+l);e.length&&(h(e),w(e))},x=function(t){if(i.getNode(u)===t.target)return r.onAction(a.CANCEL_KEY)},_=function(t){var e=i.getNode(u);e.removeEventListener("click",x),t&&e.addEventListener("click",x)},k=function(t){o.default.timer&&clearTimeout(o.default.timer),t&&(o.default.timer=window.setTimeout(function(){return r.onAction(a.CANCEL_KEY)},t))},O=function(t){t.closeOnEsc?document.addEventListener("keyup",p):document.removeEventListener("keyup",p),t.dangerMode?v():g(),y(),_(t.closeOnClickOutside),k(t.timer)};e.default=O},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(1),r=n(3),i=n(37),a=n(38),s={title:null,text:null,icon:null,buttons:r.defaultButtonList,content:null,className:null,closeOnClickOutside:!0,closeOnEsc:!0,dangerMode:!1,timer:null},c=Object.assign({},s);e.setDefaults=function(t){c=Object.assign({},s,t)};var l=function(t){var e=t&&t.button,n=t&&t.buttons;return void 0!==e&&void 0!==n&&o.throwErr("Cannot set both 'button' and 'buttons' options!"),void 0!==e?{confirm:e}:n},u=function(t){return o.ordinalSuffixOf(t+1)},f=function(t,e){o.throwErr(u(e)+" argument ('"+t+"') is invalid")},d=function(t,e){var n=t+1,r=e[n];o.isPlainObject(r)||void 0===r||o.throwErr("Expected "+u(n)+" argument ('"+r+"') to be a plain object")},p=function(t,e){var n=t+1,r=e[n];void 0!==r&&o.throwErr("Unexpected "+u(n)+" argument ("+r+")")},m=function(t,e,n,r){var i=typeof e,a="string"===i,s=e instanceof Element;if(a){if(0===n)return{text:e};if(1===n)return{text:e,title:r[0]};if(2===n)return d(n,r),{icon:e};f(e,n)}else{if(s&&0===n)return d(n,r),{content:e};if(o.isPlainObject(e))return p(n,r),e;f(e,n)}};e.getOpts=function(){for(var t=[],e=0;e= 0;) n = n.replace(" " + t + " ", " "); - e.className = n.replace(/^\s+|\s+$/g, "") - } - }, - i = function(e) { - var n = t.createElement("div"); - return n.appendChild(t.createTextNode(e)), n.innerHTML - }, - u = function(e) { - e.style.opacity = "", e.style.display = "block" - }, - c = function(e) { - if (e && !e.length) return u(e); - for (var t = 0; t < e.length; ++t) u(e[t]) - }, - d = function(e) { - e.style.opacity = "", e.style.display = "none" - }, - f = function(e) { - if (e && !e.length) return d(e); - for (var t = 0; t < e.length; ++t) d(e[t]) - }, - p = function(e, t) { - for (var n = t.parentNode; null !== n;) { - if (n === e) return !0; - n = n.parentNode - } - return !1 - }, - m = function(e) { - e.style.left = "-9999px", e.style.display = "block"; - var t, n = e.clientHeight; - return t = "undefined" != typeof getComputedStyle ? parseInt(getComputedStyle(e).getPropertyValue("padding-top"), 10) : parseInt(e.currentStyle.padding), e.style.left = "", e.style.display = "none", "-" + parseInt((n + t) / 2) + "px" - }, - v = function(e, t) { - if (+e.style.opacity < 1) { - t = t || 16, e.style.opacity = 0, e.style.display = "block"; - var n = +new Date, - o = function(e) { - function t() { - return e.apply(this, arguments) - } - return t.toString = function() { - return e.toString() - }, t - }(function() { - e.style.opacity = +e.style.opacity + (new Date - n) / 100, n = +new Date, +e.style.opacity < 1 && setTimeout(o, t) - }); - o() - } - e.style.display = "block" - }, - y = function(e, t) { - t = t || 16, e.style.opacity = 1; - var n = +new Date, - o = function(e) { - function t() { - return e.apply(this, arguments) - } - return t.toString = function() { - return e.toString() - }, t - }(function() { - e.style.opacity = +e.style.opacity - (new Date - n) / 100, n = +new Date, +e.style.opacity > 0 ? setTimeout(o, t) : e.style.display = "none" - }); - o() - }, - h = function(n) { - if ("function" == typeof MouseEvent) { - var o = new MouseEvent("click", { - view: e, - bubbles: !1, - cancelable: !0 - }); - n.dispatchEvent(o) - } else if (t.createEvent) { - var a = t.createEvent("MouseEvents"); - a.initEvent("click", !1, !1), n.dispatchEvent(a) - } else t.createEventObject ? n.fireEvent("onclick") : "function" == typeof n.onclick && n.onclick() - }, - b = function(t) { - "function" == typeof t.stopPropagation ? (t.stopPropagation(), t.preventDefault()) : e.event && e.event.hasOwnProperty("cancelBubble") && (e.event.cancelBubble = !0) - }; - a.hasClass = r, a.addClass = s, a.removeClass = l, a.escapeHtml = i, a._show = u, a.show = c, a._hide = d, a.hide = f, a.isDescendant = p, a.getTopMargin = m, a.fadeIn = v, a.fadeOut = y, a.fireClick = h, a.stopEventPropagation = b - }, {}], - 5: [function(t, o, a) { - Object.defineProperty(a, "__esModule", { - value: !0 - }); - var r = t("./handle-dom"), - s = t("./handle-swal-dom"), - l = function(t, o, a) { - var l = t || e.event, - i = l.keyCode || l.which, - u = a.querySelector("button.confirm"), - c = a.querySelector("button.cancel"), - d = a.querySelectorAll("button[tabindex]"); - if (-1 !== [9, 13, 32, 27].indexOf(i)) { - for (var f = l.target || l.srcElement, p = -1, m = 0; m < d.length; m++) - if (f === d[m]) { - p = m; - break - } - 9 === i ? (f = -1 === p ? u : p === d.length - 1 ? d[0] : d[p + 1], r.stopEventPropagation(l), f.focus(), o.confirmButtonColor && s.setFocusStyle(f, o.confirmButtonColor)) : 13 === i ? ("INPUT" === f.tagName && (f = u, u.focus()), f = -1 === p ? u : n) : 27 === i && o.allowEscapeKey === !0 ? (f = c, r.fireClick(f, l)) : f = n - } - }; - a["default"] = l, o.exports = a["default"] - }, { - "./handle-dom": 4, - "./handle-swal-dom": 6 - }], - 6: [function(n, o, a) { - var r = function(e) { - return e && e.__esModule ? e : { - "default": e - } - }; - Object.defineProperty(a, "__esModule", { - value: !0 - }); - var s = n("./utils"), - l = n("./handle-dom"), - i = n("./default-params"), - u = r(i), - c = n("./injected-html"), - d = r(c), - f = ".sweet-alert", - p = ".sweet-overlay", - m = function() { - var e = t.createElement("div"); - for (e.innerHTML = d["default"]; e.firstChild;) t.body.appendChild(e.firstChild) - }, - v = function(e) { - function t() { - return e.apply(this, arguments) - } - return t.toString = function() { - return e.toString() - }, t - }(function() { - var e = t.querySelector(f); - return e || (m(), e = v()), e - }), - y = function() { - var e = v(); - return e ? e.querySelector("input") : void 0 - }, - h = function() { - return t.querySelector(p) - }, - b = function(e, t) { - var n = s.hexToRgb(t); - e.style.boxShadow = "0 0 2px rgba(" + n + ", 0.8), inset 0 0 0 1px rgba(0, 0, 0, 0.05)" - }, - g = function(n) { - var o = v(); - l.fadeIn(h(), 10), l.show(o), l.addClass(o, "showSweetAlert"), l.removeClass(o, "hideSweetAlert"), e.previousActiveElement = t.activeElement; - var a = o.querySelector("button.confirm"); - a.focus(), setTimeout(function() { - l.addClass(o, "visible") - }, 500); - var r = o.getAttribute("data-timer"); - if ("null" !== r && "" !== r) { - var s = n; - o.timeout = setTimeout(function() { - var e = (s || null) && "true" === o.getAttribute("data-has-done-function"); - e ? s(null) : sweetAlert.close() - }, r) - } - }, - w = function() { - var e = v(), - t = y(); - l.removeClass(e, "show-input"), t.value = u["default"].inputValue, t.setAttribute("type", u["default"].inputType), t.setAttribute("placeholder", u["default"].inputPlaceholder), C() - }, - C = function(e) { - if (e && 13 === e.keyCode) return !1; - var t = v(), - n = t.querySelector(".sa-input-error"); - l.removeClass(n, "show"); - var o = t.querySelector(".sa-error-container"); - l.removeClass(o, "show") - }, - S = function() { - var e = v(); - e.style.marginTop = l.getTopMargin(v()) - }; - a.sweetAlertInitialize = m, a.getModal = v, a.getOverlay = h, a.getInput = y, a.setFocusStyle = b, a.openModal = g, a.resetInput = w, a.resetInputError = C, a.fixVerticalPosition = S - }, { - "./default-params": 2, - "./handle-dom": 4, - "./injected-html": 7, - "./utils": 9 - }], - 7: [function(e, t, n) { - Object.defineProperty(n, "__esModule", { - value: !0 - }); - var o = '
\n \n \n \n \n
\n \n \n
\n \n \n\n
\n
\n

Title

\n

Text

\n
\n \n
\n
\n
!
\n

Not valid!

\n
\n \n
\n
\n
\n
\n
\n
\n
\n
'; - n["default"] = o, t.exports = n["default"] - }, {}], - 8: [function(e, t, o) { - Object.defineProperty(o, "__esModule", { - value: !0 - }); - var a = e("./utils"), - r = e("./handle-swal-dom"), - s = e("./handle-dom"), - l = ["error", "warning", "info", "success", "input", "prompt"], - i = function(e) { - var t = r.getModal(), - o = t.querySelector("h2"), - i = t.querySelector("p"), - u = t.querySelector("button.cancel"), - c = t.querySelector("button.confirm"); - if (o.innerHTML = e.html ? e.title : s.escapeHtml(e.title).split("\n").join("
"), i.innerHTML = e.html ? e.text : s.escapeHtml(e.text || "").split("\n").join("
"), e.text && s.show(i), e.customClass) s.addClass(t, e.customClass), t.setAttribute("data-custom-class", e.customClass); - else { - var d = t.getAttribute("data-custom-class"); - s.removeClass(t, d), t.setAttribute("data-custom-class", "") - } - if (s.hide(t.querySelectorAll(".sa-icon")), e.type && !a.isIE8()) { - var f = function() { - for (var o = !1, a = 0; a < l.length; a++) - if (e.type === l[a]) { - o = !0; - break - } - if (!o) return logStr("Unknown alert type: " + e.type), { - v: !1 - }; - var i = ["success", "error", "warning", "info"], - u = n; - 1 !== i.indexOf(e.type) && (u = t.querySelector(".sa-icon.sa-" + e.type), s.show(u)); - var c = r.getInput(); - switch (e.type) { - case "success": - s.addClass(u, "animate"), s.addClass(u.querySelector(".sa-tip"), "animateSuccessTip"), s.addClass(u.querySelector(".sa-long"), "animateSuccessLong"); - break; - case "error": - s.addClass(u, "animateErrorIcon"), s.addClass(u.querySelector(".sa-x-mark"), "animateXMark"); - break; - case "warning": - s.addClass(u, "pulseWarning"), s.addClass(u.querySelector(".sa-body"), "pulseWarningIns"), s.addClass(u.querySelector(".sa-dot"), "pulseWarningIns"); - break; - case "input": - case "prompt": - c.setAttribute("type", e.inputType), c.value = e.inputValue, c.setAttribute("placeholder", e.inputPlaceholder), s.addClass(t, "show-input"), setTimeout(function() { - c.focus(), c.addEventListener("keyup", swal.resetInputError) - }, 400) - } - }(); - if ("object" == typeof f) return f.v - } - if (e.imageUrl) { - var p = t.querySelector(".sa-icon.sa-custom"); - p.style.backgroundImage = "url(" + e.imageUrl + ")", s.show(p); - var m = 80, - v = 80; - if (e.imageSize) { - var y = e.imageSize.toString().split("x"), - h = y[0], - b = y[1]; - h && b ? (m = h, v = b) : logStr("Parameter imageSize expects value with format WIDTHxHEIGHT, got " + e.imageSize) - } - p.setAttribute("style", p.getAttribute("style") + "width:" + m + "px; height:" + v + "px") - } - t.setAttribute("data-has-cancel-button", e.showCancelButton), e.showCancelButton ? u.style.display = "inline-block" : s.hide(u), t.setAttribute("data-has-confirm-button", e.showConfirmButton), e.showConfirmButton ? c.style.display = "inline-block" : s.hide(c), e.cancelButtonText && (u.innerHTML = s.escapeHtml(e.cancelButtonText)), e.confirmButtonText && (c.innerHTML = s.escapeHtml(e.confirmButtonText)), e.confirmButtonColor && (c.style.backgroundColor = e.confirmButtonColor, c.style.borderLeftColor = e.confirmLoadingButtonColor, c.style.borderRightColor = e.confirmLoadingButtonColor, r.setFocusStyle(c, e.confirmButtonColor)), t.setAttribute("data-allow-outside-click", e.allowOutsideClick); - var g = e.doneFunction ? !0 : !1; - t.setAttribute("data-has-done-function", g), e.animation ? "string" == typeof e.animation ? t.setAttribute("data-animation", e.animation) : t.setAttribute("data-animation", "pop") : t.setAttribute("data-animation", "none"), t.setAttribute("data-timer", e.timer) - }; - o["default"] = i, t.exports = o["default"] - }, { - "./handle-dom": 4, - "./handle-swal-dom": 6, - "./utils": 9 - }], - 9: [function(t, n, o) { - Object.defineProperty(o, "__esModule", { - value: !0 - }); - var a = function(e, t) { - for (var n in t) t.hasOwnProperty(n) && (e[n] = t[n]); - return e - }, - r = function(e) { - var t = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(e); - return t ? parseInt(t[1], 16) + ", " + parseInt(t[2], 16) + ", " + parseInt(t[3], 16) : null - }, - s = function() { - return e.attachEvent && !e.addEventListener - }, - l = function(t) { - e.console && e.console.log("SweetAlert: " + t) - }, - i = function(e, t) { - e = String(e).replace(/[^0-9a-f]/gi, ""), e.length < 6 && (e = e[0] + e[0] + e[1] + e[1] + e[2] + e[2]), t = t || 0; - var n, o, a = "#"; - for (o = 0; 3 > o; o++) n = parseInt(e.substr(2 * o, 2), 16), n = Math.round(Math.min(Math.max(0, n + n * t), 255)).toString(16), a += ("00" + n).substr(n.length); - return a - }; - o.extend = a, o.hexToRgb = r, o.isIE8 = s, o.logStr = l, o.colorLuminance = i - }, {}] - }, {}, [1]), "function" == typeof define && define.amd ? define(function() { - return sweetAlert - }) : "undefined" != typeof module && module.exports && (module.exports = sweetAlert) - }(window, document); \ No newline at end of file +!function(e,t,n){"use strict";!function o(e,t,n){function a(s,l){if(!t[s]){if(!e[s]){var i="function"==typeof require&&require;if(!l&&i)return i(s,!0);if(r)return r(s,!0);var u=new Error("Cannot find module '"+s+"'");throw u.code="MODULE_NOT_FOUND",u}var c=t[s]={exports:{}};e[s][0].call(c.exports,function(t){var n=e[s][1][t];return a(n?n:t)},c,c.exports,o,e,t,n)}return t[s].exports}for(var r="function"==typeof require&&require,s=0;s=0;)n=n.replace(" "+t+" "," ");e.className=n.replace(/^\s+|\s+$/g,"")}},i=function(e){var n=t.createElement("div");return n.appendChild(t.createTextNode(e)),n.innerHTML},u=function(e){e.style.opacity="",e.style.display="block"},c=function(e){if(e&&!e.length)return u(e);for(var t=0;t0?setTimeout(o,t):e.style.display="none"});o()},h=function(n){if("function"==typeof MouseEvent){var o=new MouseEvent("click",{view:e,bubbles:!1,cancelable:!0});n.dispatchEvent(o)}else if(t.createEvent){var a=t.createEvent("MouseEvents");a.initEvent("click",!1,!1),n.dispatchEvent(a)}else t.createEventObject?n.fireEvent("onclick"):"function"==typeof n.onclick&&n.onclick()},b=function(t){"function"==typeof t.stopPropagation?(t.stopPropagation(),t.preventDefault()):e.event&&e.event.hasOwnProperty("cancelBubble")&&(e.event.cancelBubble=!0)};a.hasClass=r,a.addClass=s,a.removeClass=l,a.escapeHtml=i,a._show=u,a.show=c,a._hide=d,a.hide=f,a.isDescendant=p,a.getTopMargin=m,a.fadeIn=v,a.fadeOut=y,a.fireClick=h,a.stopEventPropagation=b},{}],5:[function(t,o,a){Object.defineProperty(a,"__esModule",{value:!0});var r=t("./handle-dom"),s=t("./handle-swal-dom"),l=function(t,o,a){var l=t||e.event,i=l.keyCode||l.which,u=a.querySelector("button.confirm"),c=a.querySelector("button.cancel"),d=a.querySelectorAll("button[tabindex]");if(-1!==[9,13,32,27].indexOf(i)){for(var f=l.target||l.srcElement,p=-1,m=0;m"),i.innerHTML=e.html?e.text:s.escapeHtml(e.text||"").split("\n").join("
"),e.text&&s.show(i),e.customClass)s.addClass(t,e.customClass),t.setAttribute("data-custom-class",e.customClass);else{var d=t.getAttribute("data-custom-class");s.removeClass(t,d),t.setAttribute("data-custom-class","")}if(s.hide(t.querySelectorAll(".sa-icon")),e.type&&!a.isIE8()){var f=function(){for(var o=!1,a=0;ao;o++)n=parseInt(e.substr(2*o,2),16),n=Math.round(Math.min(Math.max(0,n+n*t),255)).toString(16),a+=("00"+n).substr(n.length);return a};o.extend=a,o.hexToRgb=r,o.isIE8=s,o.logStr=l,o.colorLuminance=i},{}]},{},[1]),"function"==typeof define&&define.amd?define(function(){return sweetAlert}):"undefined"!=typeof module&&module.exports&&(module.exports=sweetAlert)}(window,document); \ No newline at end of file