https://plasticseurope.org/wp-content/themes/plasticseurope-theme/dist/scripts/main.js

139);
140	} else if (typeof module === "object" && module.exports) {
141		module.exports = factory( require( "jquery" ) );
142	} else {
143		factory( jQuery );
144	}
145}(function( $ ) {
146
147$.extend( $.fn, {
148
149	// https://jqueryvalidation.org/validate/
150	validate: function( options ) {
151
152		// If nothing is selected, return nothing; can't chain anyway
153		if ( !this.length ) {
154			if ( options && options.debug && window.console ) {
155				console.warn( "Nothing selected, can't validate, returning nothing." );
156			}
157			return;
158		}
159
160		// Check if a validator for this form was already created
161		var validator = $.data( this[ 0 ], "validator" );
162		if ( validator ) {
163			return validator;
164		}
165
166		// Add novalidate tag if HTML5.
167		this.attr( "novalidate", "novalidate" );
168
169		validator = new $.validator( options, this[ 0 ] );
170		$.data( this[ 0 ], "validator", validator );
171
172		if ( validator.settings.onsubmit ) {
173
174			this.on( "click.validate", ":submit", function( event ) {
175
176				// Track the used submit button to properly handle scripted
177				// submits later.
178				validator.submitButton = event.currentTarget;
179
180				// Allow suppressing validation by adding a cancel class to the submit button
181				if ( $( this ).hasClass( "cancel" ) ) {
182					validator.cancelSubmit = true;
183				}
184
185				// Allow suppressing validation by adding the html5 formnovalidate attribute to the submit button
186				if ( $( this ).attr( "formnovalidate" ) !== undefined ) {
187					validator.cancelSubmit = true;
188				}
189			} );
190
191			// Validate the form on submit
192			this.on( "submit.validate", function( event ) {
193				if ( validator.settings.debug ) {
194
195					// Prevent form submit to be able to see console output
196					event.preventDefault();
197				}
198
199				function handle() {
200					var hidden, result;
201
202					// Insert a hidden input as a replacement for the missing submit button
203					// The hidden input is inserted in two cases:
204					//   - A user defined a `submitHandler`
205					//   - There was a pending request due to `remote` method and `stopRequest()`
206					//     was called to submit the form in case it's valid
207					if ( validator.submitButton && ( validator.settings.submitHandler || validator.formSubmitted ) ) {
208						hidden = $( "<input type='hidden'/>" )
209							.attr( "name", validator.submitButton.name )
210							.val( $( validator.submitButton ).val() )
211							.appendTo( validator.currentForm );
212					}
213
214					if ( validator.settings.submitHandler && !validator.settings.debug ) {
215						result = validator.settings.submitHandler.call( validator, validator.currentForm, event );
216						if ( hidden ) {
217
218							// And clean up afterwards; thanks to no-block-scope, hidden can be referenced
219							hidden.remove();
220						}
221						if ( result !== undefined ) {
222							return result;
223						}
224						return false;
225					}
226					return true;
227				}
228
229				// Prevent submit for invalid forms or custom submit handlers
230				if ( validator.cancelSubmit ) {
231					validator.cancelSubmit = false;
232					return handle();
233				}
234				if ( validator.form() ) {
235					if ( validator.pendingRequest ) {
236						validator.formSubmitted = true;
237						return false;
238					}
239					return handle();
240				} else {
241					validator.focusInvalid();
242					return false;
243				}
244			} );
245		}
246
247		return validator;
248	},
249
250	// https://jqueryvalidation.org/valid/
251	valid: function() {
252		var valid, validator, errorList;
253
254		if ( $( this[ 0 ] ).is( "form" ) ) {
255			valid = this.validate().form();
256		} else {
257			errorList = [];
258			valid = true;
259			validator = $( this[ 0 ].form ).validate();
260			this.each( function() {
261				valid = validator.element( this ) && valid;
262				if ( !valid ) {
263					errorList = errorList.concat( validator.errorList );
264				}
265			} );
266			validator.errorList = errorList;
267		}
268		return valid;
269	},
270
271	// https://jqueryvalidation.org/rules/
272	rules: function( command, argument ) {
273		var element = this[ 0 ],
274			isContentEditable = typeof this.attr( "contenteditable" ) !== "undefined" && this.attr( "contenteditable" ) !== "false",
275			settings, staticRules, existingRules, data, param, filtered;
276
277		// If nothing is selected, return empty object; can't chain anyway
278		if ( element == null ) {
279			return;
280		}
281
282		if ( !element.form && isContentEditable ) {
283			element.form = this.closest( "form" )[ 0 ];
284			element.name = this.attr( "name" );
285		}
286
287		if ( element.form == null ) {
288			return;
289		}
290
291		if ( command ) {
292			settings = $.data( element.form, "validator" ).settings;
293			staticRules = settings.rules;
294			existingRules = $.validator.staticRules( element );
295			switch ( command ) {
296			case "add":
297				$.extend( existingRules, $.validator.normalizeRule( argument ) );
298
299				// Remove messages from rules, but allow them to be set separately
300				delete existingRules.messages;
301				staticRules[ element.name ] = existingRules;
302				if ( argument.messages ) {
303					settings.messages[ element.name ] = $.extend( settings.messages[ element.name ], argument.messages );
304				}
305				break;
306			case "remove":
307				if ( !argument ) {
308					delete staticRules[ element.name ];
309					return existingRules;
310				}
311				filtered = {};
312				$.each( argument.split( /\s/ ), function( index, method ) {
313					filtered[ method ] = existingRules[ method ];
314					delete existingRules[ method ];
315				} );
316				return filtered;
317			}
318		}
319
320		data = $.validator.normalizeRules(
321		$.extend(
322			{},
323			$.validator.classRules( element ),
324			$.validator.attributeRules( element ),
325			$.validator.dataRules( element ),
326			$.validator.staticRules( element )
327		), element );
328
329		// Make sure required is at front
330		if ( data.required ) {
331			param = data.required;
332			delete data.required;
333			data = $.extend( { required: param }, data );
334		}
335
336		// Make sure remote is at back
337		if ( data.remote ) {
338			param = data.remote;
339			delete data.remote;
340			data = $.extend( data, { remote: param } );
341		}
342
343		return data;
344	}
345} );
346
347// JQuery trim is deprecated, provide a trim method based on String.prototype.trim
348var trim = function( str ) {
349
350	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim#Polyfill
351	return str.replace( /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "" );
352};
353
354// Custom selectors
355$.extend( $.expr.pseudos || $.expr[ ":" ], {		// '|| $.expr[ ":" ]' here enables backwards compatibility to jQuery 1.7. Can be removed when dropping jQ 1.7.x support
356
357	// https://jqueryvalidation.org/blank-selector/
358	blank: function( a ) {
359		return !trim( "" + $( a ).val() );
360	},
361
362	// https://jqueryvalidation.org/filled-selector/
363	filled: function( a ) {
364		var val = $( a ).val();
365		return val !== null && !!trim( "" + val );
366	},
367
368	// https://jqueryvalidation.org/unchecked-selector/
369	unchecked: function( a ) {
370		return !$( a ).prop( "checked" );
371	}
372} );
373
374// Constructor for validator
375$.validator = function( options, form ) {
376	this.settings = $.extend( true, {}, $.validator.defaults, options );
377	this.currentForm = form;
378	this.init();
379};
380
381// https://jqueryvalidation.org/jQuery.validator.format/
382$.validator.format = function( source, params ) {
383	if ( arguments.length === 1 ) {
384		return function() {
385			var args = $.makeArray( arguments );
386			args.unshift( source );
387			return $.validator.format.apply( this, args );
388		};
389	}
390	if ( params === undefined ) {
391		return source;
392	}
393	if ( arguments.length > 2 && params.constructor !== Array  ) {
394		params = $.makeArray( arguments ).slice( 1 );
395	}
396	if ( params.constructor !== Array ) {
397		params = [ params ];
398	}
399	$.each( params, function( i, n ) {
400		source = source.replace( new RegExp( "\\{" + i + "\\}", "g" ), function() {
401			return n;
402		} );
403	} );
404	return source;
405};
406
407$.extend( $.validator, {
408
409	defaults: {
410		messages: {},
411		groups: {},
412		rules: {},
413		errorClass: "error",
414		pendingClass: "pending",
415		validClass: "valid",
416		errorElement: "label",
417		focusCleanup: false,
418		focusInvalid: true,
419		ariaDescribedByCleanup: false,
420		errorContainer: $( [] ),
421		errorLabelContainer: $( [] ),
422		onsubmit: true,
423		ignore: ":hidden",
424		ignoreTitle: false,
425		customElements: [],
426		onfocusin: function( element ) {
427			this.lastActive = element;
428
429			// Hide error label and remove error class on focus if enabled
430			if ( this.settings.focusCleanup ) {
431				if ( this.settings.unhighlight ) {
432					this.settings.unhighlight.call( this, element, this.settings.errorClass, this.settings.validClass );
433				}
434				this.hideThese( this.errorsFor( element ) );
435			}
436		},
437		onfocusout: function( element ) {
438			if ( !this.checkable( element ) && ( element.name in this.submitted || !this.optional( element ) ) ) {
439				this.element( element );
440			}
441		},
442		onkeyup: function( element, event ) {
443
444			// Avoid revalidate the field when pressing one of the following keys
445			// Shift       => 16
446			// Ctrl        => 17
447			// Alt         => 18
448			// Caps lock   => 20
449			// End         => 35
450			// Home        => 36
451			// Left arrow  => 37
452			// Up arrow    => 38
453			// Right arrow => 39
454			// Down arrow  => 40
455			// Insert      => 45
456			// Num lock    => 144
457			// AltGr key   => 225
458			var excludedKeys = [
459				16, 17, 18, 20, 35, 36, 37,
460				38, 39, 40, 45, 144, 225
461			];
462
463			if ( event.which === 9 && this.elementValue( element ) === "" || $.inArray( event.keyCode, excludedKeys ) !== -1 ) {
464				return;
465			} else if ( element.name in this.submitted || element.name in this.invalid ) {
466				this.element( element );
467			}
468		},
469		onclick: function( element ) {
470
471			// Click on selects, radiobuttons and checkboxes
472			if ( element.name in this.submitted ) {
473				this.element( element );
474
475			// Or option elements, check parent select in that case
476			} else if ( element.parentNode.name in this.submitted ) {
477				this.element( element.parentNode );
478			}
479		},
480		highlight: function( element, errorClass, validClass ) {
481			if ( element.type === "radio" ) {
482				this.findByName( element.name ).addClass( errorClass ).removeClass( validClass );
483			} else {
484				$( element ).addClass( errorClass ).removeClass( validClass );
485			}
486		},
487		unhighlight: function( element, errorClass, validClass ) {
488			if ( element.type === "radio" ) {
489				this.findByName( element.name ).removeClass( errorClass ).addClass( validClass );
490			} else {
491				$( element ).removeClass( errorClass ).addClass( validClass );
492			}
493		}
494	},
495
496	// https://jqueryvalidation.org/jQuery.validator.setDefaults/
497	setDefaults: function( settings ) {
498		$.extend( $.validator.defaults, settings );
499	},
500
501	messages: {
502		required: "This field is required.",
503		remote: "Please fix this field.",
504		email: "Please enter a valid email address.",
505		url: "Please enter a valid URL.",
506		date: "Please enter a valid date.",
507		dateISO: "Please enter a valid date (ISO).",
508		number: "Please enter a valid number.",
509		digits: "Please enter only digits.",
510		equalTo: "Please enter the same value again.",
511		maxlength: $.validator.format( "Please enter no more than {0} characters." ),
512		minlength: $.validator.format( "Please enter at least {0} characters." ),
513		rangelength: $.validator.format( "Please enter a value between {0} and {1} characters long." ),
514		range: $.validator.format( "Please enter a value between {0} and {1}." ),
515		max: $.validator.format( "Please enter a value less than or equal to {0}." ),
516		min: $.validator.format( "Please enter a value greater than or equal to {0}." ),
517		step: $.validator.format( "Please enter a multiple of {0}." )
518	},
519
520	autoCreateRanges: false,
521
522	prototype: {
523
524		init: function() {
525			this.labelContainer = $( this.settings.errorLabelContainer );
526			this.errorContext = this.labelContainer.length && this.labelContainer || $( this.currentForm );
527			this.containers = $( this.settings.errorContainer ).add( this.settings.errorLabelContainer );
528			this.submitted = {};
529			this.valueCache = {};
530			this.pendingRequest = 0;
531			this.pending = {};
532			this.invalid = {};
533			this.reset();
534
535			var currentForm = this.currentForm,
536				groups = ( this.groups = {} ),
537				rules;
538			$.each( this.settings.groups, function( key, value ) {
539				if ( typeof value === "string" ) {
540					value = value.split( /\s/ );
541				}
542				$.each( value, function( index, name ) {
543					groups[ name ] = key;
544				} );
545			} );
546			rules = this.settings.rules;
547			$.each( rules, function( key, value ) {
548				rules[ key ] = $.validator.normalizeRule( value );
549			} );
550
551			function delegate( event ) {
552				var isContentEditable = typeof $( this ).attr( "contenteditable" ) !== "undefined" && $( this ).attr( "contenteditable" ) !== "false";
553
554				// Set form expando on contenteditable
555				if ( !this.form && isContentEditable ) {
556					this.form = $( this ).closest( "form" )[ 0 ];
557					this.name = $( this ).attr( "name" );
558				}
559
560				// Ignore the element if it belongs to another form. This will happen mainly
561				// when setting the `form` attribute of an input to the id of another form.
562				if ( currentForm !== this.form ) {
563					return;
564				}
565
566				var validator = $.data( this.form, "validator" ),
567					eventType = "on" + event.type.replace( /^validate/, "" ),
568					settings = validator.settings;
569				if ( settings[ eventType ] && !$( this ).is( settings.ignore ) ) {
570					settings[ eventType ].call( validator, this, event );
571				}
572			}
573			var focusListeners = [ ":text", "[type='password']", "[type='file']", "select", "textarea", "[type='number']", "[type='search']",
574								"[type='tel']", "[type='url']", "[type='email']", "[type='datetime']", "[type='date']", "[type='month']",
575								"[type='week']", "[type='time']", "[type='datetime-local']", "[type='range']", "[type='color']",
576								"[type='radio']", "[type='checkbox']", "[contenteditable]", "[type='button']" ];
577			var clickListeners = [ "select", "option", "[type='radio']", "[type='checkbox']" ];
578			$( this.currentForm )
579				.on( "focusin.validate focusout.validate keyup.validate", focusListeners.concat( this.settings.customElements ).join( ", " ), delegate )
580
581				// Support: Chrome, oldIE
582				// "select" is provided as event.target when clicking a option
583				.on( "click.validate", clickListeners.concat( this.settings.customElements ).join( ", " ), delegate );
584
585			if ( this.settings.invalidHandler ) {
586				$( this.currentForm ).on( "invalid-form.validate", this.settings.invalidHandler );
587			}
588		},
589
590		// https://jqueryvalidation.org/Validator.form/
591		form: function() {
592			this.checkForm();
593			$.extend( this.submitted, this.errorMap );
594			this.invalid = $.extend( {}, this.errorMap );
595			if ( !this.valid() ) {
596				$( this.currentForm ).triggerHandler( "invalid-form", [ this ] );
597			}
598			this.showErrors();
599			return this.valid();
600		},
601
602		checkForm: function() {
603			this.prepareForm();
604			for ( var i = 0, elements = ( this.currentElements = this.elements() ); elements[ i ]; i++ ) {
605				this.check( elements[ i ] );
606			}
607			return this.valid();
608		},
609
610		// https://jqueryvalidation.org/Validator.element/
611		element: function( element ) {
612			var cleanElement = this.clean( element ),
613				checkElement = this.validationTargetFor( cleanElement ),
614				v = this,
615				result = true,
616				rs, group;
617
618			if ( checkElement === undefined ) {
619				delete this.invalid[ cleanElement.name ];
620			} else {
621				this.prepareElement( checkElement );
622				this.currentElements = $( checkElement );
623
624				// If this element is grouped, then validate all group elements already
625				// containing a value
626				group = this.groups[ checkElement.name ];
627				if ( group ) {
628					$.each( this.groups, function( name, testgroup ) {
629						if ( testgroup === group && name !== checkElement.name ) {
630							cleanElement = v.validationTargetFor( v.clean( v.findByName( name ) ) );
631
632							// Don't want to check fields if a user hasn't gotten to them yet
633							if ( cleanElement && cleanElement.name in v.invalid ) {
634								v.currentElements.pushStack( cleanElement );
635								result = v.check( cleanElement ) && result;
636							}
637						}
638					} );
639				}
640
641				rs = this.check( checkElement ) !== false;
642				result = result && rs;
643				if ( rs ) {
644					this.invalid[ checkElement.name ] = false;
645				} else {
646					this.invalid[ checkElement.name ] = true;
647				}
648
649				if ( !this.numberOfInvalids() ) {
650
651					// Hide error containers on last error
652					this.toHide = this.toHide.add( this.containers );
653				}
654				this.showErrors();
655
656				// Add aria-invalid status for screen readers
657				$( element ).attr( "aria-invalid", !rs );
658			}
659
660			return result;
661		},
662
663		// https://jqueryvalidation.org/Validator.showErrors/
664		showErrors: function( errors ) {
665			if ( errors ) {
666				var validator = this;
667
668				// Add items to error list and map
669				$.extend( this.errorMap, errors );
670				this.errorList = $.map( this.errorMap, function( message, name ) {
671					return {
672						message: message,
673						element: validator.findByName( name )[ 0 ]
674					};
675				} );
676
677				// Remove items from success list
678				this.successList = $.grep( this.successList, function( element ) {
679					return !( element.name in errors );
680				} );
681			}
682			if ( this.settings.showErrors ) {
683				this.settings.showErrors.call( this, this.errorMap, this.errorList );
684			} else {
685				this.defaultShowErrors();
686			}
687		},
688
689		// https://jqueryvalidation.org/Validator.resetForm/
690		resetForm: function() {
691			if ( $.fn.resetForm ) {
692				$( this.currentForm ).resetForm();
693			}
694			this.invalid = {};
695			this.submitted = {};
696			this.prepareForm();
697			this.hideErrors();
698			var elements = this.elements()
699				.removeData( "previousValue" )
700				.removeAttr( "aria-invalid" );
701
702			this.resetElements( elements );
703		},
704
705		resetElements: function( elements ) {
706			var i;
707
708			if ( this.settings.unhighlight ) {
709				for ( i = 0; elements[ i ]; i++ ) {
710					this.settings.unhighlight.call( this, elements[ i ],
711						this.settings.errorClass, "" );
712					this.findByName( elements[ i ].name ).removeClass( this.settings.validClass );
713				}
714			} else {
715				elements
716					.removeClass( this.settings.errorClass )
717					.removeClass( this.settings.validClass );
718			}
719		},
720
721		numberOfInvalids: function() {
722			return this.objectLength( this.invalid );
723		},
724
725		objectLength: function( obj ) {
726			/* jshint unused: false */
727			var count = 0,
728				i;
729			for ( i in obj ) {
730
731				// This check allows counting elements with empty error
732				// message as invalid elements
733				if ( obj[ i ] !== undefined && obj[ i ] !== null && obj[ i ] !== false ) {
734					count++;
735				}
736			}
737			return count;
738		},
739
740		hideErrors: function() {
741			this.hideThese( this.toHide );
742		},
743		addErrorAriaDescribedBy: function( element, error, updateGroupMembers ) {
744			updateGroupMembers = ( updateGroupMembers === undefined ) ? false : updateGroupMembers;
745
746			var errorID, v, group,
747				describedBy = $( element ).attr( "aria-describedby" );
748				errorID = error.attr( "id" );
749
750			// Respect existing non-error aria-describedby
751			if ( !describedBy ) {
752				describedBy = errorID;
753			} else if ( !describedBy.match( new RegExp( "\\b" + this.escapeCssMeta( errorID ) + "\\b" ) ) ) {
754
755				// Add to end of list if not already present
756				describedBy += " " + errorID;
757			}
758
759			$( element ).attr( "aria-describedby", describedBy );
760
761			if ( updateGroupMembers ) {
762
763				// If this element is grouped, then assign to all elements in the same group
764				group = this.groups[ element.name ];
765				if ( group ) {
766					v = this;
767					$.each( v.groups, function( name, testgroup ) {
768						if ( testgroup === group ) {
769							v.addErrorAriaDescribedBy( $( "[name='" + v.escapeCssMeta( name ) + "']", v.currentForm ), error, false );
770						}
771					} );
772				}
773			}
774		},
775
776		removeErrorAriaDescribedBy: function( element, error ) {
777
778			var describedBy = $( element ).attr( "aria-describedby" ),
779				describedByIds = describedBy.split( " " ),
780				errorID = error.attr( "id" ),
781				ind = describedByIds.indexOf( errorID );
782
783			if ( ind > -1 ) {
784				describedByIds.splice( ind, 1 );
785			}
786
787			if ( describedByIds.length ) {
788				$( element ).attr( "aria-describedby", describedByIds.join( " " ) );
789			} else {
790				$( element ).removeAttr( "aria-describedby" );
791			}
792
793		},
794
795		hideThese: function( errors ) {
796
797			for ( var i = 0; errors[ i ]; i++ ) {
798				var error = $( errors[ i ] ),
799					errorID = error.attr( "id" ) ? this.escapeCssMeta( error.attr( "id" ) ) : undefined,
800					element = ( errorID ) ? this.elements().filter( '[aria-describedby~="' + errorID + '"]' ) : [];
801
802				if ( this.settings.ariaDescribedByCleanup && element.length ) {
803					this.removeErrorAriaDescribedBy( element, error );
804				}
805
806				if ( !error.is( this.containers ) ) {
807					error.text( "" );
808				}
809
810				this.addWrapper( error ).hide();
811			}
812
813		},
814
815		valid: function() {
816			return this.size() === 0;
817		},
818
819		size: function() {
820			return this.errorList.length;
821		},
822
823		focusInvalid: function() {
824			if ( this.settings.focusInvalid ) {
825				try {
826					$( this.findLastActive() || this.errorList.length && this.errorList[ 0 ].element || [] )
827					.filter( ":visible" )
828					.trigger( "focus" )
829
830					// Manually trigger focusin event; without it, focusin handler isn't called, findLastActive won't have anything to find
831					.trigger( "focusin" );
832				} catch ( e ) {
833
834					// Ignore IE throwing errors when focusing hidden elements
835				}
836			}
837		},
838
839		findLastActive: function() {
840			var lastActive = this.lastActive;
841			return lastActive && $.grep( this.errorList, function( n ) {
842				return n.element.name === lastActive.name;
843			} ).length === 1 && lastActive;
844		},
845
846		elements: function() {
847			var validator = this,
848				rulesCache = {},
849				selectors = [ "input", "select", "textarea", "[contenteditable]" ],
850				formId = this.currentForm.getAttribute( "id" ),
851				elements;
852
853			// Select all valid inputs inside the form (no submit or reset buttons)
854			elements = $( this.currentForm )
855			.find( selectors.concat( this.settings.customElements ).join( ", " ) )
856			.not( ":submit, :reset, :image, :disabled" )
857			.not( this.settings.ignore );
858
859			// If the form has an ID, also include elements outside the form that have
860			// a form attribute pointing to this form
861			if ( formId ) {
862				elements = elements.add(
863					$( selectors.concat( this.settings.customElements ).join( ", " ) )
864					.filter( "[form='" + validator.escapeCssMeta( formId ) + "']" )
865					.not( ":submit, :reset, :image, :disabled" )
866					.not( this.settings.ignore )
867				);
868			}
869
870			return elements.filter( function() {
871				var name = this.name || $( this ).attr( "name" ); // For contenteditable
872				var isContentEditable = typeof $( this ).attr( "contenteditable" ) !== "undefined" && $( this ).attr( "contenteditable" ) !== "false";
873
874				if ( !name && validator.settings.debug && window.console ) {
875					console.error( "%o has no name assigned", this );
876				}
877
878				// Set form expando on contenteditable
879				if ( isContentEditable ) {
880					this.form = $( this ).closest( "form" )[ 0 ];
881					this.name = name;
882				}
883
884				// Ignore elements that belong to other/nested forms
885				if ( this.form !== validator.currentForm ) {
886					return false;
887				}
888
889				// Select only the first element for each name, and only those with rules specified
890				if ( name in rulesCache || !validator.objectLength( $( this ).rules() ) ) {
891					return false;
892				}
893
894				rulesCache[ name ] = true;
895				return true;
896			} );
897		},
898
899		clean: function( selector ) {
900			return $( selector )[ 0 ];
901		},
902
903		errors: function() {
904			var errorClass = this.settings.errorClass.split( " " ).join( "." );
905			return $( this.settings.errorElement + "." + errorClass, this.errorContext );
906		},
907
908		resetInternals: function() {
909			this.successList = [];
910			this.errorList = [];
911			this.errorMap = {};
912			this.toShow = $( [] );
913			this.toHide = $( [] );
914		},
915
916		reset: function() {
917			this.resetInternals();
918			this.currentElements = $( [] );
919		},
920
921		prepareForm: function() {
922			this.reset();
923			this.toHide = this.errors().add( this.containers );
924		},
925
926		prepareElement: function( element ) {
927			this.reset();
928			this.toHide = this.errorsFor( element );
929		},
930
931		elementValue: function( element ) {
932			var $element = $( element ),
933				type = element.type,
934				isContentEditable = typeof $element.attr( "contenteditable" ) !== "undefined" && $element.attr( "contenteditable" ) !== "false",
935				val, idx;
936
937			if ( type === "radio" || type === "checkbox" ) {
938				return this.findByName( element.name ).filter( ":checked" ).val();
939			} else if ( type === "number" && typeof element.validity !== "undefined" ) {
940				return element.validity.badInput ? "NaN" : $element.val();
941			}
942
943			if ( isContentEditable ) {
944				val = $element.text();
945			} else {
946				val = $element.val();
947			}
948
949			if ( type === "file" ) {
950
951				// Modern browser (chrome & safari)
952				if ( val.substr( 0, 12 ) === "C:\\fakepath\\" ) {
953					return val.substr( 12 );
954				}
955
956				// Legacy browsers
957				// Unix-based path
958				idx = val.lastIndexOf( "/" );
959				if ( idx >= 0 ) {
960					return val.substr( idx + 1 );
961				}
962
963				// Windows-based path
964				idx = val.lastIndexOf( "\\" );
965				if ( idx >= 0 ) {
966					return val.substr( idx + 1 );
967				}
968
969				// Just the file name
970				return val;
971			}
972
973			if ( typeof val === "string" ) {
974				return val.replace( /\r/g, "" );
975			}
976			return val;
977		},
978
979		check: function( element ) {
980			element = this.validationTargetFor( this.clean( element ) );
981
982			var rules = $( element ).rules(),
983				rulesCount = $.map( rules, function( n, i ) {
984					return i;
985				} ).length,
986				dependencyMismatch = false,
987				val = this.elementValue( element ),
988				result, method, rule, normalizer;
989
990			// Abort any pending Ajax request from a previous call to this method.
991			this.abortRequest( element );
992
993			// Prioritize the local normalizer defined for this element over the global one
994			// if the former exists, otherwise user the global one in case it exists.
995			if ( typeof rules.normalizer === "function" ) {
996				normalizer = rules.normalizer;
997			} else if (	typeof this.settings.normalizer === "function" ) {
998				normalizer = this.settings.normalizer;
999			}
1000
1001			// If normalizer is defined, then call it to retreive the changed value instead
1002			// of using the real one.
1003			// Note that `this` in the normalizer is `element`.
1004			if ( normalizer ) {
1005				val = normalizer.call( element, val );
1006
1007				// Delete the normalizer from rules to avoid treating it as a pre-defined method.
1008				delete rules.normalizer;
1009			}
1010
1011			for ( method in rules ) {
1012				rule = { method: method, parameters: rules[ method ] };
1013				try {
1014					result = $.validator.methods[ method ].call( this, val, element, rule.parameters );
1015
1016					// If a method indicates that the field is optional and therefore valid,
1017					// don't mark it as valid when there are no other rules
1018					if ( result === "dependency-mismatch" && rulesCount === 1 ) {
1019						dependencyMismatch = true;
1020						continue;
1021					}
1022					dependencyMismatch = false;
1023
1024					if ( result === "pending" ) {
1025						this.toHide = this.toHide.not( this.errorsFor( element ) );
1026						return;
1027					}
1028
1029					if ( !result ) {
1030						this.formatAndAdd( element, rule );
1031						return false;
1032					}
1033				} catch ( e ) {
1034					if ( this.settings.debug && window.console ) {
1035						console.log( "Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method.", e );
1036					}
1037					if ( e instanceof TypeError ) {
1038						e.message += ".  Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method.";
1039					}
1040
1041					throw e;
1042				}
1043			}
1044			if ( dependencyMismatch ) {
1045				return;
1046			}
1047			if ( this.objectLength( rules ) ) {
1048				this.successList.push( element );
1049			}
1050			return true;
1051		},
1052
1053		// Return the custom message for the given element and validation method
1054		// specified in the element's HTML5 data attribute
1055		// return the generic message if present and no method specific message is present
1056		customDataMessage: function( element, method ) {
1057			return $( element ).data( "msg" + method.charAt( 0 ).toUpperCase() +
1058				method.substring( 1 ).toLowerCase() ) || $( element ).data( "msg" );
1059		},
1060
1061		// Return the custom message for the given element name and validation method
1062		customMessage: function( name, method ) {
1063			var m = this.settings.messages[ name ];
1064			return m && ( m.constructor === String ? m : m[ method ] );
1065		},
1066
1067		// Return the first defined argument, allowing empty strings
1068		findDefined: function() {
1069			for ( var i = 0; i < arguments.length; i++ ) {
1070				if ( arguments[ i ] !== undefined ) {
1071					return arguments[ i ];
1072				}
1073			}
1074			return undefined;
1075		},
1076
1077		// The second parameter 'rule' used to be a string, and extended to an object literal
1078		// of the following form:
1079		// rule = {
1080		//     method: "method name",
1081		//     parameters: "the given method parameters"
1082		// }
1083		//
1084		// The old behavior still supported, kept to maintain backward compatibility with
1085		// old code, and will be removed in the next major release.
1086		defaultMessage: function( element, rule ) {
1087			if ( typeof rule === "string" ) {
1088				rule = { method: rule };
1089			}
1090
1091			var message = this.findDefined(
1092					this.customMessage( element.name, rule.method ),
1093					this.customDataMessage( element, rule.method ),
1094
1095					// 'title' is never undefined, so handle empty string as undefined
1096					!this.settings.ignoreTitle && element.title || undefined,
1097					$.validator.messages[ rule.method ],
1098					"<strong>Warning: No message defined for " + element.name + "</strong>"
1099				),
1100				theregex = /\$?\{(\d+)\}/g;
1101			if ( typeof message === "function" ) {
1102				message = message.call( this, rule.parameters, element );
1103			} else if ( theregex.test( message ) ) {
1104				message = $.validator.format( message.replace( theregex, "{$1}" ), rule.parameters );
1105			}
1106
1107			return message;
1108		},
1109
1110		formatAndAdd: function( element, rule ) {
1111			var message = this.defaultMessage( element, rule );
1112
1113			this.errorList.push( {
1114				message: message,
1115				element: element,
1116				method: rule.method
1117			} );
1118
1119			this.errorMap[ element.name ] = message;
1120			this.submitted[ element.name ] = message;
1121		},
1122
1123		addWrapper: function( toToggle ) {
1124			if ( this.settings.wrapper ) {
1125				toToggle = toToggle.add( toToggle.parent( this.settings.wrapper ) );
1126			}
1127			return toToggle;
1128		},
1129
1130		defaultShowErrors: function() {
1131			var i, elements, error;
1132
1133			for ( i = 0; this.errorList[ i ]; i++ ) {
1134				error = this.errorList[ i ];
1135				if ( this.settings.highlight ) {
1136					this.settings.highlight.call( this, error.element, this.settings.errorClass, this.settings.validClass );
1137				}
1138				this.showLabel( error.element, error.message );
1139			}
1140
1141			if ( this.errorList.length ) {
1142				this.toShow = this.toShow.add( this.containers );
1143			}
1144
1145			if ( this.settings.success ) {
1146				for ( i = 0; this.successList[ i ]; i++ ) {
1147					this.showLabel( this.successList[ i ] );
1148				}
1149			}
1150
1151			if ( this.settings.unhighlight ) {
1152				for ( i = 0, elements = this.validElements(); elements[ i ]; i++ ) {
1153					this.settings.unhighlight.call( this, elements[ i ], this.settings.errorClass, this.settings.validClass );
1154				}
1155			}
1156
1157			this.toHide = this.toHide.not( this.toShow );
1158			this.hideErrors();
1159			this.addWrapper( this.toShow ).show();
1160		},
1161
1162		validElements: function() {
1163			return this.currentElements.not( this.invalidElements() );
1164		},
1165
1166		invalidElements: function() {
1167			return $( this.errorList ).map( function() {
1168				return this.element;
1169			} );
1170		},
1171
1172		showLabel: function( element, message ) {
1173			var place,
1174				error = this.errorsFor( element ),
1175				elementID = this.idOrName( element ),
1176				describedBy = $( element ).attr( "aria-describedby" );
1177
1178			if ( error.length ) {
1179
1180				// Non-label error exists but is not currently associated with element via aria-describedby
1181				if ( error.closest( "label[for='" + this.escapeCssMeta( elementID ) + "']" ).length === 0 && ( describedBy === undefined || describedBy.split( " " ).indexOf( error.attr( "id" ) ) === -1 ) ) {
1182					this.addErrorAriaDescribedBy( element, error, true );
1183				}
1184
1185				// Refresh error/success class
1186				error.removeClass( this.settings.validClass ).addClass( this.settings.errorClass );
1187
1188				// Replace message on existing label
1189				if ( this.settings && this.settings.escapeHtml ) {
1190					error.text( message || "" );
1191				} else {
1192					error.html( message || "" );
1193				}
1194			} else {
1195
1196				// Create error element
1197				error = $( "<" + this.settings.errorElement + ">" )
1198					.attr( "id", elementID + "-error" )
1199					.addClass( this.settings.errorClass );
1200
1201				if ( this.settings && this.settings.escapeHtml ) {
1202					error.text( message || "" );
1203				} else {
1204					error.html( message || "" );
1205				}
1206
1207				// Maintain reference to the element to be placed into the DOM
1208				place = error;
1209				if ( this.settings.wrapper ) {
1210
1211					// Make sure the element is visible, even in IE
1212					// actually showing the wrapped element is handled elsewhere
1213					place = error.hide().show().wrap( "<" + this.settings.wrapper + "/>" ).parent();
1214				}
1215				if ( this.labelContainer.length ) {
1216					this.labelContainer.append( place );
1217				} else if ( this.settings.errorPlacement ) {
1218					this.settings.errorPlacement.call( this, place, $( element ) );
1219				} else {
1220					place.insertAfter( element );
1221				}
1222
1223				// Link error back to the element
1224				if ( error.is( "label" ) ) {
1225
1226					// If the error is a label, then associate using 'for'
1227					error.attr( "for", elementID );
1228
1229				// If the element is not a child of an associated label, then it's necessary
1230				// to explicitly apply aria-describedby
1231				} else if ( error.parents( "label[for='" + this.escapeCssMeta( elementID ) + "']" ).length === 0 ) {
1232					this.addErrorAriaDescribedBy( element, error, true );
1233				}
1234			}
1235			if ( !message && this.settings.success ) {
1236				error.text( "" );
1237				if ( typeof this.settings.success === "string" ) {
1238					error.addClass( this.settings.success );
1239				} else {
1240					this.settings.success( error, element );
1241				}
1242			}
1243			this.toShow = this.toShow.add( error );
1244		},
1245
1246		errorsFor: function( element ) {
1247			var name = this.escapeCssMeta( this.idOrName( element ) ),
1248				describer = $( element ).attr( "aria-describedby" ),
1249				selector = "label[for='" + name + "'], label[for='" + name + "'] *";
1250
1251			// 'aria-describedby' should directly reference the error element
1252			if ( describer ) {
1253				selector = selector + ", #" + this.escapeCssMeta( describer )
1254					.replace( /\s+/g, ", #" );
1255			}
1256
1257			// There may be hidden error elements not currently associated via aria-describedby (if ariaDescribedByCleanup is true)
1258			selector = selector + ", #" + name + "-error";
1259
1260			return this
1261				.errors()
1262				.filter( selector );
1263		},
1264
1265		// See https://api.jquery.com/category/selectors/, for CSS
1266		// meta-characters that should be escaped in order to be used with JQuery
1267		// as a literal part of a name/id or any selector.
1268		escapeCssMeta: function( string ) {
1269			if ( string === undefined ) {
1270				return "";
1271			}
1272
1273			return string.replace( /([\\!"#$%&'()*+,./:;<=>?@\[\]^`{|}~])/g, "\\$1" );
1274		},
1275
1276		idOrName: function( element ) {
1277			return this.groups[ element.name ] || ( this.checkable( element ) ? element.name : element.id || element.name );
1278		},
1279
1280		validationTargetFor: function( element ) {
1281
1282			// If radio/checkbox, validate first element in group instead
1283			if ( this.checkable( element ) ) {
1284				element = this.findByName( element.name );
1285			}
1286
1287			// Always apply ignore filter
1288			return $( element ).not( this.settings.ignore )[ 0 ];
1289		},
1290
1291		checkable: function( element ) {
1292			return ( /radio|checkbox/i ).test( element.type );
1293		},
1294
1295		findByName: function( name ) {
1296			var formId = this.currentForm.getAttribute( "id" ),
1297				selector = "[name='" + this.escapeCssMeta( name ) + "']",
1298				elements = $( this.currentForm ).find( selector );
1299
1300			// If the form has an ID, also include elements outside the form that have
1301			// a form attribute pointing to this form
1302			if ( formId ) {
1303				elements = elements.add(
1304					$( selector )
1305					.filter( "[form='" + this.escapeCssMeta( formId ) + "']" )
1306				);
1307			}
1308
1309			return elements;
1310		},
1311
1312		getLength: function( value, element ) {
1313			switch ( element.nodeName.toLowerCase() ) {
1314			case "select":
1315				return $( "option:selected", element ).length;
1316			case "input":
1317				if ( this.checkable( element ) ) {
1318					return this.findByName( element.name ).filter( ":checked" ).length;
1319				}
1320			}
1321			return value.length;
1322		},
1323
1324		depend: function( param, element ) {
1325			return this.dependTypes[ typeof param ] ? this.dependTypes[ typeof param ]( param, element ) : true;
1326		},
1327
1328		dependTypes: {
1329			"boolean": function( param ) {
1330				return param;
1331			},
1332			"string": function( param, element ) {
1333				return !!$( param, element.form ).length;
1334			},
1335			"function": function( param, element ) {
1336				return param( element );
1337			}
1338		},
1339
1340		optional: function( element ) {
1341			var val = this.elementValue( element );
1342			return !$.validator.methods.required.call( this, val, element ) && "dependency-mismatch";
1343		},
1344
1345		elementAjaxPort: function( element ) {
1346			return "validate" + element.name;
1347		},
1348
1349		startRequest: function( element ) {
1350			if ( !this.pending[ element.name ] ) {
1351				this.pendingRequest++;
1352				$( element ).addClass( this.settings.pendingClass );
1353				this.pending[ element.name ] = true;
1354			}
1355		},
1356
1357		stopRequest: function( element, valid ) {
1358			this.pendingRequest--;
1359
1360			// Sometimes synchronization fails, make sure pendingRequest is never < 0
1361			if ( this.pendingRequest < 0 ) {
1362				this.pendingRequest = 0;
1363			}
1364			delete this.pending[ element.name ];
1365			$( element ).removeClass( this.settings.pendingClass );
1366			if ( valid && this.pendingRequest === 0 && this.formSubmitted && this.form() && this.pendingRequest === 0 ) {
1367				$( this.currentForm ).trigger( "submit" );
1368
1369				// Remove the hidden input that was used as a replacement for the
1370				// missing submit button. The hidden input is added by `handle()`
1371				// to ensure that the value of the used submit button is passed on
1372				// for scripted submits triggered by this method
1373				if ( this.submitButton ) {
1374					$( "input:hidden[name='" + this.submitButton.name + "']", this.currentForm ).remove();
1375				}
1376
1377				this.formSubmitted = false;
1378			} else if ( !valid && this.pendingRequest === 0 && this.formSubmitted ) {
1379				$( this.currentForm ).triggerHandler( "invalid-form", [ this ] );
1380				this.formSubmitted = false;
1381			}
1382		},
1383
1384		abortRequest: function( element ) {
1385			var port;
1386
1387			if ( this.pending[ element.name ] ) {
1388				port = this.elementAjaxPort( element );
1389				$.ajaxAbort( port );
1390
1391				this.pendingRequest--;
1392
1393				// Sometimes synchronization fails, make sure pendingRequest is never < 0
1394				if ( this.pendingRequest < 0 ) {
1395					this.pendingRequest = 0;
1396				}
1397
1398				delete this.pending[ element.name ];
1399				$( element ).removeClass( this.settings.pendingClass );
1400			}
1401		},
1402
1403		previousValue: function( element, method ) {
1404			method = typeof method === "string" && method || "remote";
1405
1406			return $.data( element, "previousValue" ) || $.data( element, "previousValue", {
1407				old: null,
1408				valid: true,
1409				message: this.defaultMessage( element, { method: method } )
1410			} );
1411		},
1412
1413		// Cleans up all forms and elements, removes validator-specific events
1414		destroy: function() {
1415			this.resetForm();
1416
1417			$( this.currentForm )
1418				.off( ".validate" )
1419				.removeData( "validator" )
1420				.find( ".validate-equalTo-blur" )
1421					.off( ".validate-equalTo" )
1422					.removeClass( "validate-equalTo-blur" )
1423				.find( ".validate-lessThan-blur" )
1424					.off( ".validate-lessThan" )
1425					.removeClass( "validate-lessThan-blur" )
1426				.find( ".validate-lessThanEqual-blur" )
1427					.off( ".validate-lessThanEqual" )
1428					.removeClass( "validate-lessThanEqual-blur" )
1429				.find( ".validate-greaterThanEqual-blur" )
1430					.off( ".validate-greaterThanEqual" )
1431					.removeClass( "validate-greaterThanEqual-blur" )
1432				.find( ".validate-greaterThan-blur" )
1433					.off( ".validate-greaterThan" )
1434					.removeClass( "validate-greaterThan-blur" );
1435		}
1436
1437	},
1438
1439	classRuleSettings: {
1440		required: { required: true },
1441		email: { email: true },
1442		url: { url: true },
1443		date: { date: true },
1444		dateISO: { dateISO: true },
1445		number: { number: true },
1446		digits: { digits: true },
1447		creditcard: { creditcard: true }
1448	},
1449
1450	addClassRules: function( className, rules ) {
1451		if ( className.constructor === String ) {
1452			this.classRuleSettings[ className ] = rules;
1453		} else {
1454			$.extend( this.classRuleSettings, className );
1455		}
1456	},
1457
1458	classRules: function( element ) {
1459		var rules = {},
1460			classes = $( element ).attr( "class" );
1461
1462		if ( classes ) {
1463			$.each( classes.split( " " ), function() {
1464				if ( this in $.validator.classRuleSettings ) {
1465					$.extend( rules, $.validator.classRuleSettings[ this ] );
1466				}
1467			} );
1468		}
1469		return rules;
1470	},
1471
1472	normalizeAttributeRule: function( rules, type, method, value ) {
1473
1474		// Convert the value to a number for number inputs, and for text for backwards compability
1475		// allows type="date" and others to be compared as strings
1476		if ( /min|max|step/.test( method ) && ( type === null || /number|range|text/.test( type ) ) ) {
1477			value = Number( value );
1478
1479			// Support Opera Mini, which returns NaN for undefined minlength
1480			if ( isNaN( value ) ) {
1481				value = undefined;
1482			}
1483		}
1484
1485		if ( value || value === 0 ) {
1486			rules[ method ] = value;
1487		} else if ( type === method && type !== "range" ) {
1488
1489			// Exception: the jquery validate 'range' method
1490			// does not test for the html5 'range' type
1491			rules[ type === "date" ? "dateISO" : method ] = true;
1492		}
1493	},
1494
1495	attributeRules: function( element ) {
1496		var rules = {},
1497			$element = $( element ),
1498			type = element.getAttribute( "type" ),
1499			method, value;
1500
1501		for ( method in $.validator.methods ) {
1502
1503			// Support for <input required> in both html5 and older browsers
1504			if ( method === "required" ) {
1505				value = element.getAttribute( method );
1506
1507				// Some browsers return an empty string for the required attribute
1508				// and non-HTML5 browsers might have required="" markup
1509				if ( value === "" ) {
1510					value = true;
1511				}
1512
1513				// Force non-HTML5 browsers to return bool
1514				value = !!value;
1515			} else {
1516				value = $element.attr( method );
1517			}
1518
1519			this.normalizeAttributeRule( rules, type, method, value );
1520		}
1521
1522		// 'maxlength' may be returned as -1, 2147483647 ( IE ) and 524288 ( safari ) for text inputs
1523		if ( rules.maxlength && /-1|2147483647|524288/.test( rules.maxlength ) ) {
1524			delete rules.maxlength;
1525		}
1526
1527		return rules;
1528	},
1529
1530	dataRules: function( element ) {
1531		var rules = {},
1532			$element = $( element ),
1533			type = element.getAttribute( "type" ),
1534			method, value;
1535
1536		for ( method in $.validator.methods ) {
1537			value = $element.data( "rule" + method.charAt( 0 ).toUpperCase() + method.substring( 1 ).toLowerCase() );
1538
1539			// Cast empty attributes like `data-rule-required` to `true`
1540			if ( value === "" ) {
1541				value = true;
1542			}
1543
1544			this.normalizeAttributeRule( rules, type, method, value );
1545		}
1546		return rules;
1547	},
1548
1549	staticRules: function( element ) {
1550		var rules = {},
1551			validator = $.data( element.form, "validator" );
1552
1553		if ( validator.settings.rules ) {
1554			rules = $.validator.normalizeRule( validator.settings.rules[ element.name ] ) || {};
1555		}
1556		return rules;
1557	},
1558
1559	normalizeRules: function( rules, element ) {
1560
1561		// Handle dependency check
1562		$.each( rules, function( prop, val ) {
1563
1564			// Ignore rule when param is explicitly false, eg. required:false
1565			if ( val === false ) {
1566				delete rules[ prop ];
1567				return;
1568			}
1569			if ( val.param || val.depends ) {
1570				var keepRule = true;
1571				switch ( typeof val.depends ) {
1572				case "string":
1573					keepRule = !!$( val.depends, element.form ).length;
1574					break;
1575				case "function":
1576					keepRule = val.depends.call( element, element );
1577					break;
1578				}
1579				if ( keepRule ) {
1580					rules[ prop ] = val.param !== undefined ? val.param : true;
1581				} else {
1582					$.data( element.form, "validator" ).resetElements( $( element ) );
1583					delete rules[ prop ];
1584				}
1585			}
1586		} );
1587
1588		// Evaluate parameters
1589		$.each( rules, function( rule, parameter ) {
1590			rules[ rule ] = typeof parameter === "function" && rule !== "normalizer" ? parameter( element ) : parameter;
1591		} );
1592
1593		// Clean number parameters
1594		$.each( [ "minlength", "maxlength" ], function() {
1595			if ( rules[ this ] ) {
1596				rules[ this ] = Number( rules[ this ] );
1597			}
1598		} );
1599		$.each( [ "rangelength", "range" ], function() {
1600			var parts;
1601			if ( rules[ this ] ) {
1602				if ( Array.isArray( rules[ this ] ) ) {
1603					rules[ this ] = [ Number( rules[ this ][ 0 ] ), Number( rules[ this ][ 1 ] ) ];
1604				} else if ( typeof rules[ this ] === "string" ) {
1605					parts = rules[ this ].replace( /[\[\]]/g, "" ).split( /[\s,]+/ );
1606					rules[ this ] = [ Number( parts[ 0 ] ), Number( parts[ 1 ] ) ];
1607				}
1608			}
1609		} );
1610
1611		if ( $.validator.autoCreateRanges ) {
1612
1613			// Auto-create ranges
1614			if ( rules.min != null && rules.max != null ) {
1615				rules.range = [ rules.min, rules.max ];
1616				delete rules.min;
1617				delete rules.max;
1618			}
1619			if ( rules.minlength != null && rules.maxlength != null ) {
1620				rules.rangelength = [ rules.minlength, rules.maxlength ];
1621				delete rules.minlength;
1622				delete rules.maxlength;
1623			}
1624		}
1625
1626		return rules;
1627	},
1628
1629	// Converts a simple string to a {string: true} rule, e.g., "required" to {required:true}
1630	normalizeRule: function( data ) {
1631		if ( typeof data === "string" ) {
1632			var transformed = {};
1633			$.each( data.split( /\s/ ), function() {
1634				transformed[ this ] = true;
1635			} );
1636			data = transformed;
1637		}
1638		return data;
1639	},
1640
1641	// https://jqueryvalidation.org/jQuery.validator.addMethod/
1642	addMethod: function( name, method, message ) {
1643		$.validator.methods[ name ] = method;
1644		$.validator.messages[ name ] = message !== undefined ? message : $.validator.messages[ name ];
1645		if ( method.length < 3 ) {
1646			$.validator.addClassRules( name, $.validator.normalizeRule( name ) );
1647		}
1648	},
1649
1650	// https://jqueryvalidation.org/jQuery.validator.methods/
1651	methods: {
1652
1653		// https://jqueryvalidation.org/required-method/
1654		required: function( value, element, param ) {
1655
1656			// Check if dependency is met
1657			if ( !this.depend( param, element ) ) {
1658				return "dependency-mismatch";
1659			}
1660			if ( element.nodeName.toLowerCase() === "select" ) {
1661
1662				// Could be an array for select-multiple or a string, both are fine this way
1663				var val = $( element ).val();
1664				return val && val.length > 0;
1665			}
1666			if ( this.checkable( element ) ) {
1667				return this.getLength( value, element ) > 0;
1668			}
1669			return value !== undefined && value !== null && value.length > 0;
1670		},
1671
1672		// https://jqueryvalidation.org/email-method/
1673		email: function( value, element ) {
1674
1675			// From https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address
1676			// Retrieved 2014-01-14
1677			// If you have a problem with this implementation, report a bug against the above spec
1678			// Or use custom methods to implement your own email validation
1679			return this.optional( element ) || /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test( value );
1680		},
1681
1682		// https://jqueryvalidation.org/url-method/
1683		url: function( value, element ) {
1684
1685			// Copyright (c) 2010-2013 Diego Perini, MIT licensed
1686			// https://gist.github.com/dperini/729294
1687			// see also https://mathiasbynens.be/demo/url-regex
1688			// modified to allow protocol-relative URLs
1689			return this.optional( element ) || /^(?:(?:(?:https?|ftp):)?\/\/)(?:(?:[^\]\[?\/<~#`!@$^&*()+=}|:";',>{ ]|%[0-9A-Fa-f]{2})+(?::(?:[^\]\[?\/<~#`!@$^&*()+=}|:";',>{ ]|%[0-9A-Fa-f]{2})*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/i.test( value );
1690		},
1691
1692		// https://jqueryvalidation.org/date-method/
1693		date: ( function() {
1694			var called = false;
1695
1696			return function( value, element ) {
1697				if ( !called ) {
1698					called = true;
1699					if ( this.settings.debug && window.console ) {
1700						console.warn(
1701							"The `date` method is deprecated and will be removed in version '2.0.0'.\n" +
1702							"Please don't use it, since it relies on the Date constructor, which\n" +
1703							"behaves very differently across browsers and locales. Use `dateISO`\n" +
1704							"instead or one of the locale specific methods in `localizations/`\n" +
1705							"and `additional-methods.js`."
1706						);
1707					}
1708				}
1709
1710				return this.optional( element ) || !/Invalid|NaN/.test( new Date( value ).toString() );
1711			};
1712		}() ),
1713
1714		// https://jqueryvalidation.org/dateISO-method/
1715		dateISO: function( value, element ) {
1716			return this.optional( element ) || /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test( value );
1717		},
1718
1719		// https://jqueryvalidation.org/number-method/
1720		number: function( value, element ) {
1721			return this.optional( element ) || /^(?:-?\d+|-?\d{1,3}(?:,\d{3})+)?(?:-?\.\d+)?$/.test( value );
1722		},
1723
1724		// https://jqueryvalidation.org/digits-method/
1725		digits: function( value, element ) {
1726			return this.optional( element ) || /^\d+$/.test( value );
1727		},
1728
1729		// https://jqueryvalidation.org/minlength-method/
1730		minlength: function( value, element, param ) {
1731			var length = Array.isArray( value ) ? value.length : this.getLength( value, element );
1732			return this.optional( element ) || length >= param;
1733		},
1734
1735		// https://jqueryvalidation.org/maxlength-method/
1736		maxlength: function( value, element, param ) {
1737			var length = Array.isArray( value ) ? value.length : this.getLength( value, element );
1738			return this.optional( element ) || length <= param;
1739		},
1740
1741		// https://jqueryvalidation.org/rangelength-method/
1742		rangelength: function( value, element, param ) {
1743			var length = Array.isArray( value ) ? value.length : this.getLength( value, element );
1744			return this.optional( element ) || ( length >= param[ 0 ] && length <= param[ 1 ] );
1745		},
1746
1747		// https://jqueryvalidation.org/min-method/
1748		min: function( value, element, param ) {
1749			return this.optional( element ) || value >= param;
1750		},
1751
1752		// https://jqueryvalidation.org/max-method/
1753		max: function( value, element, param ) {
1754			return this.optional( element ) || value <= param;
1755		},
1756
1757		// https://jqueryvalidation.org/range-method/
1758		range: function( value, element, param ) {
1759			return this.optional( element ) || ( value >= param[ 0 ] && value <= param[ 1 ] );
1760		},
1761
1762		// https://jqueryvalidation.org/step-method/
1763		step: function( value, element, param ) {
1764			var type = $( element ).attr( "type" ),
1765				errorMessage = "Step attribute on input type " + type + " is not supported.",
1766				supportedTypes = [ "text", "number", "range" ],
1767				re = new RegExp( "\\b" + type + "\\b" ),
1768				notSupported = type && !re.test( supportedTypes.join() ),
1769				decimalPlaces = function( num ) {
1770					var match = ( "" + num ).match( /(?:\.(\d+))?$/ );
1771					if ( !match ) {
1772						return 0;
1773					}
1774
1775					// Number of digits right of decimal point.
1776					return match[ 1 ] ? match[ 1 ].length : 0;
1777				},
1778				toInt = function( num ) {
1779					return Math.round( num * Math.pow( 10, decimals ) );
1780				},
1781				valid = true,
1782				decimals;
1783
1784			// Works only for text, number and range input types
1785			// TODO find a way to support input types date, datetime, datetime-local, month, time and week
1786			if ( notSupported ) {
1787				throw new Error( errorMessage );
1788			}
1789
1790			decimals = decimalPlaces( param );
1791
1792			// Value can't have too many decimals
1793			if ( decimalPlaces( value ) > decimals || toInt( value ) % toInt( param ) !== 0 ) {
1794				valid = false;
1795			}
1796
1797			return this.optional( element ) || valid;
1798		},
1799
1800		// https://jqueryvalidation.org/equalTo-method/
1801		equalTo: function( value, element, param ) {
1802
1803			// Bind to the blur event of the target in order to revalidate whenever the target field is updated
1804			var target = $( param );
1805			if ( this.settings.onfocusout && target.not( ".validate-equalTo-blur" ).length ) {
1806				target.addClass( "validate-equalTo-blur" ).on( "blur.validate-equalTo", function() {
1807					$( element ).valid();
1808				} );
1809			}
1810			return value === target.val();
1811		},
1812
1813		// https://jqueryvalidation.org/remote-method/
1814		remote: function( value, element, param, method ) {
1815			if ( this.optional( element ) ) {
1816				return "dependency-mismatch";
1817			}
1818
1819			method = typeof method === "string" && method || "remote";
1820
1821			var previous = this.previousValue( element, method ),
1822				validator, data, optionDataString;
1823
1824			if ( !this.settings.messages[ element.name ] ) {
1825				this.settings.messages[ element.name ] = {};
1826			}
1827			previous.originalMessage = previous.originalMessage || this.settings.messages[ element.name ][ method ];
1828			this.settings.messages[ element.name ][ method ] = previous.message;
1829
1830			param = typeof param === "string" && { url: param } || param;
1831			optionDataString = $.param( $.extend( { data: value }, param.data ) );
1832			if ( previous.valid !== null && previous.old === optionDataString ) {
1833				return previous.valid;
1834			}
1835
1836			previous.old = optionDataString;
1837			previous.valid = null;
1838			validator = this;
1839			this.startRequest( element );
1840			data = {};
1841			data[ element.name ] = value;
1842			$.ajax( $.extend( true, {
1843				mode: "abort",
1844				port: this.elementAjaxPort( element ),
1845				dataType: "json",
1846				data: data,
1847				context: validator.currentForm,
1848				success: function( response ) {
1849					var valid = response === true || response === "true",
1850						errors, message, submitted;
1851
1852					validator.settings.messages[ element.name ][ method ] = previous.originalMessage;
1853					if ( valid ) {
1854						submitted = validator.formSubmitted;
1855						validator.toHide = validator.errorsFor( element );
1856						validator.formSubmitted = submitted;
1857						validator.successList.push( element );
1858						validator.invalid[ element.name ] = false;
1859						validator.showErrors();
1860					} else {
1861						errors = {};
1862						message = response || validator.defaultMessage( element, { method: method, parameters: value } );
1863						errors[ element.name ] = previous.message = message;
1864						validator.invalid[ element.name ] = true;
1865						validator.showErrors( errors );
1866					}
1867					previous.valid = valid;
1868					validator.stopRequest( element, valid );
1869				}
1870			}, param ) );
1871			return "pending";
1872		}
1873	}
1874
1875} );
1876
1877// Ajax mode: abort
1878// usage: $.ajax({ mode: "abort"[, port: "uniqueport"]});
1879//        $.ajaxAbort( port );
1880// if mode:"abort" is used, the previous request on that port (port can be undefined) is aborted via XMLHttpRequest.abort()
1881
1882var pendingRequests = {},
1883	ajax;
1884
1885// Use a prefilter if available (1.5+)
1886if ( $.ajaxPrefilter ) {
1887	$.ajaxPrefilter( function( settings, _, xhr ) {
1888		var port = settings.port;
1889		if ( settings.mode === "abort" ) {
1890			$.ajaxAbort( port );
1891			pendingRequests[ port ] = xhr;
1892		}
1893	} );
1894} else {
1895
1896	// Proxy ajax
1897	ajax = $.ajax;
1898	$.ajax = function( settings ) {
1899		var mode = ( "mode" in settings ? settings : $.ajaxSettings ).mode,
1900			port = ( "port" in settings ? settings : $.ajaxSettings ).port;
1901		if ( mode === "abort" ) {
1902			$.ajaxAbort( port );
1903			pendingRequests[ port ] = ajax.apply( this, arguments );
1904			return pendingRequests[ port ];
1905		}
1906		return ajax.apply( this, arguments );
1907	};
1908}
1909
1910// Abort the previous request without sending a new one
1911$.ajaxAbort = function( port ) {
1912	if ( pendingRequests[ port ] ) {
1913		pendingRequests[ port ].abort();
1914		delete pendingRequests[ port ];
1915	}
1916};
1917return $;
1918}));

2403 ? module.exports = factory() :
2404  typeof define === 'function' && define.amd ? define(factory) :
2405  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Sweetalert2 = factory());
2406})(this, (function () { 'use strict';
2407
2408  function _assertClassBrand(e, t, n) {
2409    if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
2410    throw new TypeError("Private element is not present on this object");
2411  }
2412  function _checkPrivateRedeclaration(e, t) {
2413    if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
2414  }
2415  function _classPrivateFieldGet2(s, a) {
2416    return s.get(_assertClassBrand(s, a));
2417  }
2418  function _classPrivateFieldInitSpec(e, t, a) {
2419    _checkPrivateRedeclaration(e, t), t.set(e, a);
2420  }
2421  function _classPrivateFieldSet2(s, a, r) {
2422    return s.set(_assertClassBrand(s, a), r), r;
2423  }
2424
2425  const RESTORE_FOCUS_TIMEOUT = 100;
2426
2427  /** @type {GlobalState} */
2428  const globalState = {};
2429  const focusPreviousActiveElement = () => {
2430    if (globalState.previousActiveElement instanceof HTMLElement) {
2431      globalState.previousActiveElement.focus();
2432      globalState.previousActiveElement = null;
2433    } else if (document.body) {
2434      document.body.focus();
2435    }
2436  };
2437
2438  /**
2439   * Restore previous active (focused) element
2440   *
2441   * @param {boolean} returnFocus
2442   * @returns {Promise<void>}
2443   */
2444  const restoreActiveElement = returnFocus => {
2445    return new Promise(resolve => {
2446      if (!returnFocus) {
2447        return resolve();
2448      }
2449      const x = window.scrollX;
2450      const y = window.scrollY;
2451      globalState.restoreFocusTimeout = setTimeout(() => {
2452        focusPreviousActiveElement();
2453        resolve();
2454      }, RESTORE_FOCUS_TIMEOUT); // issues/900
2455
2456      window.scrollTo(x, y);
2457    });
2458  };
2459
2460  const swalPrefix = 'swal2-';
2461
2462  /**
2463   * @typedef {Record<SwalClass, string>} SwalClasses
2464   */
2465
2466  /**
2467   * @typedef {'success' | 'warning' | 'info' | 'question' | 'error'} SwalIcon
2468   * @typedef {Record<SwalIcon, string>} SwalIcons
2469   */
2470
2471  /** @type {SwalClass[]} */
2472  const classNames = ['container', 'shown', 'height-auto', 'iosfix', 'popup', 'modal', 'no-backdrop', 'no-transition', 'toast', 'toast-shown', 'show', 'hide', 'close', 'title', 'html-container', 'actions', 'confirm', 'deny', 'cancel', 'footer', 'icon', 'icon-content', 'image', 'input', 'file', 'range', 'select', 'radio', 'checkbox', 'label', 'textarea', 'inputerror', 'input-label', 'validation-message', 'progress-steps', 'active-progress-step', 'progress-step', 'progress-step-line', 'loader', 'loading', 'styled', 'top', 'top-start', 'top-end', 'top-left', 'top-right', 'center', 'center-start', 'center-end', 'center-left', 'center-right', 'bottom', 'bottom-start', 'bottom-end', 'bottom-left', 'bottom-right', 'grow-row', 'grow-column', 'grow-fullscreen', 'rtl', 'timer-progress-bar', 'timer-progress-bar-container', 'scrollbar-measure', 'icon-success', 'icon-warning', 'icon-info', 'icon-question', 'icon-error', 'draggable', 'dragging'];
2473  const swalClasses = classNames.reduce((acc, className) => {
2474    acc[className] = swalPrefix + className;
2475    return acc;
2476  }, /** @type {SwalClasses} */{});
2477
2478  /** @type {SwalIcon[]} */
2479  const icons = ['success', 'warning', 'info', 'question', 'error'];
2480  const iconTypes = icons.reduce((acc, icon) => {
2481    acc[icon] = swalPrefix + icon;
2482    return acc;
2483  }, /** @type {SwalIcons} */{});
2484
2485  const consolePrefix = 'SweetAlert2:';
2486
2487  /**
2488   * Capitalize the first letter of a string
2489   *
2490   * @param {string} str
2491   * @returns {string}
2492   */
2493  const capitalizeFirstLetter = str => str.charAt(0).toUpperCase() + str.slice(1);
2494
2495  /**
2496   * Standardize console warnings
2497   *
2498   * @param {string | string[]} message
2499   */
2500  const warn = message => {
2501    console.warn(`${consolePrefix} ${typeof message === 'object' ? message.join(' ') : message}`);
2502  };
2503
2504  /**
2505   * Standardize console errors
2506   *
2507   * @param {string} message
2508   */
2509  const error = message => {
2510    console.error(`${consolePrefix} ${message}`);
2511  };
2512
2513  /**
2514   * Private global state for `warnOnce`
2515   *
2516   * @type {string[]}
2517   * @private
2518   */
2519  const previousWarnOnceMessages = [];
2520
2521  /**
2522   * Show a console warning, but only if it hasn't already been shown
2523   *
2524   * @param {string} message
2525   */
2526  const warnOnce = message => {
2527    if (!previousWarnOnceMessages.includes(message)) {
2528      previousWarnOnceMessages.push(message);
2529      warn(message);
2530    }
2531  };
2532
2533  /**
2534   * Show a one-time console warning about deprecated params/methods
2535   *
2536   * @param {string} deprecatedParam
2537   * @param {string?} useInstead
2538   */
2539  const warnAboutDeprecation = (deprecatedParam, useInstead = null) => {
2540    warnOnce(`"${deprecatedParam}" is deprecated and will be removed in the next major release.${useInstead ? ` Use "${useInstead}" instead.` : ''}`);
2541  };
2542
2543  /**
2544   * If `arg` is a function, call it (with no arguments or context) and return the result.
2545   * Otherwise, just pass the value through
2546   *
2547   * @param {(() => *) | *} arg
2548   * @returns {*}
2549   */
2550  const callIfFunction = arg => typeof arg === 'function' ? arg() : arg;
2551
2552  /**
2553   * @param {*} arg
2554   * @returns {boolean}
2555   */
2556  const hasToPromiseFn = arg => arg && typeof arg.toPromise === 'function';
2557
2558  /**
2559   * @param {*} arg
2560   * @returns {Promise<*>}
2561   */
2562  const asPromise = arg => hasToPromiseFn(arg) ? arg.toPromise() : Promise.resolve(arg);
2563
2564  /**
2565   * @param {*} arg
2566   * @returns {boolean}
2567   */
2568  const isPromise = arg => arg && Promise.resolve(arg) === arg;
2569
2570  /**
2571   * @returns {boolean}
2572   */
2573  const isFirefox = () => navigator.userAgent.includes('Firefox');
2574
2575  /**
2576   * Gets the popup container which contains the backdrop and the popup itself.
2577   *
2578   * @returns {HTMLElement | null}
2579   */
2580  const getContainer = () => document.body.querySelector(`.${swalClasses.container}`);
2581
2582  /**
2583   * @param {string} selectorString
2584   * @returns {HTMLElement | null}
2585   */
2586  const elementBySelector = selectorString => {
2587    const container = getContainer();
2588    return container ? container.querySelector(selectorString) : null;
2589  };
2590
2591  /**
2592   * @param {string} className
2593   * @returns {HTMLElement | null}
2594   */
2595  const elementByClass = className => {
2596    return elementBySelector(`.${className}`);
2597  };
2598
2599  /**
2600   * @returns {HTMLElement | null}
2601   */
2602  const getPopup = () => elementByClass(swalClasses.popup);
2603
2604  /**
2605   * @returns {HTMLElement | null}
2606   */
2607  const getIcon = () => elementByClass(swalClasses.icon);
2608
2609  /**
2610   * @returns {HTMLElement | null}
2611   */
2612  const getIconContent = () => elementByClass(swalClasses['icon-content']);
2613
2614  /**
2615   * @returns {HTMLElement | null}
2616   */
2617  const getTitle = () => elementByClass(swalClasses.title);
2618
2619  /**
2620   * @returns {HTMLElement | null}
2621   */
2622  const getHtmlContainer = () => elementByClass(swalClasses['html-container']);
2623
2624  /**
2625   * @returns {HTMLElement | null}
2626   */
2627  const getImage = () => elementByClass(swalClasses.image);
2628
2629  /**
2630   * @returns {HTMLElement | null}
2631   */
2632  const getProgressSteps = () => elementByClass(swalClasses['progress-steps']);
2633
2634  /**
2635   * @returns {HTMLElement | null}
2636   */
2637  const getValidationMessage = () => elementByClass(swalClasses['validation-message']);
2638
2639  /**
2640   * @returns {HTMLButtonElement | null}
2641   */
2642  const getConfirmButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.confirm}`));
2643
2644  /**
2645   * @returns {HTMLButtonElement | null}
2646   */
2647  const getCancelButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.cancel}`));
2648
2649  /**
2650   * @returns {HTMLButtonElement | null}
2651   */
2652  const getDenyButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.deny}`));
2653
2654  /**
2655   * @returns {HTMLElement | null}
2656   */
2657  const getInputLabel = () => elementByClass(swalClasses['input-label']);
2658
2659  /**
2660   * @returns {HTMLElement | null}
2661   */
2662  const getLoader = () => elementBySelector(`.${swalClasses.loader}`);
2663
2664  /**
2665   * @returns {HTMLElement | null}
2666   */
2667  const getActions = () => elementByClass(swalClasses.actions);
2668
2669  /**
2670   * @returns {HTMLElement | null}
2671   */
2672  const getFooter = () => elementByClass(swalClasses.footer);
2673
2674  /**
2675   * @returns {HTMLElement | null}
2676   */
2677  const getTimerProgressBar = () => elementByClass(swalClasses['timer-progress-bar']);
2678
2679  /**
2680   * @returns {HTMLElement | null}
2681   */
2682  const getCloseButton = () => elementByClass(swalClasses.close);
2683
2684  // https://github.com/jkup/focusable/blob/master/index.js
2685  const focusable = `
2686  a[href],
2687  area[href],
2688  input:not([disabled]),
2689  select:not([disabled]),
2690  textarea:not([disabled]),
2691  button:not([disabled]),
2692  iframe,
2693  object,
2694  embed,
2695  [tabindex="0"],
2696  [contenteditable],
2697  audio[controls],
2698  video[controls],
2699  summary
2700`;
2701  /**
2702   * @returns {HTMLElement[]}
2703   */
2704  const getFocusableElements = () => {
2705    const popup = getPopup();
2706    if (!popup) {
2707      return [];
2708    }
2709    /** @type {NodeListOf<HTMLElement>} */
2710    const focusableElementsWithTabindex = popup.querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])');
2711    const focusableElementsWithTabindexSorted = Array.from(focusableElementsWithTabindex)
2712    // sort according to tabindex
2713    .sort((a, b) => {
2714      const tabindexA = parseInt(a.getAttribute('tabindex') || '0');
2715      const tabindexB = parseInt(b.getAttribute('tabindex') || '0');
2716      if (tabindexA > tabindexB) {
2717        return 1;
2718      } else if (tabindexA < tabindexB) {
2719        return -1;
2720      }
2721      return 0;
2722    });
2723
2724    /** @type {NodeListOf<HTMLElement>} */
2725    const otherFocusableElements = popup.querySelectorAll(focusable);
2726    const otherFocusableElementsFiltered = Array.from(otherFocusableElements).filter(el => el.getAttribute('tabindex') !== '-1');
2727    return [...new Set(focusableElementsWithTabindexSorted.concat(otherFocusableElementsFiltered))].filter(el => isVisible$1(el));
2728  };
2729
2730  /**
2731   * @returns {boolean}
2732   */
2733  const isModal = () => {
2734    return hasClass(document.body, swalClasses.shown) && !hasClass(document.body, swalClasses['toast-shown']) && !hasClass(document.body, swalClasses['no-backdrop']);
2735  };
2736
2737  /**
2738   * @returns {boolean}
2739   */
2740  const isToast = () => {
2741    const popup = getPopup();
2742    if (!popup) {
2743      return false;
2744    }
2745    return hasClass(popup, swalClasses.toast);
2746  };
2747
2748  /**
2749   * @returns {boolean}
2750   */
2751  const isLoading = () => {
2752    const popup = getPopup();
2753    if (!popup) {
2754      return false;
2755    }
2756    return popup.hasAttribute('data-loading');
2757  };
2758
2759  /**
2760   * Securely set innerHTML of an element
2761   * https://github.com/sweetalert2/sweetalert2/issues/1926
2762   *
2763   * @param {HTMLElement} elem
2764   * @param {string} html
2765   */
2766  const setInnerHtml = (elem, html) => {
2767    elem.textContent = '';
2768    if (html) {
2769      const parser = new DOMParser();
2770      const parsed = parser.parseFromString(html, `text/html`);
2771      const head = parsed.querySelector('head');
2772      if (head) {
2773        Array.from(head.childNodes).forEach(child => {
2774          elem.appendChild(child);
2775        });
2776      }
2777      const body = parsed.querySelector('body');
2778      if (body) {
2779        Array.from(body.childNodes).forEach(child => {
2780          if (child instanceof HTMLVideoElement || child instanceof HTMLAudioElement) {
2781            elem.appendChild(child.cloneNode(true)); // https://github.com/sweetalert2/sweetalert2/issues/2507
2782          } else {
2783            elem.appendChild(child);
2784          }
2785        });
2786      }
2787    }
2788  };
2789
2790  /**
2791   * @param {HTMLElement} elem
2792   * @param {string} className
2793   * @returns {boolean}
2794   */
2795  const hasClass = (elem, className) => {
2796    if (!className) {
2797      return false;
2798    }
2799