← All changes | js/formidable.js +1639 -891 6.3.1 → trunk View file →

		@@ -1,104 +1,58 @@
1		-/* exported frmRecaptcha, frmAfterRecaptcha, frmUpdateField, frmDeleteEntry, frmOnSubmit, frm_resend_email */
	1	+/* exported frmRecaptcha, frmAfterRecaptcha */
2	2
3		-var frmFrontForm;
4		-
5	3	function frmFrontFormJS() {
6	4	'use strict';
7	5
8		- /*global jQuery:false, frm_js, grecaptcha, frmProForm, tinyMCE */
9		- /*global frmThemeOverride_jsErrors, frmThemeOverride_frmPlaceError, frmThemeOverride_frmAfterSubmit */
	6	+ let jsErrors = [];
10	7
11		- var action = '';
12		- var jsErrors = [];
13		-
14	8	/**
15		- * Maybe add polyfills.
16		- *
17		- * @since 5.4
18		- */
19		- function maybeAddPolyfills() {
20		- var i;
21		- if ( ! Element.prototype.matches ) {
22		- // IE9 supports matches but as msMatchesSelector instead.
23		- Element.prototype.matches = Element.prototype.msMatchesSelector;
24		- }
25		-
26		- if ( ! Element.prototype.closest ) {
27		- Element.prototype.closest = function( s ) {
28		- var el = this;
29		-
30		- do {
31		- if ( el.matches( s ) ) {
32		- return el;
33		- }
34		- el = el.parentElement || el.parentNode;
35		- } while ( el !== null && el.nodeType === 1 );
36		-
37		- return null;
38		- };
39		- }
40		-
41		- // NodeList.forEach().
42		- if ( window.NodeList && ! NodeList.prototype.forEach ) {
43		- NodeList.prototype.forEach = function( callback, thisArg ) {
44		- thisArg = thisArg || window;
45		- for ( i = 0; i < this.length; i++ ) {
46		- callback.call( thisArg, this[ i ], i, this );
47		- }
48		- };
49		- }
50		- }
51		-
52		- /**
53	9	* Triggers custom JS event.
54	10	*
55	11	* @since 5.5.3
56	12	*
57	13	* @param {HTMLElement} el The HTML element.
58		- * @param {String} eventName Event name.
59		- * @param {mixed} data The passed data.
	14	+ * @param {string} eventName Event name.
	15	+ * @param {*} data The passed data.
60	16	*/
61	17	function triggerCustomEvent( el, eventName, data ) {
62		- var event;
63		-
64		- if ( typeof window.CustomEvent === 'function' ) {
65		- event = new CustomEvent( eventName );
66		- } else if ( document.createEvent ) {
67		- event = document.createEvent( 'HTMLEvents' );
68		- event.initEvent( eventName, false, true );
69		- } else {
	18	+ if ( typeof window.CustomEvent !== 'function' ) {
70	19	return;
71	20	}
72	21
	22	+ const event = new CustomEvent( eventName );
73	23	event.frmData = data;
74	24
75	25	el.dispatchEvent( event );
76	26	}
77	27
78		- /* Get the ID of the field that changed*/
	28	+ /**
	29	+ * Get the ID of the field that changed.
	30	+ *
	31	+ * @param {HTMLElement|jQuery} field
	32	+ * @param {boolean} fullID
	33	+ * @return {string|number} Field ID.
	34	+ */
79	35	function getFieldId( field, fullID ) {
80		- var nameParts, fieldId,
81		- isRepeating = false,
82		- fieldName = '';
	36	+ let nameParts;
	37	+ let fieldId;
	38	+ let isRepeating = false;
	39	+ let fieldName = '';
	40	+
83	41	if ( field instanceof jQuery ) {
84		- fieldName = field.attr( 'name' );
85		- } else {
86		- fieldName = field.name;
	42	+ field = field.get( 0 );
87	43	}
88	44
89		- if ( typeof fieldName === 'undefined' ) {
	45	+ fieldName = field.name;
	46	+
	47	+ if ( fieldName === undefined ) {
90	48	fieldName = '';
91	49	}
92	50
93	51	if ( fieldName === '' ) {
94		- if ( field instanceof jQuery ) {
95		- fieldName = field.data( 'name' );
96		- } else {
97		- fieldName = field.getAttribute( 'data-name' );
98		- }
	52	+ fieldName = field.getAttribute( 'data-name' );
99	53
100		- if ( typeof fieldName === 'undefined' ) {
	54	+ if ( fieldName === undefined ) {
101	55	fieldName = '';
102	56	}
103	57
104	58	if ( fieldName !== '' && fieldName ) {
		@@ -113,25 +67,24 @@
113	67	return 0;
114	68	}
115	69	nameParts = nameParts.filter( function( n ) {
116	70	return n !== '';
117		- });
	71	+ } );
118	72
119		- fieldId = nameParts[0];
	73	+ fieldId = nameParts[ 0 ];
120	74
121	75	if ( nameParts.length === 1 ) {
122	76	return fieldId;
123	77	}
124	78
125		- if ( nameParts[1] === '[form' || nameParts[1] === '[row_ids' ) {
	79	+ if ( nameParts[ 1 ] === '[form' || nameParts[ 1 ] === '[row_ids' ) {
126	80	return 0;
127	81	}
128	82
129	83	// Check if 'this' is in a repeating section
130		- if ( jQuery( 'input[name="item_meta[' + fieldId + '][form]"]' ).length ) {
131		-
	84	+ if ( document.querySelector( `input[name="item_meta[${ fieldId }][form]"]` ) ) {
132	85	// this is a repeatable section with name: item_meta[repeating-section-id][row-id][field-id]
133		- fieldId = nameParts[2].replace( '[', '' );
	86	+ fieldId = nameParts[ 2 ].replace( '[', '' );
134	87	isRepeating = true;
135	88	}
136	89
137	90	// Check if 'this' is an other text field and get field ID for it
		@@ -137,21 +90,21 @@
137	90	// Check if 'this' is an other text field and get field ID for it
138	91	if ( 'other' === fieldId ) {
139	92	if ( isRepeating ) {
140	93	// name for other fields: item_meta[370][0][other][414]
141		- fieldId = nameParts[3].replace( '[', '' );
	94	+ fieldId = nameParts[ 3 ].replace( '[', '' );
142	95	} else {
143	96	// Other field name: item_meta[other][370]
144		- fieldId = nameParts[1].replace( '[', '' );
	97	+ fieldId = nameParts[ 1 ].replace( '[', '' );
145	98	}
146	99	}
147	100
148	101	if ( fullID === true ) {
149	102	// For use in the container div id
150		- if ( fieldId === nameParts[0]) {
151		- fieldId = fieldId + '-' + nameParts[1].replace( '[', '' );
	103	+ if ( fieldId === nameParts[ 0 ] ) {
	104	+ fieldId = `${ fieldId }-${ nameParts[ 1 ].replace( '[', '' ) }`;
152	105	} else {
153		- fieldId = fieldId + '-' + nameParts[0] + '-' + nameParts[1].replace( '[', '' );
	106	+ fieldId = `${ fieldId }-${ nameParts[ 0 ] }-${ nameParts[ 1 ].replace( '[', '' ) }`;
154	107	}
155	108	}
156	109
157	110	return fieldId;
		@@ -161,12 +114,18 @@
161	114	* Disable the submit button for a given jQuery form object
162	115	*
163	116	* @since 2.03.02
164	117	*
165		- * @param {object} $form
	118	+ * @param {Object} $form
166	119	*/
167	120	function disableSubmitButton( $form ) {
168		- $form.find( 'input[type="submit"], input[type="button"], button[type="submit"]' ).attr( 'disabled', 'disabled' );
	121	+ const form = $form instanceof jQuery ? $form.get( 0 ) : $form;
	122	+ if ( ! form ) {
	123	+ return;
	124	+ }
	125	+ form.querySelectorAll( 'input[type="submit"], input[type="button"], button[type="submit"], button.frm_save_draft' ).forEach(
	126	+ button => button.disabled = true
	127	+ );
169	128	}
170	129
171	130	/**
172	131	* Enable the submit button for a given jQuery form object
		@@ -172,12 +131,16 @@
172	131	* Enable the submit button for a given jQuery form object
173	132	*
174	133	* @since 2.03.02
175	134	*
176		- * @param {object} $form
	135	+ * @param {HTMLElement} form
	136	+ *
	137	+ * @return {void}
177	138	*/
178		- function enableSubmitButton( $form ) {
179		- $form.find( 'input[type="submit"], input[type="button"], button[type="submit"]' ).prop( 'disabled', false );
	139	+ function enableSubmitButton( form ) {
	140	+ form.querySelectorAll( 'input[type="submit"], input[type="button"], button[type="submit"]' ).forEach(
	141	+ button => button.disabled = false
	142	+ );
180	143	}
181	144
182	145	/**
183	146	* Disable the save draft link for a given jQuery form object
		@@ -183,117 +146,227 @@
183	146	* Disable the save draft link for a given jQuery form object
184	147	*
185	148	* @since 4.04.03
186	149	*
187		- * @param {object} $form
	150	+ * @param {Object} $form
188	151	*/
189	152	function disableSaveDraft( $form ) {
190		- $form.find( 'a.frm_save_draft' ).css( 'pointer-events', 'none' );
	153	+ const form = $form instanceof jQuery ? $form.get( 0 ) : $form;
	154	+ if ( ! form ) {
	155	+ return;
	156	+ }
	157	+ form.querySelectorAll( 'a.frm_save_draft' ).forEach(
	158	+ link => link.style.pointerEvents = 'none'
	159	+ );
191	160	}
192	161
193	162	/**
194		- * Enable the save draft link for a given jQuery form object
	163	+ * Enable the save draft link for a given form object.
195	164	*
196	165	* @since 4.04.03
197	166	*
198		- * @param {object} $form
	167	+ * @param {jQuery|HTMLElement} $form
199	168	*/
200	169	function enableSaveDraft( $form ) {
201		- $form.find( 'a.frm_save_draft' ).css( 'pointer-events', '' );
	170	+ const form = $form instanceof jQuery ? $form.get( 0 ) : $form;
	171	+ if ( ! form ) {
	172	+ return;
	173	+ }
	174	+ form.querySelectorAll( '.frm_save_draft' ).forEach( saveDraftButton => {
	175	+ saveDraftButton.disabled = false;
	176	+ saveDraftButton.style.pointerEvents = '';
	177	+ } );
202	178	}
203	179
	180	+ /**
	181	+ * Validate form with JS.
	182	+ *
	183	+ * @param {HTMLElement|jQuery} object
	184	+ * @return {Array} Errors.
	185	+ */
204	186	function validateForm( object ) {
205		- var r, rl, n, nl, fields, field, value, requiredFields,
206		- errors = [];
	187	+ let errors = [];
207	188
208		- // Make sure required text field is filled in
209		- requiredFields = jQuery( object ).find(
210		- '.frm_required_field:visible input, .frm_required_field:visible select, .frm_required_field:visible textarea'
211		- ).filter( ':not(.frm_optional)' );
212		- if ( requiredFields.length ) {
213		- for ( r = 0, rl = requiredFields.length; r < rl; r++ ) {
214		- if ( hasClass( requiredFields[r], 'ed_button' ) ) {
215		- // skip rich text field buttons.
216		- continue;
	189	+ const vanillaJsObject = 'function' === typeof object.get ? object.get( 0 ) : object;
	190	+
	191	+ // Required field validation.
	192	+ vanillaJsObject?.querySelectorAll( '.frm_required_field' ).forEach(
	193	+ requiredField => {
	194	+ const isVisible = requiredField.offsetParent !== null;
	195	+ if ( ! isVisible ) {
	196	+ return;
217	197	}
218		- errors = checkRequiredField( requiredFields[r], errors );
	198	+
	199	+ requiredField.querySelectorAll( 'input, select, textarea' ).forEach(
	200	+ requiredInput => {
	201	+ if ( hasClass( requiredInput, 'frm_optional' ) || hasClass( requiredInput, 'ed_button' ) ) {
	202	+ // skip rich text field buttons.
	203	+ return;
	204	+ }
	205	+
	206	+ errors = checkRequiredField( requiredInput, errors );
	207	+ }
	208	+ );
219	209	}
220		- }
	210	+ );
221	211
222		- fields = jQuery( object ).find( 'input,select,textarea' );
223		- if ( fields.length ) {
224		- for ( n = 0, nl = fields.length; n < nl; n++ ) {
225		- field = fields[n];
226		- if ( '' !== field.value ) {
227		- validateFieldValue( field, errors );
	212	+ vanillaJsObject?.querySelectorAll( 'input,select,textarea' ).forEach(
	213	+ field => {
	214	+ if ( '' === field.value ) {
	215	+ if ( 'number' === field.type ) {
	216	+ // A number field will return an empty string when it is invalid.
	217	+ checkValidity( field, errors );
	218	+ }
	219	+
	220	+ const isConfirmationField = field.name && 0 === field.name.indexOf( 'item_meta[conf_' );
	221	+ if ( ! isConfirmationField ) {
	222	+ // Allow a blank confirmation field to still call validateFieldValue.
	223	+ // If we continue for a confirmation field there are issues with forms submitting with a blank confirmation field.
	224	+ return;
	225	+ }
228	226	}
	227	+
	228	+ validateFieldValue( field, errors, true );
	229	+ checkValidity( field, errors );
229	230	}
	231	+ );
	232	+
	233	+ // Invisible captchas are processed after validation.
	234	+ // We only want to validate a visible captcha on submit.
	235	+ if ( ! hasInvisibleRecaptcha( object ) ) {
	236	+ errors = validateRecaptcha( object, errors );
230	237	}
231	238
232		- errors = validateRecaptcha( object, errors );
	239	+ return errors;
	240	+ }
233	241
234		- return errors;
	242	+ /**
	243	+ * Check the ValidityState interface for the field.
	244	+ * If it is invalid, show an error for it.
	245	+ *
	246	+ * @param {HTMLElement} field
	247	+ * @param {Array} errors
	248	+ * @return {void}
	249	+ */
	250	+ function checkValidity( field, errors ) {
	251	+ if ( 'object' !== typeof field.validity || false !== field.validity.valid ) {
	252	+ return;
	253	+ }
	254	+
	255	+ const fieldID = getFieldId( field, true );
	256	+ if ( errors[ fieldID ] === undefined ) {
	257	+ errors[ fieldID ] = getFieldValidationMessage( field, 'data-invmsg' );
	258	+ }
	259	+
	260	+ if ( 'function' === typeof field.reportValidity ) {
	261	+ // This triggers an error pop up.
	262	+ field.reportValidity();
	263	+ }
235	264	}
236	265
237	266	/**
238	267	* @since 5.0.10
239	268	*
240		- * @param {object} element
	269	+ * @param {Object} element
241	270	* @param {string} targetClass
242		- * @returns {boolean}
	271	+ * @return {boolean} True if the element has the target class.
243	272	*/
244	273	function hasClass( element, targetClass ) {
245		- var className = ' ' + element.className + ' ';
246		- return -1 !== className.indexOf( ' ' + targetClass + ' ' );
	274	+ return element.classList && element.classList.contains( targetClass );
247	275	}
248	276
	277	+ /**
	278	+ * @param {HTMLElement} field
	279	+ */
249	280	function maybeValidateChange( field ) {
250	281	if ( field.type === 'url' ) {
251		- maybeAddHttpToUrl( field );
	282	+ maybeAddHttpsToUrl( field );
252	283	}
253		- if ( jQuery( field ).closest( 'form' ).hasClass( 'frm_js_validate' ) ) {
254		- validateField( field );
	284	+ const form = field.closest( 'form' );
	285	+ if ( ! form ) {
	286	+ return;
255	287	}
	288	+
	289	+ // Removing stale errors is universal. Adding errors only happens when JS validation is enabled.
	290	+ validateField( field, hasClass( form, 'frm_js_validate' ) );
256	291	}
257	292
258		- function maybeAddHttpToUrl( field ) {
259		- var url = field.value;
260		- var matches = url.match( /^(https?|ftps?|mailto|news|feed|telnet):/ );
	293	+ /**
	294	+ * @param {HTMLElement} field
	295	+ */
	296	+ function maybeAddHttpsToUrl( field ) {
	297	+ const url = field.value;
	298	+ const matches = url.match( /^(https?|ftps?|mailto|news|feed|telnet):/ );
261	299	if ( field.value !== '' && matches === null ) {
262		- field.value = 'http://' + url;
	300	+ field.value = `https://${ url }`;
263	301	}
264	302	}
265	303
266		- function validateField( field ) {
267		- var key,
268		- errors = [],
269		- $fieldCont = jQuery( field ).closest( '.frm_form_field' );
	304	+ /**
	305	+ * Validate a field with JS.
	306	+ *
	307	+ * Removing stale errors is universal. Adding errors only happens when JS validation is enabled.
	308	+ *
	309	+ * @since 6.32 Added the `addErrors` parameter.
	310	+ *
	311	+ * @param {HTMLElement} field
	312	+ * @param {boolean} addErrors Whether to add new errors. Defaults to `true`.
	313	+ *
	314	+ * @return {void}
	315	+ */
	316	+ function validateField( field, addErrors = true ) {
	317	+ let errors;
	318	+ let key;
270	319
271		- if ( $fieldCont.hasClass( 'frm_required_field' ) && ! jQuery( field ).hasClass( 'frm_optional' ) ) {
	320	+ errors = [];
	321	+ const fieldContainer = field.closest( '.frm_form_field' );
	322	+
	323	+ if ( ! fieldContainer ) {
	324	+ // Hidden fields do not have a field container and do not require JS validation.
	325	+ return;
	326	+ }
	327	+
	328	+ if ( hasClass( fieldContainer, 'frm_required_field' ) && ! hasClass( field, 'frm_optional' ) ) {
272	329	errors = checkRequiredField( field, errors );
273	330	}
274	331
275	332	if ( errors.length < 1 ) {
276		- validateFieldValue( field, errors );
	333	+ validateFieldValue( field, errors, false );
277	334	}
278	335
279		- removeFieldError( $fieldCont );
280		- if ( Object.keys( errors ).length > 0 ) {
281		- for ( key in errors ) {
282		- addFieldError( $fieldCont, key, errors );
	336	+ const hasErrors = Object.keys( errors ).length > 0;
	337	+
	338	+ if ( addErrors ) {
	339	+ removeFieldError( fieldContainer );
	340	+ if ( hasErrors ) {
	341	+ for ( key in errors ) {
	342	+ addFieldError( fieldContainer, key, errors );
	343	+ }
283	344	}
	345	+ } else if ( ! hasErrors ) {
	346	+ // JS validation is off, so only remove existing errors once the field passes validation.
	347	+ removeFieldError( fieldContainer );
284	348	}
285	349	}
286	350
287		- function validateFieldValue( field, errors ) {
	351	+ /**
	352	+ * Validates a field value.
	353	+ *
	354	+ * @since 6.15 Added `onSubmit` parameter.
	355	+ *
	356	+ * @param {HTMLElement} field Field input.
	357	+ * @param {Object} errors Errors data.
	358	+ * @param {boolean} onSubmit Is `true` if the form is being submitted.
	359	+ */
	360	+ function validateFieldValue( field, errors, onSubmit ) {
288	361	if ( field.type === 'hidden' ) {
289	362	// don't validate
290	363	} else if ( field.type === 'number' ) {
291	364	checkNumberField( field, errors );
292	365	} else if ( field.type === 'email' ) {
293		- checkEmailField( field, errors );
	366	+ checkEmailField( field, errors, onSubmit );
294	367	} else if ( field.type === 'password' ) {
295		- checkPasswordField( field, errors );
	368	+ checkPasswordField( field, errors, onSubmit );
296	369	} else if ( field.type === 'url' ) {
297	370	checkUrlField( field, errors );
298	371	} else if ( field.pattern !== null ) {
299	372	checkPatternField( field, errors );
		@@ -298,19 +371,34 @@
298	371	} else if ( field.pattern !== null ) {
299	372	checkPatternField( field, errors );
300	373	}
301	374
	375	+ if ( 'tel' === field.type && shouldCheckConfirmField( field, onSubmit ) ) {
	376	+ confirmField( field, errors );
	377	+ }
	378	+
	379	+ /**
	380	+ * @since 6.15 Added `onSubmit` to the data.
	381	+ */
302	382	triggerCustomEvent( document, 'frm_validate_field_value', {
303		- field: field,
304		- errors: errors
305		- });
	383	+ field,
	384	+ errors,
	385	+ onSubmit
	386	+ } );
306	387	}
307	388
	389	+ /**
	390	+ * @param {HTMLElement} field
	391	+ * @param {Array} errors
	392	+ * @return {Array} Errors
	393	+ */
308	394	function checkRequiredField( field, errors ) {
309		- var checkGroup, tempVal, i, placeholder,
310		- val = '',
311		- fieldID = '',
312		- fileID = field.getAttribute( 'data-frmfile' );
	395	+ let tempVal;
	396	+ let i;
	397	+ let placeholder;
	398	+ let val = '';
	399	+ let fieldID = '';
	400	+ let fileID = field.getAttribute( 'data-frmfile' );
313	401
314	402	if ( field.type === 'hidden' && fileID === null && ! isAppointmentField( field ) && ! isInlineDatepickerField( field ) ) {
315	403	return errors;
316	404	}
		@@ -315,19 +403,26 @@
315	403	return errors;
316	404	}
317	405
318	406	if ( field.type === 'checkbox' || field.type === 'radio' ) {
319		- checkGroup = jQuery( 'input[name="' + field.name + '"]' ).closest( '.frm_required_field' ).find( 'input:checked' );
320		- jQuery( checkGroup ).each( function() {
321		- val = this.value;
322		- });
	407	+ document.querySelectorAll( `input[name="${ field.name }"]` ).forEach( function( input ) {
	408	+ const requiredField = input.closest( '.frm_required_field' );
	409	+ if ( ! requiredField ) {
	410	+ return;
	411	+ }
	412	+
	413	+ const checkedInputs = requiredField.querySelectorAll( 'input:checked' );
	414	+ checkedInputs.forEach( function( checkedInput ) {
	415	+ val = checkedInput.value;
	416	+ } );
	417	+ } );
323	418	} else if ( field.type === 'file' || fileID ) {
324		- if ( typeof fileID === 'undefined' ) {
	419	+ if ( fileID === undefined ) {
325	420	fileID = getFieldId( field, true );
326	421	fileID = fileID.replace( 'file', '' );
327	422	}
328	423
329		- if ( typeof errors[ fileID ] === 'undefined' ) {
	424	+ if ( errors[ fileID ] === undefined ) {
330	425	val = getFileVals( fileID );
331	426	}
332	427	fieldID = fileID;
333	428	} else {
		@@ -335,9 +430,10 @@
335	430	// skip hidden other fields
336	431	return errors;
337	432	}
338	433
339		- val = jQuery( field ).val();
	434	+ val = jQuery( field ).val(); // eslint-disable-line no-jquery/no-val
	435	+
340	436	if ( val === null ) {
341	437	val = '';
342	438	} else if ( typeof val !== 'string' ) {
343	439	tempVal = val;
		@@ -342,10 +438,10 @@
342	438	} else if ( typeof val !== 'string' ) {
343	439	tempVal = val;
344	440	val = '';
345	441	for ( i = 0; i < tempVal.length; i++ ) {
346		- if ( tempVal[i] !== '' ) {
347		- val = tempVal[i];
	442	+ if ( tempVal[ i ] !== '' ) {
	443	+ val = tempVal[ i ];
348	444	}
349	445	}
350	446	}
351	447
		@@ -358,14 +454,22 @@
358	454	} else {
359	455	fieldID = getFieldId( field, true );
360	456	}
361	457
	458	+ // Make sure fieldID is a string.
	459	+ // fieldID may be a number which doesn't include a .replace function.
	460	+ if ( 'function' !== typeof fieldID.replace ) {
	461	+ fieldID = fieldID.toString();
	462	+ }
	463	+
362	464	if ( hasClass( field, 'frm_time_select' ) ) {
363	465	// set id for time field
364	466	fieldID = fieldID.replace( '-H', '' ).replace( '-m', '' );
365	467	} else if ( isSignatureField( field ) ) {
366	468	if ( val === '' ) {
367		- val = jQuery( field ).closest( '.frm_form_field' ).find( '[name="' + field.getAttribute( 'name' ).replace( '[typed]', '[output]' ) + '"]' ).val();
	469	+ const fieldContainer = field.closest( '.frm_form_field' );
	470	+ const outputField = fieldContainer ? fieldContainer.querySelector( `[name="${ field.getAttribute( 'name' ).replace( '[typed]', '[output]' ) }"]` ) : null;
	471	+ val = outputField ? outputField.value : '';
368	472	}
369	473	fieldID = fieldID.replace( '-typed', '' );
370	474	}
371	475
		@@ -386,36 +490,57 @@
386	490
387	491	return errors;
388	492	}
389	493
	494	+ /**
	495	+ * @param {HTMLElement} field
	496	+ * @return {boolean} True if the input is a typed signature input.
	497	+ */
390	498	function isSignatureField( field ) {
391		- var name = field.getAttribute( 'name' );
	499	+ const name = field.getAttribute( 'name' );
392	500	return 'string' === typeof name && '[typed]' === name.substr( -7 );
393	501	}
394	502
	503	+ /**
	504	+ * @param {HTMLElement} field
	505	+ * @return {boolean} True if the field is a SSA appointment field.
	506	+ */
395	507	function isAppointmentField( field ) {
396	508	return hasClass( field, 'ssa_appointment_form_field_appointment_id' );
397	509	}
398	510
	511	+ /**
	512	+ * @param {HTMLElement} field
	513	+ * @return {boolean} True if the field is inline datepicker field.
	514	+ */
399	515	function isInlineDatepickerField( field ) {
400	516	return 'hidden' === field.type && '_alt' === field.id.substr( -4 ) && hasClass( field.nextElementSibling, 'frm_date_inline' );
401	517	}
402	518
	519	+ /**
	520	+ * @param {string|number} fileID
	521	+ * @return {string} File input value.
	522	+ */
403	523	function getFileVals( fileID ) {
404		- var val = '',
405		- fileFields = jQuery( 'input[name="file' + fileID + '"], input[name="file' + fileID + '[]"], input[name^="item_meta[' + fileID + ']"]' );
	524	+ let val = '';
	525	+ const fileFields = document.querySelectorAll( `input[name="file${ fileID }"], input[name="file${ fileID }[]"], input[name^="item_meta[${ fileID }]"]` );
406	526
407		- fileFields.each( function() {
	527	+ fileFields.forEach( function( field ) {
408	528	if ( val === '' ) {
409		- val = this.value;
	529	+ val = field.value;
410	530	}
411		- });
	531	+ } );
412	532	return val;
413	533	}
414	534
	535	+ /**
	536	+ * @param {HTMLElement} field
	537	+ * @param {Array} errors
	538	+ * @return {void}
	539	+ */
415	540	function checkUrlField( field, errors ) {
416		- var fieldID,
417		- url = field.value;
	541	+ let fieldID;
	542	+ const url = field.value;
418	543
419	544	if ( url !== '' && ! /^http(s)?:\/\/(?:localhost|(?:[\da-z\.-]+\.[\da-z\.-]+))/i.test( url ) ) {
420	545	fieldID = getFieldId( field, true );
421	546	if ( ! ( fieldID in errors ) ) {
		@@ -423,41 +548,90 @@
423	548	}
424	549	}
425	550	}
426	551
427		- function checkEmailField( field, errors ) {
428		- var fieldID = getFieldId( field, true ),
429		- pattern = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/i;
	552	+ /**
	553	+ * Checks if the confirm field should be checked.
	554	+ *
	555	+ * @since 6.15
	556	+ *
	557	+ * @param {HTMLElement} field Field input.
	558	+ * @param {boolean} onSubmit Is `true` if the form is being submitted.
	559	+ * @return {boolean} True if we should confirm the field.
	560	+ */
	561	+ function shouldCheckConfirmField( field, onSubmit ) {
	562	+ if ( onSubmit ) {
	563	+ // Always check on submitting.
	564	+ return true;
	565	+ }
430	566
	567	+ if ( 0 === field.id.indexOf( 'field_conf_' ) ) {
	568	+ // Always check if it's the confirm field.
	569	+ return true;
	570	+ }
	571	+
	572	+ return false;
	573	+ }
	574	+
	575	+ /**
	576	+ * Check the email field for errors.
	577	+ *
	578	+ * @since 6.15 Added `onSubmit` parameter.
	579	+ *
	580	+ * @param {HTMLElement} field Field input.
	581	+ * @param {Object} errors Errors data.
	582	+ * @param {boolean} onSubmit Is `true` if the form is being submitted.
	583	+ */
	584	+ function checkEmailField( field, errors, onSubmit ) {
	585	+ const fieldID = getFieldId( field, true );
	586	+ const pattern = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/i;
	587	+
431	588	// validate the current field we're editing first
432	589	if ( '' !== field.value && pattern.test( field.value ) === false ) {
433	590	errors[ fieldID ] = getFieldValidationMessage( field, 'data-invmsg' );
434	591	}
435	592
436		- confirmField( field, errors );
	593	+ if ( shouldCheckConfirmField( field, onSubmit ) ) {
	594	+ confirmField( field, errors );
	595	+ }
437	596	}
438	597
439		- function checkPasswordField( field, errors ) {
440		- confirmField( field, errors );
	598	+ /**
	599	+ * Check the password field for errors.
	600	+ *
	601	+ * @since 6.15 Added `onSubmit` parameter.
	602	+ *
	603	+ * @param {HTMLElement} field Field input.
	604	+ * @param {Object} errors Errors data.
	605	+ * @param {boolean} onSubmit Is `true` if the form is being submitted.
	606	+ */
	607	+ function checkPasswordField( field, errors, onSubmit ) {
	608	+ if ( shouldCheckConfirmField( field, onSubmit ) ) {
	609	+ confirmField( field, errors );
	610	+ }
441	611	}
442	612
	613	+ /**
	614	+ * @param {HTMLElement} field
	615	+ * @param {Array} errors
	616	+ * @return {void}
	617	+ */
443	618	function confirmField( field, errors ) {
444		- var value, confirmValue, firstField,
445		- fieldID = getFieldId( field, true ),
446		- strippedId = field.id.replace( 'conf_', '' ),
447		- strippedFieldID = fieldID.replace( 'conf_', '' ),
448		- confirmField = document.getElementById( strippedId.replace( 'field_', 'field_conf_' ) );
	619	+ const fieldID = getFieldId( field, true );
	620	+ const strippedId = field.id.replace( 'conf_', '' );
	621	+ const strippedFieldID = fieldID.replace( 'conf_', '' );
	622	+ const confirmField = document.getElementById( strippedId.replace( 'field_', 'field_conf_' ) );
449	623
450		- if ( confirmField === null || typeof errors[ 'conf_' + strippedFieldID ] !== 'undefined' ) {
	624	+ if ( ! confirmField || errors[ `conf_${ strippedFieldID }` ] !== undefined ) {
451	625	return;
452	626	}
453	627
454	628	if ( fieldID !== strippedFieldID ) {
455		- firstField = document.getElementById( strippedId );
456		- value = firstField.value;
457		- confirmValue = confirmField.value;
458		- if ( '' !== value && '' !== confirmValue && value !== confirmValue ) {
459		- errors[ 'conf_' + strippedFieldID ] = getFieldValidationMessage( confirmField, 'data-confmsg' );
	629	+ const firstField = document.getElementById( strippedId );
	630	+ const { value } = firstField;
	631	+ const confirmValue = confirmField.value;
	632	+ if ( value !== confirmValue ) {
	633	+ errors[ `conf_${ strippedFieldID }` ] = getFieldValidationMessage( confirmField, 'data-confmsg' );
460	634	}
461	635	} else {
462	636	validateField( confirmField );
463	637	}
		@@ -462,11 +636,16 @@
462	636	validateField( confirmField );
463	637	}
464	638	}
465	639
	640	+ /**
	641	+ * @param {HTMLElement} field
	642	+ * @param {Array} errors
	643	+ * @return {void}
	644	+ */
466	645	function checkNumberField( field, errors ) {
467		- var fieldID,
468		- number = field.value;
	646	+ let fieldID;
	647	+ const number = field.value;
469	648
470	649	if ( number !== '' && isNaN( number / 1 ) !== false ) {
471	650	fieldID = getFieldId( field, true );
472	651	if ( ! ( fieldID in errors ) ) {
		@@ -474,102 +653,198 @@
474	653	}
475	654	}
476	655	}
477	656
	657	+ /**
	658	+ * @param {HTMLElement} field
	659	+ * @param {Array} errors
	660	+ * @return {void}
	661	+ */
478	662	function checkPatternField( field, errors ) {
479		- var fieldID,
480		- text = field.value,
481		- format = getFieldValidationMessage( field, 'pattern' );
	663	+ let fieldID;
	664	+ const text = field.value;
	665	+ let format = getFieldValidationMessage( field, 'pattern' );
482	666
483	667	if ( format !== '' && text !== '' ) {
484	668	fieldID = getFieldId( field, true );
485	669	if ( ! ( fieldID in errors ) ) {
486		- format = new RegExp( '^' + format + '$', 'i' );
487		- if ( format.test( text ) === false ) {
488		- errors[ fieldID ] = getFieldValidationMessage( field, 'data-invmsg' );
	670	+ if ( 'object' === typeof window.frmProForm && 'function' === typeof window.frmProForm.isIntlPhoneInput && window.frmProForm.isIntlPhoneInput( field ) ) {
	671	+ if ( ! window.frmProForm.validateIntlPhoneInput( field ) ) {
	672	+ errors[ fieldID ] = getFieldValidationMessage( field, 'data-invmsg' );
	673	+ }
	674	+ } else {
	675	+ format = new RegExp( `^${ format }$`, 'i' );
	676	+ if ( format.test( text ) === false ) {
	677	+ errors[ fieldID ] = getFieldValidationMessage( field, 'data-invmsg' );
	678	+ }
489	679	}
490	680	}
491	681	}
492	682	}
493	683
	684	+ /**
	685	+ * Set color for select placeholders.
	686	+ *
	687	+ * @since 6.5.1
	688	+ */
	689	+ function setSelectPlaceholderColor() {
	690	+ const selects = document.querySelectorAll( '.form-field select' );
	691	+ const styleElement = document.querySelector( '.with_frm_style' );
	692	+ const textColorDisabled = styleElement ? getComputedStyle( styleElement ).getPropertyValue( '--text-color-disabled' ).trim() : '';
	693	+ // Exit if there are no select elements or the textColorDisabled property is missing
	694	+ if ( ! selects.length || ! textColorDisabled ) {
	695	+ return;
	696	+ }
	697	+
	698	+ // Function to change the color of a select element
	699	+ const changeSelectColor = function( select ) {
	700	+ if ( select.options[ select.selectedIndex ] && hasClass( select.options[ select.selectedIndex ], 'frm-select-placeholder' ) ) {
	701	+ select.style.setProperty( 'color', textColorDisabled, 'important' );
	702	+ } else {
	703	+ select.style.color = '';
	704	+ }
	705	+ };
	706	+
	707	+ // Use a loop to iterate through each select element
	708	+ Array.prototype.forEach.call( selects, function( select ) {
	709	+ // Apply the color change to each select element
	710	+ changeSelectColor( select );
	711	+
	712	+ // Add an event listener for future changes
	713	+ select.addEventListener( 'change', function() {
	714	+ changeSelectColor( select );
	715	+ } );
	716	+ } );
	717	+ }
	718	+
	719	+ /**
	720	+ * @param {HTMLElement|jQuery} object
	721	+ *
	722	+ * @return {HTMLElement|false} Captcha element if there is an invisible recaptcha.
	723	+ */
494	724	function hasInvisibleRecaptcha( object ) {
495		- var recaptcha, recaptchaID, alreadyChecked;
	725	+ if ( isGoingToPrevPage( object ) ) {
	726	+ return false;
	727	+ }
496	728
497		- if ( isGoingToPrevPage( object ) ) {
	729	+ const form = object instanceof jQuery ? object.get( 0 ) : object;
	730	+ if ( ! form ) {
498	731	return false;
499	732	}
500	733
501		- recaptcha = jQuery( object ).find( '.frm-g-recaptcha[data-size="invisible"], .g-recaptcha[data-size="invisible"]' );
502		- if ( recaptcha.length ) {
503		- recaptchaID = recaptcha.data( 'rid' );
504		- alreadyChecked = grecaptcha.getResponse( recaptchaID );
	734	+ const recaptcha = form.querySelector( '.frm-g-recaptcha[data-size="invisible"], .g-recaptcha[data-size="invisible"]' );
	735	+ if ( recaptcha ) {
	736	+ const recaptchaID = recaptcha.dataset.rid;
	737	+ const alreadyChecked = grecaptcha.getResponse( recaptchaID );
505	738	if ( alreadyChecked.length === 0 ) {
506	739	return recaptcha;
507		- } else {
508		- return false;
509	740	}
510		- } else {
511		- return false;
512	741	}
	742	+
	743	+ return false;
513	744	}
514	745
	746	+ /**
	747	+ * @param {HTMLElement} invisibleRecaptcha
	748	+ *
	749	+ * @return {void}
	750	+ */
515	751	function executeInvisibleRecaptcha( invisibleRecaptcha ) {
516		- var recaptchaID = invisibleRecaptcha.data( 'rid' );
	752	+ const recaptchaID = invisibleRecaptcha.dataset.rid;
517	753	grecaptcha.reset( recaptchaID );
518	754	grecaptcha.execute( recaptchaID );
519	755	}
520	756
521	757	function validateRecaptcha( form, errors ) {
522		- var recaptchaID, response, fieldContainer, fieldID,
523		- $recaptcha = jQuery( form ).find( '.frm-g-recaptcha' );
524		- if ( $recaptcha.length ) {
525		- recaptchaID = $recaptcha.data( 'rid' );
	758	+ const formEl = form instanceof jQuery ? form.get( 0 ) : form;
	759	+ if ( ! formEl ) {
	760	+ return errors;
	761	+ }
526	762
527		- try {
528		- response = grecaptcha.getResponse( recaptchaID );
529		- } catch ( e ) {
530		- if ( jQuery( form ).find( 'input[name="recaptcha_checked"]' ).length ) {
531		- return errors;
532		- } else {
533		- response = '';
534		- }
	763	+ const recaptcha = formEl.querySelector( '.frm-g-recaptcha' );
	764	+ if ( ! recaptcha ) {
	765	+ return errors;
	766	+ }
	767	+
	768	+ const recaptchaID = recaptcha.dataset.rid;
	769	+ let response;
	770	+
	771	+ try {
	772	+ response = grecaptcha.getResponse( recaptchaID );
	773	+ } catch ( e ) {
	774	+ if ( formEl.querySelector( 'input[name="recaptcha_checked"]' ) ) {
	775	+ return errors;
535	776	}
	777	+ response = '';
	778	+ }
536	779
537		- if ( response.length === 0 ) {
538		- fieldContainer = $recaptcha.closest( '.frm_form_field' );
539		- fieldID = fieldContainer.attr( 'id' ).replace( 'frm_field_', '' ).replace( '_container', '' );
	780	+ if ( response.length === 0 ) {
	781	+ const fieldContainer = recaptcha.closest( '.frm_form_field' );
	782	+ if ( fieldContainer?.id ) {
	783	+ const fieldID = fieldContainer.id.replace( 'frm_field_', '' ).replace( '_container', '' );
540	784	errors[ fieldID ] = '';
541	785	}
542	786	}
	787	+
543	788	return errors;
544	789	}
545	790
	791	+ /**
	792	+ * @param {HTMLElement} field
	793	+ * @param {string} messageType
	794	+ * @return {string} The error message to display.
	795	+ */
546	796	function getFieldValidationMessage( field, messageType ) {
547		- var msg, errorHtml;
548		-
549		- msg = field.getAttribute( messageType );
	797	+ let msg = field.getAttribute( messageType );
550	798	if ( null === msg ) {
551	799	msg = '';
552	800	}
553	801
554	802	if ( '' !== msg && shouldWrapErrorHtmlAroundMessageType( messageType ) ) {
555		- errorHtml = field.getAttribute( 'data-error-html' );
556		- if ( null !== errorHtml ) {
557		- errorHtml = errorHtml.replace( /\+/g, '%20' );
558		- msg = decodeURIComponent( errorHtml ).replace( '[error]', msg );
559		- msg = msg.replace( '[key]', getFieldId( field, false ) );
560		- }
	803	+ msg = wrapErrorHtml( msg, field );
561	804	}
562	805
563	806	return msg;
564	807	}
565	808
	809	+ /**
	810	+ * @param {string} msg
	811	+ * @param {HTMLElement} field
	812	+ * @return {string} The error HTML to use.
	813	+ */
	814	+ function wrapErrorHtml( msg, field ) {
	815	+ let errorHtml = field.getAttribute( 'data-error-html' );
	816	+ if ( null === errorHtml ) {
	817	+ return msg;
	818	+ }
	819	+
	820	+ errorHtml = errorHtml.replace( /\+/g, '%20' );
	821	+ msg = decodeURIComponent( errorHtml ).replace( '[error]', msg );
	822	+ const fieldId = getFieldId( field, false );
	823	+ const split = fieldId.split( '-' );
	824	+ const fieldIdParts = field.id.split( '_' );
	825	+ fieldIdParts.shift(); // Drop the "field" value from the front.
	826	+ split[ 0 ] = fieldIdParts.join( '_' );
	827	+ const errorKey = split.join( '-' );
	828	+ return msg.replace( '[key]', errorKey );
	829	+ }
	830	+
566	831	function shouldWrapErrorHtmlAroundMessageType( type ) {
567	832	return 'pattern' !== type;
568	833	}
569	834
	835	+ /**
	836	+ * Check if JS validation should happen.
	837	+ *
	838	+ * @param {HTMLElement|Object} object Form object.
	839	+ * @return {boolean} True if validation is enabled and we are not saving a draft or going to a previous page.
	840	+ */
570	841	function shouldJSValidate( object ) {
571		- var validate = jQuery( object ).hasClass( 'frm_js_validate' );
	842	+ if ( 'function' === typeof object.get ) {
	843	+ // Get the HTMLElement from a jQuery object.
	844	+ object = object.get( 0 );
	845	+ }
	846	+ let validate = hasClass( object, 'frm_js_validate' );
572	847	if ( validate && typeof frmProForm !== 'undefined' && ( frmProForm.savingDraft( object ) || frmProForm.goingToPreviousPage( object ) ) ) {
573	848	validate = false;
574	849	}
575	850
		@@ -575,26 +850,38 @@
575	850
576	851	return validate;
577	852	}
578	853
	854	+ /**
	855	+ * @param {HTMLElement} object
	856	+ * @param {string} action
	857	+ * @return {void}
	858	+ */
579	859	function getFormErrors( object, action ) {
580		- var fieldset, data, success, error, shouldTriggerEvent;
	860	+ const fieldsets = object.querySelectorAll( '.frm_form_field' );
	861	+ fieldsets.forEach( field => field.classList.add( 'frm_doing_ajax' ) );
581	862
582		- if ( typeof action === 'undefined' ) {
583		- jQuery( object ).find( 'input[name="frm_action"]' ).val();
584		- }
	863	+ const data = `${ jQuery( object ).serialize() }&action=frm_entries_${ action }&nonce=${ frm_js.nonce }`; // eslint-disable-line no-jquery/no-serialize
	864	+ const shouldTriggerEvent = object.classList.contains( 'frm_trigger_event_on_submit' );
585	865
586		- fieldset = jQuery( object ).find( '.frm_form_field' );
587		- fieldset.addClass( 'frm_doing_ajax' );
	866	+ const doRedirect = response => {
	867	+ jQuery( document ).trigger( 'frmBeforeFormRedirect', [ object, response ] );
588	868
589		- data = jQuery( object ).serialize() + '&action=frm_entries_' + action + '&nonce=' + frm_js.nonce; // eslint-disable-line camelcase
590		- shouldTriggerEvent = object.classList.contains( 'frm_trigger_event_on_submit' );
	869	+ if ( ! response.openInNewTab ) {
	870	+ // We return here because we're redirecting there is no need to update content.
	871	+ window.location = response.redirect;
	872	+ return;
	873	+ }
591	874
592		- success = function( response ) {
593		- var defaultResponse, formID, replaceContent, pageOrder, formReturned, contSubmit, delay,
594		- $fieldCont, key, inCollapsedSection, frmTrigger, newTab;
	875	+ // We don't return here because we're opening in a new tab, the old tab will still update.
	876	+ const newTab = window.open( response.redirect, '_blank' );
	877	+ if ( ! newTab && response.fallbackMsg && response.content ) {
	878	+ response.content = response.content.trim().replace( /(<\/div><\/div>)$/, ` ${ response.fallbackMsg }</div></div>` );
	879	+ }
	880	+ };
595	881
596		- defaultResponse = {
	882	+ const success = function( response ) {
	883	+ const defaultResponse = {
597	884	content: '',
598	885	errors: {},
599	886	pass: false
600	887	};
		@@ -600,60 +887,60 @@
600	887	};
601	888
602	889	if ( response === null ) {
603	890	response = defaultResponse;
	891	+ } else {
	892	+ // Response is a string. Convert it to an object.
	893	+ response = response.replace( /^\s+|\s+$/g, '' );
	894	+ if ( response.indexOf( '{' ) === 0 ) {
	895	+ response = JSON.parse( response );
	896	+ } else {
	897	+ response = defaultResponse;
	898	+ }
604	899	}
605	900
606		- response = response.replace( /^\s+|\s+$/g, '' );
607		- if ( response.indexOf( '{' ) === 0 ) {
608		- response = JSON.parse( response );
609		- } else {
610		- response = defaultResponse;
611		- }
	901	+ let willRedirect = false;
612	902
613		- if ( typeof response.redirect !== 'undefined' ) {
	903	+ if ( response.redirect !== undefined ) {
614	904	if ( shouldTriggerEvent ) {
615	905	triggerCustomEvent( object, 'frmSubmitEvent' );
616	906	return;
617	907	}
618	908
619		- jQuery( document ).trigger( 'frmBeforeFormRedirect', [ object, response ]);
620		-
621		- if ( ! response.openInNewTab ) {
622		- // We return here because we're redirecting there is no need to update content.
623		- window.location = response.redirect;
624		- return;
	909	+ if ( response.delay ) {
	910	+ setTimeout( function() {
	911	+ doRedirect( response );
	912	+ }, 1000 * response.delay );
	913	+ } else {
	914	+ doRedirect( response );
625	915	}
626	916
627		- // We don't return here because we're opening in a new tab, the old tab will still update.
628		- newTab = window.open( response.redirect, '_blank' );
629		- if ( ! newTab && response.fallbackMsg && response.content ) {
630		- response.content = response.content.trim().replace( /(<\/div><\/div>)$/, ' ' + response.fallbackMsg + '</div></div>' );
631		- }
	917	+ willRedirect = true;
632	918	}
633	919
634		- if ( response.content !== '' ) {
	920	+ if ( 'string' === typeof response.content && response.content !== '' ) {
635	921	// the form or success message was returned
636	922
637	923	if ( shouldTriggerEvent ) {
638		- triggerCustomEvent( object, 'frmSubmitEvent' );
	924	+ triggerCustomEvent( object, 'frmSubmitEvent', { content: response.content } );
639	925	return;
640	926	}
641	927
642	928	removeSubmitLoading( jQuery( object ) );
643		- if ( frm_js.offset != -1 ) { // eslint-disable-line camelcase
	929	+ if ( frm_js.offset != -1 ) {
644	930	frmFrontForm.scrollMsg( jQuery( object ), false );
645	931	}
646	932
647		- formID = jQuery( object ).find( 'input[name="form_id"]' ).val();
	933	+ const formIdInput = object.querySelector( 'input[name="form_id"]' );
	934	+ const formID = formIdInput ? formIdInput.value : '';
648	935	response.content = response.content.replace( / frm_pro_form /g, ' frm_pro_form frm_no_hide ' );
649		- replaceContent = jQuery( object ).closest( '.frm_forms' );
	936	+ const replaceContent = jQuery( object ).closest( '.frm_forms' ); // eslint-disable-line no-jquery/no-closest
650	937	removeAddedScripts( replaceContent, formID );
651		- delay = maybeSlideOut( replaceContent, response.content );
	938	+ const delay = maybeSlideOut( replaceContent, response.content );
652	939
653	940	setTimeout(
654	941	function() {
655		- var container, input, previousInput;
	942	+ afterFormSubmittedBeforeReplace( object, response );
656	943
657	944	replaceContent.replaceWith( response.content );
658	945
659	946	addUrlParam( response );
		@@ -658,48 +945,41 @@
658	945
659	946	addUrlParam( response );
660	947
661	948	if ( typeof frmThemeOverride_frmAfterSubmit === 'function' ) { // eslint-disable-line camelcase
662		- pageOrder = jQuery( 'input[name="frm_page_order_' + formID + '"]' ).val();
663		- formReturned = jQuery( response.content ).find( 'input[name="form_id"]' ).val();
	949	+ const pageOrderInput = document.querySelector( `input[name="frm_page_order_${ formID }"]` );
	950	+ const pageOrder = pageOrderInput ? pageOrderInput.value : '';
	951	+ const tempDiv = document.createElement( 'div' );
	952	+ tempDiv.innerHTML = response.content;
	953	+ const formReturnedInput = tempDiv.querySelector( 'input[name="form_id"]' );
	954	+ const formReturned = formReturnedInput ? formReturnedInput.value : '';
664	955	frmThemeOverride_frmAfterSubmit( formReturned, pageOrder, response.content, object );
665	956	}
666	957
667		- if ( typeof response.recaptcha !== 'undefined' ) {
668		- container = jQuery( '#frm_form_' + formID + '_container' ).find( '.frm_fields_container' );
669		- input = '<input type="hidden" name="recaptcha_checked" value="' + response.recaptcha + '">';
670		- previousInput = container.find( 'input[name="recaptcha_checked"]' );
671		-
672		- if ( previousInput.length ) {
673		- previousInput.replaceWith( input );
674		- } else {
675		- container.append( input );
676		- }
677		- }
678		-
679	958	afterFormSubmitted( object, response );
680	959	},
681	960	delay
682	961	);
683		- } else if ( Object.keys( response.errors ).length ) {
	962	+ } else if ( response.errors !== undefined && Object.keys( response.errors ).length ) {
684	963	// errors were returned
685	964	removeSubmitLoading( jQuery( object ), 'enable' );
686	965
687	966	//show errors
688		- contSubmit = true;
	967	+ let contSubmit = true;
689	968	removeAllErrors();
690	969
691		- $fieldCont = null;
	970	+ let $fieldCont = null;
692	971
693		- for ( key in response.errors ) {
694		- $fieldCont = jQuery( object ).find( '#frm_field_' + key + '_container' );
	972	+ for ( const key in response.errors ) {
	973	+ const fieldContEl = object.querySelector( `#frm_field_${ key }_container` );
	974	+ $fieldCont = fieldContEl ? jQuery( fieldContEl ) : jQuery();
695	975
696	976	if ( $fieldCont.length ) {
697		- if ( ! $fieldCont.is( ':visible' ) ) {
698		- inCollapsedSection = $fieldCont.closest( '.frm_toggle_container' );
	977	+ if ( ! $fieldCont.is( ':visible' ) ) { // eslint-disable-line no-jquery/no-is
	978	+ const inCollapsedSection = $fieldCont.closest( '.frm_toggle_container' ); // eslint-disable-line no-jquery/no-closest, formidable/no-jquery-variable-methods
699	979	if ( inCollapsedSection.length ) {
700		- frmTrigger = inCollapsedSection.prev();
701		- if ( ! frmTrigger.hasClass( 'frm_trigger' ) ) {
	980	+ let frmTrigger = inCollapsedSection.prev();
	981	+ if ( ! frmTrigger.hasClass( 'frm_trigger' ) ) { // eslint-disable-line formidable/no-jquery-variable-methods
702	982	// If the frmTrigger object is the section description, check to see if the previous element is the trigger
703	983	frmTrigger = frmTrigger.prev( '.frm_trigger' );
704	984	}
705	985	frmTrigger.trigger( 'click' );
		@@ -705,9 +985,9 @@
705	985	frmTrigger.trigger( 'click' );
706	986	}
707	987	}
708	988
709		- if ( $fieldCont.is( ':visible' ) ) {
	989	+ if ( $fieldCont.is( ':visible' ) ) { // eslint-disable-line no-jquery/no-is
710	990	addFieldError( $fieldCont, key, response.errors );
711	991	contSubmit = false;
712	992	}
713	993	}
		@@ -712,11 +992,10 @@
712	992	}
713	993	}
714	994	}
715	995
716		- jQuery( object ).find( '.frm-g-recaptcha, .g-recaptcha, .h-captcha' ).each( function() {
717		- var $recaptcha = jQuery( this ),
718		- recaptchaID = $recaptcha.data( 'rid' );
	996	+ object.querySelectorAll( '.frm-g-recaptcha, .g-recaptcha, .h-captcha' ).forEach( function( captchaEl ) {
	997	+ const recaptchaID = captchaEl.dataset.rid;
719	998
720	999	if ( typeof grecaptcha !== 'undefined' && grecaptcha ) {
721	1000	if ( recaptchaID ) {
722	1001	grecaptcha.reset( recaptchaID );
		@@ -723,26 +1002,33 @@
723	1002	} else {
724	1003	grecaptcha.reset();
725	1004	}
726	1005	}
	1006	+
727	1007	if ( typeof hcaptcha !== 'undefined' && hcaptcha ) {
728	1008	hcaptcha.reset();
729	1009	}
730		- });
	1010	+ } );
731	1011
732		- jQuery( document ).trigger( 'frmFormErrors', [ object, response ]);
	1012	+ if ( window.turnstile ) {
	1013	+ object.querySelectorAll( '.frm-cf-turnstile' ).forEach(
	1014	+ turnstileField => turnstileField.dataset.rid && turnstile.reset( turnstileField.dataset.rid )
	1015	+ );
	1016	+ }
733	1017
734		- fieldset.removeClass( 'frm_doing_ajax' );
	1018	+ jQuery( document ).trigger( 'frmFormErrors', [ object, response ] );
	1019	+
	1020	+ fieldsets.forEach( field => field.classList.remove( 'frm_doing_ajax' ) );
735	1021	scrollToFirstField( object );
736	1022
737	1023	if ( contSubmit ) {
738	1024	object.submit();
739	1025	} else {
740		- jQuery( object ).prepend( response.error_message );
	1026	+ object.insertAdjacentHTML( 'afterbegin', response.error_message );
741	1027	checkForErrorsAndMaybeSetFocus();
742	1028	}
743		- } else {
744		- // there may have been a plugin conflict, or the form is not set to submit with ajax
	1029	+ } else if ( ! willRedirect ) { // Avoid double submission if redirecting to a page.
	1030	+ // There may have been a plugin conflict, or the form is not set to submit with ajax.
745	1031
746	1032	showFileLoading( object );
747	1033
748	1034	object.submit();
		@@ -748,10 +1034,12 @@
748	1034	object.submit();
749	1035	}
750	1036	};
751	1037
752		- error = function() {
753		- jQuery( object ).find( 'input[type="submit"], input[type="button"]' ).prop( 'disabled', false );
	1038	+ const error = function() {
	1039	+ object.querySelectorAll( 'input[type="submit"], input[type="button"]' ).forEach(
	1040	+ button => button.disabled = false
	1041	+ );
754	1042	object.submit();
755	1043	};
756	1044
757	1045	postToAjaxUrl( object, data, success, error );
		@@ -757,22 +1045,20 @@
757	1045	postToAjaxUrl( object, data, success, error );
758	1046	}
759	1047
760	1048	function postToAjaxUrl( form, data, success, error ) {
761		- var ajaxUrl, action, ajaxParams;
	1049	+ let ajaxUrl = frm_js.ajax_url;
	1050	+ const action = form.getAttribute( 'action' );
762	1051
763		- ajaxUrl = frm_js.ajax_url; // eslint-disable-line camelcase
764		- action = form.getAttribute( 'action' );
765		-
766		- if ( 'string' === typeof action && -1 !== action.indexOf( '?action=frm_forms_preview' ) ) {
767		- ajaxUrl = action.split( '?action=frm_forms_preview' )[0];
	1052	+ if ( 'string' === typeof action && action.includes( '?action=frm_forms_preview' ) ) {
	1053	+ ajaxUrl = action.split( '?action=frm_forms_preview' )[ 0 ];
768	1054	}
769	1055
770		- ajaxParams = {
	1056	+ const ajaxParams = {
771	1057	type: 'POST',
772	1058	url: ajaxUrl,
773		- data: data,
774		- success: success
	1059	+ data,
	1060	+ success
775	1061	};
776	1062
777	1063	if ( 'function' === typeof error ) {
778	1064	ajaxParams.error = error;
		@@ -777,34 +1063,54 @@
777	1063	if ( 'function' === typeof error ) {
778	1064	ajaxParams.error = error;
779	1065	}
780	1066
781		- jQuery.ajax( ajaxParams );
	1067	+ jQuery.ajax( ajaxParams ); // eslint-disable-line no-jquery/no-ajax
782	1068	}
783	1069
784	1070	function afterFormSubmitted( object, response ) {
785		- var formCompleted = jQuery( response.content ).find( '.frm_message' );
786		- if ( formCompleted.length ) {
787		- jQuery( document ).trigger( 'frmFormComplete', [ object, response ]);
	1071	+ const tempDiv = document.createElement( 'div' );
	1072	+ tempDiv.innerHTML = response.content;
	1073	+ const formCompleted = tempDiv.querySelector( '.frm_message' );
	1074	+ if ( formCompleted ) {
	1075	+ jQuery( document ).trigger( 'frmFormComplete', [ object, response ] );
788	1076	} else {
789		- jQuery( document ).trigger( 'frmPageChanged', [ object, response ]);
	1077	+ jQuery( document ).trigger( 'frmPageChanged', [ object, response ] );
790	1078	}
791	1079	}
792	1080
	1081	+ /**
	1082	+ * Trigger an event before the form is replaced with a success message.
	1083	+ *
	1084	+ * @since 6.9
	1085	+ *
	1086	+ * @param {HTMLElement} object The form.
	1087	+ * @param {Object} response The response from submitting the form with AJAX.
	1088	+ * @return {void}
	1089	+ */
	1090	+ function afterFormSubmittedBeforeReplace( object, response ) {
	1091	+ const tempDiv = document.createElement( 'div' );
	1092	+ tempDiv.innerHTML = response.content;
	1093	+ const formCompleted = tempDiv.querySelector( '.frm_message' );
	1094	+ if ( formCompleted ) {
	1095	+ triggerCustomEvent( document, 'frmFormCompleteBeforeReplace', { object, response } );
	1096	+ }
	1097	+ }
	1098	+
793	1099	function removeAddedScripts( formContainer, formID ) {
794		- var endReplace = jQuery( '.frm_end_ajax_' + formID );
	1100	+ const endReplace = document.querySelectorAll( `.frm_end_ajax_${ formID }` );
795	1101	if ( endReplace.length ) {
796		- formContainer.nextUntil( '.frm_end_ajax_' + formID ).remove();
797		- endReplace.remove();
	1102	+ formContainer.nextUntil( `.frm_end_ajax_${ formID }` ).remove();
	1103	+ endReplace.forEach( el => el.remove() );
798	1104	}
799	1105	}
800	1106
801	1107	function maybeSlideOut( oldContent, newContent ) {
802		- var c,
803		- newClass = 'frm_slideout';
804		- if ( newContent.indexOf( ' frm_slide' ) !== -1 ) {
	1108	+ let c;
	1109	+ let newClass = 'frm_slideout';
	1110	+ if ( newContent.includes( ' frm_slide' ) ) {
805	1111	c = oldContent.children();
806		- if ( newContent.indexOf( ' frm_going_back' ) !== -1 ) {
	1112	+ if ( newContent.includes( ' frm_going_back' ) ) {
807	1113	newClass += ' frm_going_back';
808	1114	}
809	1115	c.removeClass( 'frm_going_back' );
810	1116	c.addClass( newClass );
		@@ -813,30 +1119,28 @@
813	1119	return 0;
814	1120	}
815	1121
816	1122	function addUrlParam( response ) {
817		- var url;
818		- if ( history.pushState && typeof response.page !== 'undefined' ) {
	1123	+ let url;
	1124	+ if ( history.pushState && response.page !== undefined ) {
819	1125	url = addQueryVar( 'frm_page', response.page );
820		- window.history.pushState({ 'html': response.html }, '', '?' + url );
	1126	+ window.history.pushState( { html: response.html }, '', `?${ url }` );
821	1127	}
822	1128	}
823	1129
824	1130	function addQueryVar( key, value ) {
825		- var kvp, i, x;
826		-
827	1131	key = encodeURI( key );
828	1132	value = encodeURI( value );
829	1133
830		- kvp = document.location.search.substr( 1 ).split( '&' );
	1134	+ const kvp = document.location.search.substr( 1 ).split( '&' );
831	1135
832		- i = kvp.length;
	1136	+ let i = kvp.length;
833	1137	while ( i-- ) {
834		- x = kvp[i].split( '=' );
	1138	+ const x = kvp[ i ].split( '=' );
835	1139
836		- if ( x[0] == key ) {
837		- x[1] = value;
838		- kvp[i] = x.join( '=' );
	1140	+ if ( x[ 0 ] == key ) {
	1141	+ x[ 1 ] = value;
	1142	+ kvp[ i ] = x.join( '=' );
839	1143	break;
840	1144	}
841	1145	}
842	1146
		@@ -847,73 +1151,159 @@
847	1151	return kvp.join( '&' );
848	1152	}
849	1153
850	1154	function addFieldError( $fieldCont, key, jsErrors ) {
851		- var input, id, describedBy, roleString;
852		- if ( $fieldCont.length && $fieldCont.is( ':visible' ) ) {
853		- $fieldCont.addClass( 'frm_blank_field' );
854		- input = $fieldCont.find( 'input, select, textarea' );
855		- id = 'frm_error_field_' + key;
856		- describedBy = input.attr( 'aria-describedby' );
	1155	+ const container = $fieldCont instanceof jQuery ? $fieldCont.get( 0 ) : $fieldCont;
857	1156
858		- if ( typeof frmThemeOverride_frmPlaceError === 'function' ) { // eslint-disable-line camelcase
859		- frmThemeOverride_frmPlaceError( key, jsErrors );
	1157	+ if ( ! container || container.offsetParent === null ) {
	1158	+ return;
	1159	+ }
	1160	+
	1161	+ container.classList.add( 'frm_blank_field' );
	1162	+ const inputs = container.querySelectorAll( 'input, select, textarea' );
	1163	+ const id = getErrorElementId( key, inputs[ 0 ] );
	1164	+
	1165	+ let describedBy;
	1166	+
	1167	+ if ( typeof frmThemeOverride_frmPlaceError === 'function' ) { // eslint-disable-line camelcase
	1168	+ frmThemeOverride_frmPlaceError( key, jsErrors );
	1169	+ } else {
	1170	+ let errorHtml;
	1171	+ if ( jsErrors[ key ].includes( '<div' ) ) {
	1172	+ errorHtml = jsErrors[ key ];
860	1173	} else {
861		- if ( -1 !== jsErrors[key].indexOf( '<div' ) ) {
862		- $fieldCont.append(
863		- jsErrors[key]
864		- );
865		- } else {
866		- roleString = frm_js.include_alert_role ? 'role="alert"' : ''; // eslint-disable-line camelcase
867		- $fieldCont.append( '<div class="frm_error" ' + roleString + ' id="' + id + '">' + jsErrors[key] + '</div>' );
868		- }
869		-
870		- if ( typeof describedBy === 'undefined' ) {
	1174	+ const roleString = frm_js.include_alert_role ? 'role="alert"' : '';
	1175	+ errorHtml = `<div class="frm_error" ${ roleString } id="${ id }">${ jsErrors[ key ] }</div>`;
	1176	+ }
	1177	+ container.insertAdjacentHTML( 'beforeend', errorHtml );
	1178	+ inputs.forEach( input => {
	1179	+ describedBy = input.getAttribute( 'aria-describedby' );
	1180	+ if ( ! describedBy ) {
871	1181	describedBy = id;
872		- } else if ( describedBy.indexOf( id ) === -1 && describedBy.indexOf( 'frm_error_field_' ) === -1 ) {
873		- if ( input.data( 'error-first' ) === 0 ) {
874		- describedBy = describedBy + ' ' + id;
	1182	+ } else if ( ! describedBy.includes( id ) && ! describedBy.includes( 'frm_error_field_' ) ) {
	1183	+ const { errorFirst } = input.dataset;
	1184	+ if ( errorFirst === '0' ) {
	1185	+ describedBy = `${ describedBy } ${ id }`;
875	1186	} else {
876		- describedBy = id + ' ' + describedBy;
	1187	+ describedBy = `${ id } ${ describedBy }`;
877	1188	}
878	1189	}
	1190	+ input.setAttribute( 'aria-describedby', describedBy );
	1191	+ } );
	1192	+ }
879	1193
880		- input.attr( 'aria-describedby', describedBy );
	1194	+ inputs.forEach( input => {
	1195	+ if ( [ 'radio', 'checkbox' ].includes( input.type ) ) {
	1196	+ const group = input.closest( '[role="radiogroup"], [role="group"]' );
	1197	+ if ( group ) {
	1198	+ group.setAttribute( 'aria-invalid', 'true' );
	1199	+ }
	1200	+ } else {
	1201	+ input.setAttribute( 'aria-invalid', 'true' );
881	1202	}
882		- input.attr( 'aria-invalid', true );
	1203	+ } );
883	1204
884		- jQuery( document ).trigger( 'frmAddFieldError', [ $fieldCont, key, jsErrors ]);
	1205	+ jQuery( document ).trigger( 'frmAddFieldError', [ jQuery( container ), key, jsErrors ] );
	1206	+ }
	1207	+
	1208	+ /**
	1209	+ * Get the ID to use for an error element added when submitting with AJAX.
	1210	+ *
	1211	+ * @param {string} key
	1212	+ * @param {HTMLElement} input
	1213	+ * @return {string} The ID to use for the error element.
	1214	+ */
	1215	+ function getErrorElementId( key, input ) {
	1216	+ if ( isNaN( key ) || ! input || ! input.id ) {
	1217	+ // If key isn't a number, assume it's already in the right format.
	1218	+ return `frm_error_field_${ key }`;
885	1219	}
	1220	+ return `frm_error_${ input.id }`;
886	1221	}
887	1222
888		- function removeFieldError( $fieldCont ) {
889		- var errorMessage = $fieldCont.find( '.frm_error' ),
890		- errorId = errorMessage.attr( 'id' ),
891		- input = $fieldCont.find( 'input, select, textarea' ),
892		- describedBy = input.attr( 'aria-describedby' );
	1223	+ /**
	1224	+ * Removes errors before validating with JS.
	1225	+ * This prevents issues with stale errors that has since been fixed.
	1226	+ *
	1227	+ * @param {HTMLElement|jQuery} fieldCont Field container element.
	1228	+ * @return {void}
	1229	+ */
	1230	+ function removeFieldError( fieldCont ) {
	1231	+ const container = fieldCont instanceof jQuery ? fieldCont.get( 0 ) : fieldCont;
	1232	+ if ( ! container ) {
	1233	+ return;
	1234	+ }
893	1235
894		- $fieldCont.removeClass( 'frm_blank_field has-error' );
895		- errorMessage.remove();
896		- input.attr( 'aria-invalid', false );
897		- input.removeAttr( 'aria-describedby' );
	1236	+ const errorMessage = container.querySelector( '.frm_error' );
	1237	+ const input = container.querySelector( 'input, select, textarea' );
898	1238
899		- if ( typeof describedBy !== 'undefined' ) {
900		- describedBy = describedBy.replace( errorId, '' );
901		- input.attr( 'aria-describedby', describedBy );
	1239	+ container.classList.remove( 'frm_blank_field', 'has-error' );
	1240	+
	1241	+ if ( input ) {
	1242	+ if ( 'true' === input.getAttribute( 'aria-invalid' ) ) {
	1243	+ input.setAttribute( 'aria-invalid', 'false' );
	1244	+ } else if ( [ 'radio', 'checkbox' ].includes( input.type ) ) {
	1245	+ const group = input.closest( '[role="radiogroup"], [role="group"]' );
	1246	+ if ( group ) {
	1247	+ group.setAttribute( 'aria-invalid', 'false' );
	1248	+ }
	1249	+ }
902	1250	}
	1251	+
	1252	+ if ( errorMessage ) {
	1253	+ removeElementFromInputDescribedBy( errorMessage );
	1254	+ errorMessage.remove();
	1255	+ }
903	1256	}
904	1257
	1258	+ /**
	1259	+ * Updates the aria-describedby attribute, removing the target element ID.
	1260	+ *
	1261	+ * @since 6.32
	1262	+ *
	1263	+ * @param {HTMLElement} el The target element that is removed from the aria-describedby data.
	1264	+ * @return {void}
	1265	+ */
	1266	+ function removeElementFromInputDescribedBy( el ) {
	1267	+ document.querySelectorAll( `[aria-describedby*="${ el.id }"]` ).forEach( input => {
	1268	+ let ariaDescribedBy = input.getAttribute( 'aria-describedby' ).split( ' ' );
	1269	+ ariaDescribedBy = ariaDescribedBy.filter( value => {
	1270	+ const trimmedValue = value.trim();
	1271	+ return trimmedValue && trimmedValue !== el.id;
	1272	+ } );
	1273	+
	1274	+ if ( ariaDescribedBy.length ) {
	1275	+ input.setAttribute( 'aria-describedby', ariaDescribedBy.join( ' ' ) );
	1276	+ return;
	1277	+ }
	1278	+ input.removeAttribute( 'aria-describedby' );
	1279	+ } );
	1280	+ }
	1281	+
905	1282	function removeAllErrors() {
906		- jQuery( '.form-field' ).removeClass( 'frm_blank_field has-error' );
907		- jQuery( '.form-field .frm_error' ).replaceWith( '' );
908		- jQuery( '.frm_error_style' ).remove();
	1283	+ document.querySelectorAll( '.form-field' ).forEach( field => {
	1284	+ field.classList.remove( 'frm_blank_field', 'has-error' );
	1285	+ } );
	1286	+ document.querySelectorAll( '.form-field .frm_error' ).forEach( el => {
	1287	+ removeElementFromInputDescribedBy( el );
	1288	+ el.remove();
	1289	+ } );
	1290	+ document.querySelectorAll( '.frm_error_style' ).forEach( error => error.remove() );
909	1291	}
910	1292
	1293	+ /**
	1294	+ * @param {HTMLElement|Object} object Form object.
	1295	+ * @return {void}
	1296	+ */
911	1297	function scrollToFirstField( object ) {
912		- var field = jQuery( object ).find( '.frm_blank_field' ).first();
913		- if ( field.length ) {
914		- frmFrontForm.scrollMsg( field, object, true );
	1298	+ if ( 'function' === typeof object.get ) {
	1299	+ // Get the HTMLElement from a jQuery object.
	1300	+ object = object.get( 0 );
915	1301	}
	1302	+ const field = object.querySelector( '.frm_blank_field' );
	1303	+ if ( field ) {
	1304	+ frmFrontForm.scrollMsg( jQuery( field ), object, true );
	1305	+ }
916	1306	}
917	1307
918	1308	function showSubmitLoading( $object ) {
919	1309	showLoadingIndicator( $object );
		@@ -921,9 +1311,9 @@
921	1311	disableSaveDraft( $object );
922	1312	}
923	1313
924	1314	function showLoadingIndicator( $object ) {
925		- if ( ! $object.hasClass( 'frm_loading_form' ) && ! $object.hasClass( 'frm_loading_prev' ) ) {
	1315	+ if ( ! $object.hasClass( 'frm_loading_form' ) && ! $object.hasClass( 'frm_loading_prev' ) ) { // eslint-disable-line no-jquery/no-class, formidable/no-jquery-variable-methods
926	1316	addLoadingClass( $object );
927	1317	$object.trigger( 'frmStartFormLoading' );
928	1318	}
929	1319	}
		@@ -928,110 +1318,48 @@
928	1318	}
929	1319	}
930	1320
931	1321	function addLoadingClass( $object ) {
932		- var loadingClass = isGoingToPrevPage( $object ) ? 'frm_loading_prev' : 'frm_loading_form';
	1322	+ const loadingClass = isGoingToPrevPage( $object ) ? 'frm_loading_prev' : 'frm_loading_form';
933	1323
934		- $object.addClass( loadingClass );
	1324	+ $object.addClass( loadingClass ); // eslint-disable-line no-jquery/no-class, formidable/no-jquery-variable-methods
935	1325	}
936	1326
937	1327	function isGoingToPrevPage( $object ) {
938		- return ( typeof frmProForm !== 'undefined' && frmProForm.goingToPreviousPage( $object ) );
	1328	+ return typeof frmProForm !== 'undefined' && frmProForm.goingToPreviousPage( $object );
939	1329	}
940	1330
941		- function removeSubmitLoading( $object, enable, processesRunning ) {
942		- var loadingForm;
943		-
	1331	+ function removeSubmitLoading( _, enable, processesRunning ) {
944	1332	if ( processesRunning > 0 ) {
945	1333	return;
946	1334	}
947	1335
948		- loadingForm = jQuery( '.frm_loading_form' );
949		- loadingForm.removeClass( 'frm_loading_form' );
950		- loadingForm.removeClass( 'frm_loading_prev' );
	1336	+ document.querySelectorAll( '.frm_loading_form' ).forEach( function( form ) {
	1337	+ form.classList.remove( 'frm_loading_form', 'frm_loading_prev' );
	1338	+ jQuery( form ).trigger( 'frmEndFormLoading' );
951	1339
952		- loadingForm.trigger( 'frmEndFormLoading' );
953		-
954		- if ( enable === 'enable' ) {
955		- enableSubmitButton( loadingForm );
956		- enableSaveDraft( loadingForm );
957		- }
	1340	+ if ( enable === 'enable' ) {
	1341	+ enableSubmitButton( form );
	1342	+ enableSaveDraft( form );
	1343	+ }
	1344	+ } );
958	1345	}
959	1346
960	1347	function showFileLoading( object ) {
961		- var fileval,
962		- loading = document.getElementById( 'frm_loading' );
963		- if ( loading !== null ) {
964		- fileval = jQuery( object ).find( 'input[type=file]' ).val();
965		- if ( typeof fileval !== 'undefined' && fileval !== '' ) {
966		- setTimeout( function() {
967		- jQuery( loading ).fadeIn( 'slow' );
968		- }, 2000 );
969		- }
	1348	+ const loading = document.getElementById( 'frm_loading' );
	1349	+ if ( ! loading ) {
	1350	+ return;
970	1351	}
971		- }
972	1352
973		- function clearDefault() {
974		- /*jshint validthis:true */
975		- toggleDefault( jQuery( this ), 'clear' );
976		- }
977		-
978		- function replaceDefault() {
979		- /*jshint validthis:true */
980		- toggleDefault( jQuery( this ), 'replace' );
981		- }
982		-
983		- function toggleDefault( $thisField, e ) {
984		- // TODO: Fix this for a default value that is a number or array
985		- var thisVal,
986		- v = $thisField.data( 'frmval' ).replace( /(\n|\r\n)/g, '\r' );
987		- if ( v === '' || typeof v === 'undefined' ) {
988		- return false;
	1353	+ const fileInput = object.querySelector( 'input[type=file]' );
	1354	+ const fileval = fileInput ? fileInput.value : '';
	1355	+ if ( fileval !== '' ) {
	1356	+ setTimeout( function() {
	1357	+ jQuery( loading ).fadeIn( 'slow' ); // eslint-disable-line no-jquery/no-fade
	1358	+ }, 2000 );
989	1359	}
990		- thisVal = $thisField.val().replace( /(\n|\r\n)/g, '\r' );
991		-
992		- if ( 'replace' === e ) {
993		- if ( thisVal === '' ) {
994		- $thisField.addClass( 'frm_default' ).val( v );
995		- }
996		- } else if ( thisVal == v ) {
997		- $thisField.removeClass( 'frm_default' ).val( '' );
998		- }
999	1360	}
1000	1361
1001		- function resendEmail() {
1002		- /*jshint validthis:true */
1003		- var $link = jQuery( this ),
1004		- entryId = this.getAttribute( 'data-eid' ),
1005		- formId = this.getAttribute( 'data-fid' ),
1006		- label = $link.find( '.frm_link_label' );
1007		- if ( label.length < 1 ) {
1008		- label = $link;
1009		- }
1010		- label.append( '<span class="frm-wait"></span>' );
1011		-
1012		- jQuery.ajax({
1013		- type: 'POST',
1014		- url: frm_js.ajax_url, // eslint-disable-line camelcase
1015		- data: {
1016		- action: 'frm_entries_send_email',
1017		- entry_id: entryId,
1018		- form_id: formId,
1019		- nonce: frm_js.nonce // eslint-disable-line camelcase
1020		- },
1021		- success: function( msg ) {
1022		- var admin = document.getElementById( 'wpbody' );
1023		- if ( admin === null ) {
1024		- label.html( msg );
1025		- } else {
1026		- label.html( '' );
1027		- $link.after( msg );
1028		- }
1029		- }
1030		- });
1031		- return false;
1032		- }
1033		-
1034	1362	/**********************************************
1035	1363	* General Helpers
1036	1364	*********************************************/
1037	1365
		@@ -1036,68 +1364,12 @@
1036	1364	*********************************************/
1037	1365
1038	1366	function confirmClick() {
1039	1367	/*jshint validthis:true */
1040		- var message = jQuery( this ).data( 'frmconfirm' );
	1368	+ const message = this.dataset.frmconfirm;
1041	1369	return confirm( message );
1042	1370	}
1043	1371
1044		- function toggleDiv() {
1045		- /*jshint validthis:true */
1046		- var div = jQuery( this ).data( 'frmtoggle' );
1047		- if ( jQuery( div ).is( ':visible' ) ) {
1048		- jQuery( div ).slideUp( 'fast' );
1049		- } else {
1050		- jQuery( div ).slideDown( 'fast' );
1051		- }
1052		- return false;
1053		- }
1054		-
1055		- /**********************************************
1056		- * Fallback functions
1057		- *********************************************/
1058		-
1059		- function addTrimFallbackForIE() {
1060		- if ( typeof String.prototype.trim !== 'function' ) {
1061		- String.prototype.trim = function() {
1062		- return this.replace( /^\s+|\s+$/g, '' );
1063		- };
1064		- }
1065		- }
1066		-
1067		- function addFilterFallbackForIE() {
1068		- var t, len, res, thisp, i, val;
1069		-
1070		- if ( ! Array.prototype.filter ) {
1071		-
1072		- Array.prototype.filter = function( fun /*, thisp */ ) {
1073		-
1074		- if ( this === void 0 || this === null ) {
1075		- throw new TypeError();
1076		- }
1077		-
1078		- t = Object( this );
1079		- len = t.length >>> 0;
1080		- if ( typeof fun !== 'function' ) {
1081		- throw new TypeError();
1082		- }
1083		-
1084		- res = [];
1085		- thisp = arguments[1];
1086		- for ( i = 0; i < len; i++ ) {
1087		- if ( i in t ) {
1088		- val = t[i]; // in case fun mutates this
1089		- if ( fun.call( thisp, val, i, t ) ) {
1090		- res.push( val );
1091		- }
1092		- }
1093		- }
1094		-
1095		- return res;
1096		- };
1097		- }
1098		- }
1099		-
1100	1372	/**
1101	1373	* Check for -webkit-box-shadow css value for input:-webkit-autofill selector.
1102	1374	* If this is a match, the User is autofilling the input on a Webkit browser.
1103	1375	* We want to delete the Honeypot field, otherwise it will get triggered as spam on autocomplete.
		@@ -1102,44 +1374,15 @@
1102	1374	* If this is a match, the User is autofilling the input on a Webkit browser.
1103	1375	* We want to delete the Honeypot field, otherwise it will get triggered as spam on autocomplete.
1104	1376	*/
1105	1377	function onHoneypotFieldChange() {
1106		- var css = jQuery( this ).css( 'box-shadow' );
1107		- if ( css.match( /inset/ ) ) {
1108		- this.parentNode.removeChild( this );
	1378	+ /*jshint validthis:true */
	1379	+ const css = window.getComputedStyle( this ).boxShadow;
	1380	+ if ( css?.match( /inset/ ) ) {
	1381	+ this.remove();
1109	1382	}
1110	1383	}
1111	1384
1112		- function maybeMakeHoneypotFieldsUntabbable() {
1113		- document.addEventListener( 'keydown', handleKeyUp );
1114		-
1115		- function handleKeyUp( event ) {
1116		- var code;
1117		-
1118		- if ( 'undefined' !== typeof event.key ) {
1119		- code = event.key;
1120		- } else if ( 'undefined' !== typeof event.keyCode && 9 === event.keyCode ) {
1121		- code = 'Tab';
1122		- }
1123		-
1124		- if ( 'Tab' === code ) {
1125		- makeHoneypotFieldsUntabbable();
1126		- document.removeEventListener( 'keydown', handleKeyUp );
1127		- }
1128		- }
1129		-
1130		- function makeHoneypotFieldsUntabbable() {
1131		- document.querySelectorAll( '.frm_verify' ).forEach(
1132		- function( wrapper ) {
1133		- var input = wrapper.querySelector( 'input[id^=frm_email]' );
1134		- if ( input ) {
1135		- input.setAttribute( 'tabindex', -1 );
1136		- }
1137		- }
1138		- );
1139		- }
1140		- }
1141		-
1142	1385	/**
1143	1386	* Focus on the first sub field when clicking to the primary label of combo field.
1144	1387	*
1145	1388	* @since 4.10.02
		@@ -1144,11 +1387,11 @@
1144	1387	*
1145	1388	* @since 4.10.02
1146	1389	*/
1147	1390	function changeFocusWhenClickComboFieldLabel() {
1148		- var label;
	1391	+ let label;
1149	1392
1150		- var comboInputsContainer = document.querySelectorAll( '.frm_combo_inputs_container' );
	1393	+ const comboInputsContainer = document.querySelectorAll( '.frm_combo_inputs_container' );
1151	1394	comboInputsContainer.forEach( function( inputsContainer ) {
1152	1395	if ( ! inputsContainer.closest( '.frm_form_field' ) ) {
1153	1396	return;
1154	1397	}
		@@ -1157,38 +1400,64 @@
1157	1400	if ( ! label ) {
1158	1401	return;
1159	1402	}
1160	1403
1161		- label.addEventListener( 'click', function( e ) {
	1404	+ label.addEventListener( 'click', function() {
1162	1405	inputsContainer.querySelector( '.frm_form_field:first-child input, .frm_form_field:first-child select, .frm_form_field:first-child textarea' ).focus();
1163		- });
1164		- });
	1406	+ } );
	1407	+ } );
1165	1408	}
1166	1409
	1410	+ /**
	1411	+ * Sets focus on a the first subfield of a combo field that has an error.
	1412	+ *
	1413	+ * @since 6.16.3
	1414	+ *
	1415	+ * @param {HTMLElement} element
	1416	+ * @return {boolean} True if the focus was set on a combo field.
	1417	+ */
	1418	+ function maybeFocusOnComboSubField( element ) {
	1419	+ if ( 'FIELDSET' !== element.nodeName ) {
	1420	+ return false;
	1421	+ }
	1422	+ if ( ! element.querySelector( '.frm_combo_inputs_container' ) ) {
	1423	+ return false;
	1424	+ }
	1425	+ const comboSubfield = element.querySelector( '[aria-invalid="true"]' );
	1426	+ if ( comboSubfield ) {
	1427	+ focusInput( comboSubfield );
	1428	+ return true;
	1429	+ }
	1430	+ return false;
	1431	+ }
	1432	+
1167	1433	function checkForErrorsAndMaybeSetFocus() {
1168		- var errors, element, timeoutCallback;
1169		-
1170		- if ( ! frm_js.focus_first_error ) { // eslint-disable-line camelcase
	1434	+ if ( ! frm_js.focus_first_error ) {
1171	1435	return;
1172	1436	}
1173	1437
1174		- errors = document.querySelectorAll( '.frm_form_field .frm_error' );
	1438	+ const errors = document.querySelectorAll( '.frm_form_field .frm_error' );
1175	1439	if ( ! errors.length ) {
1176	1440	return;
1177	1441	}
1178	1442
1179		- element = errors[0];
	1443	+ let element = errors[ 0 ];
	1444	+ let timeoutCallback;
1180	1445	do {
1181	1446	element = element.previousSibling;
1182		- if ( -1 !== [ 'input', 'select', 'textarea' ].indexOf( element.nodeName.toLowerCase() ) ) {
1183		- element.focus();
	1447	+ if ( [ 'input', 'select', 'textarea' ].includes( element.nodeName.toLowerCase() ) ) {
	1448	+ focusInput( element );
1184	1449	break;
1185	1450	}
1186	1451
1187		- if ( 'undefined' !== typeof element.classList ) {
	1452	+ if ( maybeFocusOnComboSubField( element ) ) {
	1453	+ break;
	1454	+ }
	1455	+
	1456	+ if ( element.classList !== undefined ) {
1188	1457	if ( element.classList.contains( 'html-active' ) ) {
1189	1458	timeoutCallback = function() {
1190		- var textarea = element.querySelector( 'textarea' );
	1459	+ const textarea = element.querySelector( 'textarea' );
1191	1460	if ( null !== textarea ) {
1192	1461	textarea.focus();
1193	1462	}
1194	1463	};
		@@ -1195,8 +1464,14 @@
1195	1464	} else if ( element.classList.contains( 'tmce-active' ) ) {
1196	1465	timeoutCallback = function() {
1197	1466	tinyMCE.activeEditor.focus();
1198	1467	};
	1468	+ } else if ( element.classList.contains( 'frm_opt_container' ) ) {
	1469	+ const firstInput = element.querySelector( 'input' );
	1470	+ if ( firstInput ) {
	1471	+ focusInput( firstInput );
	1472	+ break;
	1473	+ }
1199	1474	}
1200	1475
1201	1476	if ( 'function' === typeof timeoutCallback ) {
1202	1477	setTimeout( timeoutCallback, 0 );
		@@ -1206,16 +1481,21 @@
1206	1481	} while ( element.previousSibling );
1207	1482	}
1208	1483
1209	1484	/**
1210		- * Checks if is on IE browser.
	1485	+ * Focus a visible input, or possibly delay the focus event until the form has faded in.
1211	1486	*
1212		- * @since 5.4
	1487	+ * @since 6.16.3
1213	1488	*
1214		- * @return {Boolean}
	1489	+ * @param {HTMLElement} input
	1490	+ * @return {void}
1215	1491	*/
1216		- function isIE() {
1217		- return navigator.userAgent.indexOf( 'MSIE' ) > -1 || navigator.userAgent.indexOf( 'Trident' ) > -1;
	1492	+ function focusInput( input ) {
	1493	+ if ( input.offsetParent !== null ) {
	1494	+ input.focus();
	1495	+ } else {
	1496	+ triggerCustomEvent( document, 'frmMaybeDelayFocus', { input } );
	1497	+ }
1218	1498	}
1219	1499
1220	1500	/**
1221	1501	* Does the same as jQuery( document ).on( 'event', 'selector', handler ).
		@@ -1221,24 +1501,24 @@
1221	1501	* Does the same as jQuery( document ).on( 'event', 'selector', handler ).
1222	1502	*
1223	1503	* @since 5.4
1224	1504	*
1225		- * @param {String} event Event name.
1226		- * @param {String} selector Selector.
1227		- * @param {Function} handler Handler.
1228		- * @param {Boolean|Object} options Options to be added to `addEventListener()` method. Default is `false`.
	1505	+ * @param {string} event Event name.
	1506	+ * @param {string} selector Selector.
	1507	+ * @param {Function} handler Handler.
	1508	+ * @param {boolean | Object} options Options to be added to `addEventListener()` method. Default is `false`.
1229	1509	*/
1230	1510	function documentOn( event, selector, handler, options ) {
1231		- if ( 'undefined' === typeof options ) {
	1511	+ if ( options === undefined ) {
1232	1512	options = false;
1233	1513	}
1234	1514
1235	1515	document.addEventListener( event, function( e ) {
1236		- var target;
	1516	+ let target;
1237	1517
1238	1518	// loop parent nodes from the target to the delegation node.
1239	1519	for ( target = e.target; target && target != this; target = target.parentNode ) {
1240		- if ( target && target.matches && target.matches( selector ) ) {
	1520	+ if ( target.matches && target.matches( selector ) ) {
1241	1521	handler.call( target, e );
1242	1522	break;
1243	1523	}
1244	1524	}
		@@ -1245,27 +1525,23 @@
1245	1525	}, options );
1246	1526	}
1247	1527
1248	1528	function initFloatingLabels() {
1249		- var checkFloatLabel, checkDropdownLabel, checkPlaceholderIE, runOnLoad, selector, floatClass;
	1529	+ const selector = '.frm-show-form .frm_inside_container input, .frm-show-form .frm_inside_container select, .frm-show-form .frm_inside_container textarea';
	1530	+ const floatClass = 'frm_label_float_top';
1250	1531
1251		- selector = '.frm-show-form .frm_inside_container input, .frm-show-form .frm_inside_container select, .frm-show-form .frm_inside_container textarea';
1252		- floatClass = 'frm_label_float_top';
1253		-
1254		- checkFloatLabel = function( input ) {
1255		- var container, shouldFloatTop, firstOpt;
1256		-
1257		- container = input.closest( '.frm_inside_container' );
	1532	+ const checkFloatLabel = function( input ) {
	1533	+ const container = input.closest( '.frm_inside_container' );
1258	1534	if ( ! container ) {
1259	1535	return;
1260	1536	}
1261	1537
1262		- shouldFloatTop = input.value || document.activeElement === input;
	1538	+ const shouldFloatTop = input.value || document.activeElement === input;
1263	1539
1264	1540	container.classList.toggle( floatClass, shouldFloatTop );
1265	1541
1266	1542	if ( 'SELECT' === input.tagName ) {
1267		- firstOpt = input.querySelector( 'option:first-child' );
	1543	+ const firstOpt = input.querySelector( 'option:first-child' );
1268	1544
1269	1545	if ( shouldFloatTop ) {
1270	1546	if ( firstOpt.hasAttribute( 'data-label' ) ) {
1271	1547	firstOpt.textContent = firstOpt.getAttribute( 'data-label' );
		@@ -1270,49 +1546,26 @@
1270	1546	if ( firstOpt.hasAttribute( 'data-label' ) ) {
1271	1547	firstOpt.textContent = firstOpt.getAttribute( 'data-label' );
1272	1548	firstOpt.removeAttribute( 'data-label' );
1273	1549	}
1274		- } else {
1275		- if ( firstOpt.textContent ) {
1276		- firstOpt.setAttribute( 'data-label', firstOpt.textContent );
1277		- firstOpt.textContent = '';
1278		- }
	1550	+ } else if ( firstOpt.textContent ) {
	1551	+ firstOpt.setAttribute( 'data-label', firstOpt.textContent );
	1552	+ firstOpt.textContent = '';
1279	1553	}
1280		- } else if ( isIE() ) {
1281		- checkPlaceholderIE( input );
1282	1554	}
1283	1555	};
1284	1556
1285		- checkDropdownLabel = function() {
1286		- document.querySelectorAll( '.frm-show-form .frm_inside_container:not(.' + floatClass + ') select' ).forEach( function( input ) {
1287		- var firstOpt = input.querySelector( 'option:first-child' );
	1557	+ const checkDropdownLabel = function() {
	1558	+ document.querySelectorAll( `.frm-show-form .frm_inside_container:not(.${ floatClass }) select` ).forEach( function( input ) {
	1559	+ const firstOpt = input.querySelector( 'option:first-child' );
1288	1560
1289	1561	if ( firstOpt.textContent ) {
1290	1562	firstOpt.setAttribute( 'data-label', firstOpt.textContent );
1291	1563	firstOpt.textContent = '';
1292	1564	}
1293		- });
	1565	+ } );
1294	1566	};
1295	1567
1296		- checkPlaceholderIE = function( input ) {
1297		- if ( input.value ) {
1298		- // Don't need to handle this case because placeholder isn't shown.
1299		- return;
1300		- }
1301		-
1302		- if ( document.activeElement === input ) {
1303		- if ( input.hasAttribute( 'data-placeholder' ) ) {
1304		- input.placeholder = input.getAttribute( 'data-placeholder' );
1305		- input.removeAttribute( 'data-placeholder' );
1306		- }
1307		- } else {
1308		- if ( input.placeholder ) {
1309		- input.setAttribute( 'data-placeholder', input.placeholder );
1310		- input.placeholder = '';
1311		- }
1312		- }
1313		- };
1314		-
1315	1568	[ 'focus', 'blur', 'change' ].forEach( function( eventName ) {
1316	1569	documentOn(
1317	1570	eventName,
1318	1571	selector,
		@@ -1320,21 +1573,17 @@
1320	1573	checkFloatLabel( event.target );
1321	1574	},
1322	1575	true
1323	1576	);
1324		- });
	1577	+ } );
1325	1578
1326		- jQuery( document ).on( 'change', selector, function( event ) {
1327		- checkFloatLabel( event.target );
1328		- });
1329		-
1330		- runOnLoad = function( firstLoad ) {
1331		- if ( firstLoad && document.activeElement && -1 !== [ 'INPUT', 'SELECT', 'TEXTAREA' ].indexOf( document.activeElement.tagName ) ) {
	1579	+ const runOnLoad = function( firstLoad ) {
	1580	+ if ( firstLoad && document.activeElement && [ 'INPUT', 'SELECT', 'TEXTAREA' ].includes( document.activeElement.tagName ) ) {
1332	1581	checkFloatLabel( document.activeElement );
1333	1582	} else if ( firstLoad ) {
1334	1583	document.querySelectorAll( '.frm_inside_container' ).forEach(
1335	1584	function( container ) {
1336		- var input = container.querySelector( 'input, select, textarea' );
	1585	+ const input = container.querySelector( 'input, select, textarea' );
1337	1586	if ( input && '' !== input.value ) {
1338	1587	checkFloatLabel( input );
1339	1588	}
1340	1589	}
		@@ -1341,14 +1590,9 @@
1341	1590	);
1342	1591	}
1343	1592
1344	1593	checkDropdownLabel();
1345		-
1346		- if ( isIE() ) {
1347		- document.querySelectorAll( selector ).forEach( function( input ) {
1348		- checkPlaceholderIE( input );
1349		- });
1350		- }
	1594	+ calcProductsTotal();
1351	1595	};
1352	1596
1353	1597	runOnLoad( true );
1354	1598
		@@ -1353,91 +1597,610 @@
1353	1597	runOnLoad( true );
1354	1598
1355	1599	jQuery( document ).on( 'frmPageChanged', function( event ) {
1356	1600	runOnLoad();
1357		- });
	1601	+ } );
1358	1602
1359	1603	document.addEventListener( 'frm_after_start_over', function( event ) {
1360	1604	runOnLoad();
1361		- });
	1605	+ } );
1362	1606	}
1363	1607
	1608	+ function shouldUpdateValidityMessage( target ) {
	1609	+ if ( 'INPUT' !== target.nodeName ) {
	1610	+ return false;
	1611	+ }
	1612	+
	1613	+ if ( ! target.dataset.invmsg ) {
	1614	+ return false;
	1615	+ }
	1616	+
	1617	+ if ( 'text' !== target.getAttribute( 'type' ) ) {
	1618	+ return false;
	1619	+ }
	1620	+
	1621	+ if ( target.classList.contains( 'frm_verify' ) ) {
	1622	+ return false;
	1623	+ }
	1624	+
	1625	+ return true;
	1626	+ }
	1627	+
	1628	+ function maybeClearCustomValidityMessage( event, field ) {
	1629	+ let key;
	1630	+ let isInvalid = false;
	1631	+
	1632	+ if ( ! shouldUpdateValidityMessage( field ) ) {
	1633	+ return;
	1634	+ }
	1635	+
	1636	+ for ( key in field.validity ) {
	1637	+ if ( 'customError' === key ) {
	1638	+ continue;
	1639	+ }
	1640	+ if ( 'valid' !== key && field.validity[ key ] === true ) {
	1641	+ isInvalid = true;
	1642	+ break;
	1643	+ }
	1644	+ }
	1645	+
	1646	+ if ( ! isInvalid ) {
	1647	+ field.setCustomValidity( '' );
	1648	+ }
	1649	+ }
	1650	+
1364	1651	function maybeShowNewTabFallbackMessage() {
1365		- var messageEl;
1366		-
1367	1652	if ( ! window.frmShowNewTabFallback ) {
1368	1653	return;
1369	1654	}
1370	1655
1371		- messageEl = document.querySelector( '#frm_form_' + frmShowNewTabFallback.formId + '_container .frm_message' );
	1656	+ const messageEl = document.querySelector( `#frm_form_${ frmShowNewTabFallback.formId }_container .frm_message` );
1372	1657	if ( ! messageEl ) {
1373	1658	return;
1374	1659	}
1375	1660
1376		- messageEl.insertAdjacentHTML( 'beforeend', ' ' + frmShowNewTabFallback.message );
	1661	+ messageEl.insertAdjacentHTML( 'beforeend', ` ${ frmShowNewTabFallback.message }` );
1377	1662	}
1378	1663
1379	1664	function setCustomValidityMessage() {
1380		- var forms, length, index;
	1665	+ const forms = document.getElementsByClassName( 'frm-show-form' );
	1666	+ const { length } = forms;
1381	1667
1382		- forms = document.getElementsByClassName( 'frm-show-form' );
1383		- length = forms.length;
1384		-
1385		- for ( index = 0; index < length; ++index ) {
	1668	+ for ( let index = 0; index < length; ++index ) {
1386	1669	forms[ index ].addEventListener(
1387	1670	'invalid',
1388	1671	function( event ) {
1389		- var target = event.target;
	1672	+ const { target } = event;
1390	1673
1391		- if ( 'INPUT' !== target.nodeName ) {
1392		- return;
	1674	+ if ( shouldUpdateValidityMessage( target ) ) {
	1675	+ target.setCustomValidity( target.dataset.invmsg );
1393	1676	}
	1677	+ },
	1678	+ true
	1679	+ );
	1680	+ }
	1681	+ }
1394	1682
1395		- if ( ! target.dataset.invmsg ) {
1396		- return;
	1683	+ function enableSubmitButtonOnBackButtonPress() {
	1684	+ window.addEventListener( 'pageshow', function( event ) {
	1685	+ if ( event.persisted ) {
	1686	+ document.querySelectorAll( '.frm_loading_form' ).forEach(
	1687	+ function( form ) {
	1688	+ enableSubmitButton( form );
1397	1689	}
	1690	+ );
	1691	+ removeSubmitLoading();
	1692	+ }
	1693	+ } );
	1694	+ }
1398	1695
1399		- if ( 'text' !== target.getAttribute( 'type' ) ) {
1400		- return;
	1696	+ /**
	1697	+ * Destroys the formidable generated global hcaptcha object since it wouldn't otherwise render.
	1698	+ */
	1699	+ function destroyhCaptcha() {
	1700	+ if ( ! window.hasOwnProperty( 'hcaptcha' ) || ! document.querySelector( '.frm-show-form .h-captcha' ) ) {
	1701	+ return;
	1702	+ }
	1703	+ window.hcaptcha = null;
	1704	+ }
	1705	+
	1706	+ /**
	1707	+ * @since 6.16.3
	1708	+ *
	1709	+ * @return {string} Unique key, used for duplicate checks.
	1710	+ */
	1711	+ function getUniqueKey() {
	1712	+ const uniqueKey = Array.from( window.crypto.getRandomValues( new Uint8Array( 8 ) ) )
	1713	+ .map( b => b.toString( 16 ).padStart( 2, '0' ) )
	1714	+ .join( '' );
	1715	+ const timestamp = Date.now().toString( 16 );
	1716	+ return `${ uniqueKey }-${ timestamp }`;
	1717	+ }
	1718	+
	1719	+ /**
	1720	+ * Animates the scroll position of the document.
	1721	+ *
	1722	+ * @since 6.20
	1723	+ *
	1724	+ * @param {number} start
	1725	+ * @param {number} end
	1726	+ * @param {number} duration
	1727	+ * @return {void}
	1728	+ */
	1729	+ function animateScroll( start, end, duration ) {
	1730	+ if ( ! window.hasOwnProperty( 'performance' ) || ! window.hasOwnProperty( 'requestAnimationFrame' ) ) {
	1731	+ document.documentElement.scrollTop = end;
	1732	+ return;
	1733	+ }
	1734	+
	1735	+ const startTime = performance.now();
	1736	+ const step = currentTime => {
	1737	+ const progress = Math.min( ( currentTime - startTime ) / duration, 1 );
	1738	+ document.documentElement.scrollTop = start + ( ( end - start ) * progress );
	1739	+ if ( progress < 1 ) {
	1740	+ requestAnimationFrame( step );
	1741	+ }
	1742	+ };
	1743	+ requestAnimationFrame( step );
	1744	+ }
	1745	+
	1746	+ /**
	1747	+ * Make sure that the captcha label for a reCAPTCHA or Turnstile field matches the response input ID.
	1748	+ * This is determined dynamically, so we check for the ID after the input is rendered.
	1749	+ * hCaptcha is handled separately, in the frmCaptcha function as it is not rendered explicitly.
	1750	+ *
	1751	+ * @since 6.25.1
	1752	+ *
	1753	+ * @param {HTMLElement} captcha
	1754	+ * @return {void}
	1755	+ */
	1756	+ function maybeFixCaptchaLabel( captcha ) {
	1757	+ const form = captcha.closest( 'form' );
	1758	+ if ( ! form ) {
	1759	+ return;
	1760	+ }
	1761	+
	1762	+ const label = form.querySelector( 'label[for="g-recaptcha-response"], label[for="cf-turnstile-response"]' );
	1763	+ const captchaResponse = form.querySelector( '[name="g-recaptcha-response"], [name="cf-turnstile-response"]' );
	1764	+
	1765	+ if ( label && captchaResponse ) {
	1766	+ label.htmlFor = captchaResponse.id;
	1767	+ }
	1768	+ }
	1769	+
	1770	+ /**
	1771	+ * Check to make sure the quantity field value is within the min and max values.
	1772	+ *
	1773	+ * @param {HTMLElement} input
	1774	+ * @return {number} The quantity value.
	1775	+ */
	1776	+ function checkQuantityFieldMinMax( input ) {
	1777	+ if ( '' === input.value ) {
	1778	+ // Leave the value if it is empty.
	1779	+ return 0;
	1780	+ }
	1781	+
	1782	+ const val = parseFloat( input.value ? input.value.trim() : 0 );
	1783	+ if ( isNaN( val ) ) {
	1784	+ return 0;
	1785	+ }
	1786	+
	1787	+ let max = input.hasAttribute( 'max' ) ? parseFloat( input.getAttribute( 'max' ) ) : 0;
	1788	+ let min = input.hasAttribute( 'min' ) ? parseFloat( input.getAttribute( 'min' ) ) : 0;
	1789	+
	1790	+ max = isNaN( max ) ? 0 : max;
	1791	+ min = isNaN( min ) ? 0 : Math.max( 0, min );
	1792	+
	1793	+ if ( val < min ) {
	1794	+ input.value = min;
	1795	+ return min;
	1796	+ }
	1797	+
	1798	+ if ( 0 !== max && val > max ) {
	1799	+ input.value = max;
	1800	+ return max;
	1801	+ }
	1802	+
	1803	+ return val;
	1804	+ }
	1805	+
	1806	+ function triggerChange( input, fieldKey ) {
	1807	+ if ( fieldKey === undefined ) {
	1808	+ fieldKey = 'dependent';
	1809	+ }
	1810	+
	1811	+ jQuery( input ).trigger( { type: 'change', selfTriggered: true, frmTriggered: fieldKey } );
	1812	+ }
	1813	+
	1814	+ /**
	1815	+ * Calculates the total price.
	1816	+ *
	1817	+ * @param {Event|undefined} e The event object.
	1818	+ * @return {void}
	1819	+ */
	1820	+ function calcProductsTotal( e ) {
	1821	+ if ( 'object' === typeof frmProForm ) {
	1822	+ // Pro is installed, use the Pro JS.
	1823	+ return;
	1824	+ }
	1825	+
	1826	+ if ( typeof __FRMCURR === 'undefined' ) {
	1827	+ return;
	1828	+ }
	1829	+
	1830	+ const totalFields = document.querySelectorAll( '[data-frmtotal]' );
	1831	+ if ( ! totalFields.length ) {
	1832	+ return;
	1833	+ }
	1834	+
	1835	+ const formTotals = [];
	1836	+
	1837	+ totalFields.forEach( totalField => {
	1838	+ let total = 0;
	1839	+ const form = totalField.closest( 'form' );
	1840	+
	1841	+ if ( ! form ) {
	1842	+ return;
	1843	+ }
	1844	+
	1845	+ const formId = form.querySelector( 'input[name="form_id"]' ).value;
	1846	+ const currency = getCurrency( formId );
	1847	+
	1848	+ if ( undefined !== formTotals[ formId ] ) {
	1849	+ total = formTotals[ formId ];
	1850	+ } else {
	1851	+ form.querySelectorAll( 'input[data-frmprice],select:has([data-frmprice])' ).forEach( function( input ) {
	1852	+ let quantity = 0;
	1853	+ let price = 0;
	1854	+ const isSingle = 'hidden' === input.type;
	1855	+
	1856	+ if ( input.tagName === 'SELECT' ) {
	1857	+ if ( input.selectedIndex !== -1 ) {
	1858	+ price = input.options[ input.selectedIndex ].getAttribute( 'data-frmprice' );
	1859	+ }
	1860	+ } else {
	1861	+ if ( ! isSingle && ! input.matches( ':checked' ) ) {
	1862	+ return;
	1863	+ }
	1864	+ price = input.getAttribute( 'data-frmprice' );
1401	1865	}
1402	1866
1403		- if ( target.classList.contains( 'frm_verify' ) ) {
1404		- return;
	1867	+ if ( ! price ) {
	1868	+ price = 0;
	1869	+ } else {
	1870	+ price = preparePrice( price, currency );
	1871	+ quantity = getQuantity( input );
	1872	+ price = parseFloat( quantity ) * parseFloat( price );
1405	1873	}
1406	1874
1407		- target.setCustomValidity( target.dataset.invmsg );
1408		- },
1409		- true
1410		- );
	1875	+ if ( 'true' === input.getAttribute( 'data-frmdiscount' ) ) {
	1876	+ price = price * -1;
	1877	+ }
	1878	+
	1879	+ total += price;
	1880	+ } );
	1881	+
	1882	+ formTotals[ formId ] = total;
	1883	+ }
	1884	+
	1885	+ total = isNaN( total ) ? 0 : total;
	1886	+
	1887	+ // Set a decimal separator for currency if no default for it
	1888	+ currency.decimal_separator = currency.decimal_separator.trim(); // first remove unnecessary space(s)
	1889	+ if ( ! currency.decimal_separator.length ) {
	1890	+ currency.decimal_separator = '.';
	1891	+ }
	1892	+
	1893	+ totalField.value = roundTotal( total, currency );
	1894	+ total = normalizeTotal( total, currency );
	1895	+
	1896	+ // because of e.g. fields that might be using this field for calculations
	1897	+ triggerChange( totalField );
	1898	+
	1899	+ total = formatCurrency( total, currency );
	1900	+ const formatted = totalField.previousElementSibling;
	1901	+ if ( formatted?.matches( '.frm_total_formatted' ) ) {
	1902	+ // Use innerHTML so that currency symbols like Euros can render and not their encoded string value.
	1903	+ formatted.innerHTML = total;
	1904	+ return;
	1905	+ }
	1906	+
	1907	+ const formattedEls = totalField.closest( '.frm_form_field' ).querySelectorAll( '.frm_total_formatted' );
	1908	+ formattedEls.forEach( formattedEl => {
	1909	+ // Use innerHTML so that currency symbols like Euros can render and not their encoded string value.
	1910	+ formattedEl.innerHTML = total;
	1911	+ } );
	1912	+ } );
	1913	+ }
	1914	+
	1915	+ /**
	1916	+ * Round total and maybe add trailing zeros so formatCurrency has a proper format to work with.
	1917	+ *
	1918	+ * @param {number} total The total amount to normalize.
	1919	+ * @param {Object} currency The currency object containing decimal information.
	1920	+ * @return {string} The normalized total amount.
	1921	+ */
	1922	+ function normalizeTotal( total, currency ) {
	1923	+ const isLargeTotal = total > Number.MAX_SAFE_INTEGER;
	1924	+
	1925	+ total = roundTotal( total, currency );
	1926	+
	1927	+ return maybeAddTrailingZeroToPrice( total, currency, isLargeTotal );
	1928	+ }
	1929	+
	1930	+ function roundTotal( total, currency ) {
	1931	+ const isLargeTotal = total > Number.MAX_SAFE_INTEGER;
	1932	+
	1933	+ if ( ! isLargeTotal ) {
	1934	+ const { decimals } = currency;
	1935	+ total = decimals > 0 ? round10( total, decimals ) : Math.ceil( total );
1411	1936	}
	1937	+
	1938	+ return total;
1412	1939	}
1413	1940
1414		- return {
1415		- init: function() {
1416		- maybeAddPolyfills();
	1941	+ function round10( value, decimals ) {
	1942	+ return Number( `${ Math.round( `${ value }e${ decimals }` ) }e-${ decimals }` );
	1943	+ }
1417	1944
1418		- jQuery( document ).off( 'submit.formidable', '.frm-show-form' );
1419		- jQuery( document ).on( 'submit.formidable', '.frm-show-form', frmFrontForm.submitForm );
	1945	+ /**
	1946	+ * Format a numeric value according to the specified currency format settings.
	1947	+ *
	1948	+ * @param {string} total The numeric value to format.
	1949	+ * @param {Object} currency The currency formatting configuration.
	1950	+ * @return {string} The formatted currency string.
	1951	+ */
	1952	+ function formatCurrency( total, currency ) {
	1953	+ total = maybeAddTrailingZeroToPrice( total, currency );
	1954	+ if ( total.length && ( total[ total.length - 1 ] === '.' || total[ total.length - 1 ] === currency.decimal_separator ) ) {
	1955	+ total = total.substr( 0, total.length - 1 );
	1956	+ }
1420	1957
1421		- jQuery( '.frm-show-form input[onblur], .frm-show-form textarea[onblur]' ).each( function() {
1422		- if ( jQuery( this ).val() === '' ) {
1423		- jQuery( this ).trigger( 'blur' );
	1958	+ total = maybeRemoveTrailingZerosFromPrice( total, currency );
	1959	+ total = addThousands( total, currency );
	1960	+
	1961	+ const leftSymbol = currency.symbol_left ? ( currency.symbol_left + currency.symbol_padding ) : '';
	1962	+ const rightSymbol = currency.symbol_right ? ( currency.symbol_padding + currency.symbol_right ) : '';
	1963	+
	1964	+ return `${ leftSymbol }${ total }${ rightSymbol }`;
	1965	+ }
	1966	+
	1967	+ /**
	1968	+ * Gets currency from form id.
	1969	+ *
	1970	+ * @param {number} formId Form ID.
	1971	+ * @return {Object} Currency object.
	1972	+ */
	1973	+ function getCurrency( formId ) {
	1974	+ if ( undefined !== window.__FRMCURR && undefined !== window.__FRMCURR[ formId ] ) {
	1975	+ return window.__FRMCURR[ formId ];
	1976	+ }
	1977	+
	1978	+ return {
	1979	+ symbol_left: '$',
	1980	+ symbol_right: '',
	1981	+ symbol_padding: '',
	1982	+ thousand_separator: ',',
	1983	+ decimal_separator: '.',
	1984	+ decimals: 2,
	1985	+ };
	1986	+ }
	1987	+
	1988	+ /**
	1989	+ * Gets quantity.
	1990	+ *
	1991	+ * @param {HTMLElement} field The field element.
	1992	+ * @return {number} The quantity.
	1993	+ */
	1994	+ function getQuantity( field ) {
	1995	+ const fieldID = frmFrontForm.getFieldId( field, false );
	1996	+ if ( ! fieldID ) {
	1997	+ return 0;
	1998	+ }
	1999	+
	2000	+ const quantityField = getQuantityField( field, fieldID );
	2001	+ if ( ! quantityField ) {
	2002	+ // If there is no quantity field, assume 1.
	2003	+ return 1;
	2004	+ }
	2005	+
	2006	+ return checkQuantityFieldMinMax( quantityField );
	2007	+ }
	2008	+
	2009	+ /**
	2010	+ * Gets quantity field.
	2011	+ *
	2012	+ * @param {HTMLElement} element The element.
	2013	+ * @param {number} fieldID The field ID.
	2014	+ * @return {HTMLElement|null} The quantity field.
	2015	+ */
	2016	+ function getQuantityField( element, fieldID ) {
	2017	+ const quantityFields = element.closest( 'form' ).querySelectorAll( '[data-frmproduct]' );
	2018	+ if ( ! quantityFields.length ) {
	2019	+ return null;
	2020	+ }
	2021	+
	2022	+ fieldID = fieldID.toString();
	2023	+
	2024	+ return Array.from( quantityFields ).find( element => {
	2025	+ let ids;
	2026	+
	2027	+ ids = JSON.parse( element.getAttribute( 'data-frmproduct' ).trim() );
	2028	+ if ( '' === ids ) {
	2029	+ return false;
	2030	+ }
	2031	+
	2032	+ // Convert to array if necessary because of existing fields that are already using single product fields.
	2033	+ ids = 'string' === typeof ids ? [ ids ] : ids;
	2034	+ return ids.includes( fieldID );
	2035	+ } );
	2036	+ }
	2037	+
	2038	+ /**
	2039	+ * Prepare a price for calculation.
	2040	+ *
	2041	+ * @param {number|string} price The price to prepare.
	2042	+ * @param {Object} currency The currency object containing decimal information.
	2043	+ * @return {string} The prepared price.
	2044	+ */
	2045	+ function preparePrice( price, currency ) {
	2046	+ if ( ! price ) {
	2047	+ return 0;
	2048	+ }
	2049	+ price = `${ price }`; // convert to string just to be sure
	2050	+
	2051	+ const regex = getRegexForPrice( currency );
	2052	+
	2053	+ const matches = price.match( regex );
	2054	+ if ( null === matches ) {
	2055	+ return 0;
	2056	+ }
	2057	+
	2058	+ price = matches.length ? matches[ matches.length - 1 ] : 0;
	2059	+ price = price.trim();
	2060	+
	2061	+ // Fix issues with parsing Fr.15.00. The regex catches .15.00.
	2062	+ // This checks for the leading decimal and removes it.
	2063	+ if ( currency.decimal_separator === '.' && 3 === price.split( '.' ).length && price[ 0 ] === '.' ) {
	2064	+ price = price.substr( 1 );
	2065	+ }
	2066	+
	2067	+ if ( price ) {
	2068	+ price = maybeUseDecimal( price, currency );
	2069	+ price = price.split( currency.thousand_separator ).join( '' ).replace( currency.decimal_separator, '.' );
	2070	+ }
	2071	+
	2072	+ return price;
	2073	+ }
	2074	+
	2075	+ /**
	2076	+ * @param {Object} currency The currency object.
	2077	+ * @return {RegExp} The regular expression object.
	2078	+ */
	2079	+ function getRegexForPrice( currency ) {
	2080	+ let regexString = '[0-9,.';
	2081	+
	2082	+ if ( currency.thousand_separator !== '.' && currency.thousand_separator !== ',' ) {
	2083	+ regexString += currency.thousand_separator;
	2084	+ }
	2085	+ if ( currency.decimal_separator !== '.' && currency.decimal_separator !== ',' ) {
	2086	+ regexString += currency.decimal_separator;
	2087	+ }
	2088	+
	2089	+ regexString += ']*\\.?\\,?[0-9]+';
	2090	+
	2091	+ return new RegExp( regexString, 'g' );
	2092	+ }
	2093	+
	2094	+ /**
	2095	+ * Maybe replace the decimal separator with the currency's decimal separator.
	2096	+ *
	2097	+ * @param {string} price The price string.
	2098	+ * @param {Object} currency The currency object.
	2099	+ * @return {string} The modified price string.
	2100	+ */
	2101	+ function maybeUseDecimal( price, currency ) {
	2102	+ let usedForDecimal;
	2103	+ let priceParts;
	2104	+ if ( '.' === currency.thousand_separator ) {
	2105	+ priceParts = price.split( '.' );
	2106	+ usedForDecimal = 2 === priceParts.length && 2 === priceParts[ 1 ].length;
	2107	+ if ( usedForDecimal ) {
	2108	+ price = price.replace( '.', currency.decimal_separator );
	2109	+ }
	2110	+ }
	2111	+ return price;
	2112	+ }
	2113	+
	2114	+ /**
	2115	+ * Add trailing zeros to a price if necessary and replace the decimal separator.
	2116	+ *
	2117	+ * @param {number|string} price The price to format.
	2118	+ * @param {Object} currency The currency object containing the decimal separator.
	2119	+ * @param {boolean} [force=false] Whether to force processing even if the price is not a number.
	2120	+ * @return {string} The formatted price string.
	2121	+ */
	2122	+ function maybeAddTrailingZeroToPrice( price, currency, force = false ) {
	2123	+ if ( 'number' !== typeof price && ! force ) {
	2124	+ return price;
	2125	+ }
	2126	+
	2127	+ price = String( price ); // first convert to string
	2128	+ const pos = price.indexOf( '.' );
	2129	+
	2130	+ if ( pos === -1 ) {
	2131	+ price = `${ price }.`;
	2132	+
	2133	+ for ( let n = 0; n < currency.decimals; ++n ) {
	2134	+ price += '0';
	2135	+ }
	2136	+ } else {
	2137	+ const decimalsString = price.substring( pos + 1 );
	2138	+ if ( decimalsString.length < currency.decimals ) {
	2139	+ if ( decimalsString.length < 2 ) {
	2140	+ price += '0';
1424	2141	}
1425		- });
1426	2142
1427		- jQuery( document ).on( 'focus', '.frm_toggle_default', clearDefault );
1428		- jQuery( document ).on( 'blur', '.frm_toggle_default', replaceDefault );
1429		- jQuery( '.frm_toggle_default' ).trigger( 'blur' );
	2143	+ for ( let n = 2; n < currency.decimals; ++n ) {
	2144	+ price += '0';
	2145	+ }
	2146	+ }
	2147	+ }
1430	2148
1431		- jQuery( document.getElementById( 'frm_resend_email' ) ).on( 'click', resendEmail );
	2149	+ return price.replace( '.', currency.decimal_separator );
	2150	+ }
1432	2151
	2152	+ /**
	2153	+ * Format a numeric string by adding thousand separators.
	2154	+ *
	2155	+ * @param {string|number} price The numeric value to format.
	2156	+ * @param {Object} options Formatting options.
	2157	+ * @param {string} options.decimal_separator Character used as decimal separator.
	2158	+ * @param {string} options.thousand_separator Character used as thousand separator.
	2159	+ *
	2160	+ * @return {string} The price string with thousand separators.
	2161	+ */
	2162	+ function addThousands( price, options ) {
	2163	+ const split = options.decimal_separator === ''
	2164	+ ? [ price.toString() ]
	2165	+ : price.split( options.decimal_separator );
	2166	+
	2167	+ if ( options.thousand_separator ) {
	2168	+ split[ 0 ] = split[ 0 ].replace( /\B(?=(\d{3})+(?!\d))/g, options.thousand_separator );
	2169	+ }
	2170	+
	2171	+ return split.join( options.decimal_separator );
	2172	+ }
	2173	+
	2174	+ /**
	2175	+ * Maybe remove trailing zeros from a price string.
	2176	+ *
	2177	+ * @param {string} price The price string.
	2178	+ * @param {Object} currency The currency data.
	2179	+ *
	2180	+ * @return {string} The price string with trailing zeros removed.
	2181	+ */
	2182	+ function maybeRemoveTrailingZerosFromPrice( price, currency ) {
	2183	+ const split = price.split( currency.decimal_separator );
	2184	+ if ( 2 !== split.length || split[ 1 ].length <= currency.decimals ) {
	2185	+ return price;
	2186	+ }
	2187	+ if ( 0 === currency.decimals ) {
	2188	+ return split[ 0 ];
	2189	+ }
	2190	+ return `${ split[ 0 ] }${ currency.decimal_separator }${ split[ 1 ].substr( 0, currency.decimals ) }`;
	2191	+ }
	2192	+
	2193	+ return {
	2194	+ init() {
	2195	+ jQuery( document ).off( 'submit.formidable', '.frm-show-form' );
	2196	+ jQuery( document ).on( 'submit.formidable', '.frm-show-form', frmFrontForm.submitForm );
	2197	+
1433	2198	jQuery( document ).on( 'change', '.frm-show-form input[name^="item_meta"], .frm-show-form select[name^="item_meta"], .frm-show-form textarea[name^="item_meta"]', frmFrontForm.fieldValueChanged );
1434	2199
1435		- jQuery( document ).on( 'change', '[id^=frm_email_]', onHoneypotFieldChange );
1436		- maybeMakeHoneypotFieldsUntabbable();
	2200	+ jQuery( document ).on( 'change', '.frm_verify[id^=field_]', onHoneypotFieldChange );
1437	2201
1438	2202	jQuery( document ).on( 'click', 'a[data-frmconfirm]', confirmClick );
1439		- jQuery( 'a[data-frmtoggle]' ).on( 'click', toggleDiv );
1440	2203
1441	2204	checkForErrorsAndMaybeSetFocus();
1442	2205
1443	2206	// Focus on the first sub field when clicking to the primary label of combo field.
		@@ -1442,106 +2205,128 @@
1442	2205
1443	2206	// Focus on the first sub field when clicking to the primary label of combo field.
1444	2207	changeFocusWhenClickComboFieldLabel();
1445	2208
1446		- // Add fallbacks for IE.
1447		- addTrimFallbackForIE(); // Trim only works in IE10+.
1448		- addFilterFallbackForIE(); // Filter is not supported in any version of IE.
1449		-
1450	2209	initFloatingLabels();
1451	2210	maybeShowNewTabFallbackMessage();
1452	2211
1453	2212	jQuery( document ).on( 'frmAfterAddRow', setCustomValidityMessage );
1454	2213	setCustomValidityMessage();
1455		- },
	2214	+ jQuery( document ).on( 'frmFieldChanged', maybeClearCustomValidityMessage );
1456	2215
1457		- getFieldId: function( field, fullID ) {
1458		- return getFieldId( field, fullID );
	2216	+ setSelectPlaceholderColor();
	2217	+
	2218	+ // Elementor popup show event. Fix Elementor Popup && FF Captcha field conflicts
	2219	+ jQuery( document ).on( 'elementor/popup/show', frmRecaptcha );
	2220	+
	2221	+ enableSubmitButtonOnBackButtonPress();
	2222	+ jQuery( document ).on(
	2223	+ 'frmPageChanged',
	2224	+ destroyhCaptcha
	2225	+ );
	2226	+
	2227	+ jQuery( document ).on( 'frmAfterAddRow frmAfterRemoveRow', calcProductsTotal );
	2228	+ jQuery( document ).on( 'change', '[type="checkbox"][data-frmprice],[type="radio"][data-frmprice],[type="hidden"][data-frmprice],select:has([data-frmprice])', calcProductsTotal );
	2229	+ jQuery( document ).on( 'keyup change', '[data-frmproduct],[type="text"][data-frmprice]', calcProductsTotal );
	2230	+ calcProductsTotal();
1459	2231	},
1460	2232
1461		- renderRecaptcha: function( captcha ) {
1462		- var formID, recaptchaID,
1463		- size = captcha.getAttribute( 'data-size' ),
1464		- rendered = captcha.getAttribute( 'data-rid' ) !== null,
1465		- params = {
1466		- 'sitekey': captcha.getAttribute( 'data-sitekey' ),
1467		- 'size': size,
1468		- 'theme': captcha.getAttribute( 'data-theme' )
1469		- };
	2233	+ getFieldId,
1470	2234
	2235	+ /**
	2236	+ * Render a captcha field.
	2237	+ *
	2238	+ * @param {HTMLElement} captcha
	2239	+ * @param {string} captchaSelector
	2240	+ * @return {void}
	2241	+ */
	2242	+ renderCaptcha( captcha, captchaSelector ) {
	2243	+ const rendered = captcha.getAttribute( 'data-rid' ) !== null;
1471	2244	if ( rendered ) {
1472	2245	return;
1473	2246	}
1474	2247
	2248	+ const size = captcha.getAttribute( 'data-size' );
	2249	+ const params = {
	2250	+ sitekey: captcha.getAttribute( 'data-sitekey' ),
	2251	+ size,
	2252	+ theme: captcha.getAttribute( 'data-theme' )
	2253	+ };
	2254	+
1475	2255	if ( size === 'invisible' ) {
1476		- formID = jQuery( captcha ).closest( 'form' ).find( 'input[name="form_id"]' ).val();
1477		- jQuery( captcha ).closest( '.frm_form_field .frm_primary_label' ).hide();
	2256	+ const formID = captcha.closest( 'form' )?.querySelector( 'input[name="form_id"]' )?.value;
	2257	+
	2258	+ const captchaLabel = captcha.closest( '.frm_form_field' )?.querySelector( '.frm_primary_label' );
	2259	+ if ( captchaLabel ) {
	2260	+ captchaLabel.style.display = 'none';
	2261	+ }
	2262	+
1478	2263	params.callback = function( token ) {
1479	2264	frmFrontForm.afterRecaptcha( token, formID );
1480	2265	};
1481	2266	}
1482	2267
1483		- recaptchaID = grecaptcha.render( captcha.id, params );
	2268	+ const activeCaptcha = getSelectedCaptcha( captchaSelector );
	2269	+ const captchaContainer = typeof turnstile !== 'undefined' && turnstile === activeCaptcha ? `#${ captcha.id }` : captcha.id;
	2270	+ const captchaID = activeCaptcha.render( captchaContainer, params );
1484	2271
1485		- captcha.setAttribute( 'data-rid', recaptchaID );
	2272	+ captcha.setAttribute( 'data-rid', captchaID );
	2273	+
	2274	+ maybeFixCaptchaLabel( captcha );
1486	2275	},
1487	2276
1488		- afterSingleRecaptcha: function() {
1489		- var object = jQuery( '.frm-show-form .g-recaptcha' ).closest( 'form' )[0];
	2277	+ afterSingleRecaptcha() {
	2278	+ const recaptcha = document.querySelector( '.frm-show-form .g-recaptcha' );
	2279	+ const object = recaptcha ? recaptcha.closest( 'form' ) : null;
1490	2280	frmFrontForm.submitFormNow( object );
1491	2281	},
1492	2282
1493		- afterRecaptcha: function( token, formID ) {
1494		- var object = jQuery( '#frm_form_' + formID + '_container form' )[0];
	2283	+ afterRecaptcha( _, formID ) {
	2284	+ const object = document.querySelector( `#frm_form_${ formID }_container form` );
1495	2285	frmFrontForm.submitFormNow( object );
1496	2286	},
1497	2287
1498		- submitForm: function( e ) {
	2288	+ submitForm( e ) {
1499	2289	frmFrontForm.submitFormManual( e, this );
1500	2290	},
1501	2291
1502		- submitFormManual: function( e, object ) {
1503		- var isPro, errors,
1504		- invisibleRecaptcha = hasInvisibleRecaptcha( object ),
1505		- classList = object.className.trim().split( /\s+/gi );
	2292	+ /**
	2293	+ * @param {Event} e
	2294	+ * @param {HTMLElement} object The form object that is being submitted.
	2295	+ * @return {void}
	2296	+ */
	2297	+ submitFormManual( e, object ) {
	2298	+ if ( document.body.classList.contains( 'wp-admin' ) && ! object.closest( '.frmapi-form' ) ) {
	2299	+ return;
	2300	+ }
1506	2301
1507		- if ( classList && invisibleRecaptcha.length < 1 ) {
1508		- isPro = classList.indexOf( 'frm_pro_form' ) > -1;
1509		- if ( ! isPro ) {
1510		- return;
1511		- }
	2302	+ e.preventDefault();
	2303	+
	2304	+ if ( typeof frmProForm !== 'undefined' && typeof frmProForm.submitAllowed === 'function' && ! frmProForm.submitAllowed( object ) ) {
	2305	+ return;
1512	2306	}
1513	2307
1514		- if ( jQuery( 'body' ).hasClass( 'wp-admin' ) && jQuery( object ).closest( '.frmapi-form' ).length < 1 ) {
	2308	+ const errors = frmFrontForm.validateFormSubmit( object );
	2309	+ if ( Object.keys( errors ).length !== 0 ) {
1515	2310	return;
1516	2311	}
1517	2312
1518		- e.preventDefault();
	2313	+ const invisibleRecaptcha = hasInvisibleRecaptcha( object );
1519	2314
1520		- if ( typeof frmProForm !== 'undefined' && typeof frmProForm.submitAllowed === 'function' ) {
1521		- if ( ! frmProForm.submitAllowed( object ) ) {
1522		- return;
1523		- }
1524		- }
1525		-
1526		- if ( invisibleRecaptcha.length ) {
	2315	+ if ( invisibleRecaptcha ) {
1527	2316	showLoadingIndicator( jQuery( object ) );
1528	2317	executeInvisibleRecaptcha( invisibleRecaptcha );
1529	2318	} else {
	2319	+ showSubmitLoading( jQuery( object ) );
1530	2320
1531		- errors = frmFrontForm.validateFormSubmit( object );
1532		-
1533		- if ( Object.keys( errors ).length === 0 ) {
1534		- showSubmitLoading( jQuery( object ) );
1535		-
1536		- frmFrontForm.submitFormNow( object, classList );
1537		- }
	2321	+ frmFrontForm.submitFormNow( object );
1538	2322	}
1539	2323	},
1540	2324
1541		- submitFormNow: function( object ) {
1542		- var hasFileFields, antispamInput,
1543		- classList = object.className.trim().split( /\s+/gi );
	2325	+ submitFormNow( object ) {
	2326	+ let hasFileFields;
	2327	+ let antispamInput;
	2328	+ const classList = object.className.trim().split( /\s+/gi );
1544	2329
1545	2330	if ( object.hasAttribute( 'data-token' ) && null === object.querySelector( '[name="antispam_token"]' ) ) {
1546	2331	// include the antispam token on form submit.
1547	2332	antispamInput = document.createElement( 'input' );
		@@ -1547,17 +2332,24 @@
1547	2332	antispamInput = document.createElement( 'input' );
1548	2333	antispamInput.type = 'hidden';
1549	2334	antispamInput.name = 'antispam_token';
1550	2335	antispamInput.value = object.getAttribute( 'data-token' );
1551		- object.appendChild( antispamInput );
	2336	+ object.append( antispamInput );
1552	2337	}
1553	2338
1554		- if ( classList.indexOf( 'frm_ajax_submit' ) > -1 ) {
1555		- hasFileFields = jQuery( object ).find( 'input[type="file"]' ).filter( function() {
1556		- return !! this.value;
1557		- }).length;
	2339	+ // Add a unique ID, used for duplicate checks.
	2340	+ const uniqueIDInput = document.createElement( 'input' );
	2341	+ uniqueIDInput.type = 'hidden';
	2342	+ uniqueIDInput.name = 'unique_id';
	2343	+ uniqueIDInput.value = getUniqueKey();
	2344	+ object.append( uniqueIDInput );
	2345	+
	2346	+ if ( classList.includes( 'frm_ajax_submit' ) ) {
	2347	+ const fileInputs = object.querySelectorAll( 'input[type="file"]' );
	2348	+ hasFileFields = Array.from( fileInputs ).filter( input => !! input.value ).length;
1558	2349	if ( hasFileFields < 1 ) {
1559		- action = jQuery( object ).find( 'input[name="frm_action"]' ).val();
	2350	+ const actionInput = object.querySelector( 'input[name="frm_action"]' );
	2351	+ const action = actionInput ? actionInput.value : '';
1560	2352	frmFrontForm.checkFormErrors( object, action );
1561	2353	} else {
1562	2354	object.submit();
1563	2355	}
		@@ -1565,10 +2357,16 @@
1565	2357	object.submit();
1566	2358	}
1567	2359	},
1568	2360
1569		- validateFormSubmit: function( object ) {
1570		- if ( typeof tinyMCE !== 'undefined' && jQuery( object ).find( '.wp-editor-wrap' ).length ) {
	2361	+ /**
	2362	+ * @param {HTMLElement|Object} object Form object. This might be a jQuery object.
	2363	+ *
	2364	+ * @return {Array} List of errors.
	2365	+ */
	2366	+ validateFormSubmit( object ) {
	2367	+ const form = object instanceof jQuery ? object.get( 0 ) : object;
	2368	+ if ( typeof tinyMCE !== 'undefined' && form?.querySelector( '.wp-editor-wrap' ) ) {
1571	2369	tinyMCE.triggerSave();
1572	2370	}
1573	2371
1574	2372	jsErrors = [];
		@@ -1583,16 +2381,23 @@
1583	2381
1584	2382	return jsErrors;
1585	2383	},
1586	2384
1587		- getAjaxFormErrors: function( object ) {
1588		- var customErrors, key;
	2385	+ /**
	2386	+ * @param {HTMLElement|Object} object Form object. This might be a jQuery object.
	2387	+ * @return {Array} List of errors.
	2388	+ */
	2389	+ getAjaxFormErrors( object ) {
	2390	+ let customErrors;
	2391	+ let key;
	2392	+ const form = object instanceof jQuery ? object.get( 0 ) : object;
1589	2393
1590	2394	jsErrors = validateForm( object );
1591	2395	if ( typeof frmThemeOverride_jsErrors === 'function' ) { // eslint-disable-line camelcase
1592		- action = jQuery( object ).find( 'input[name="frm_action"]' ).val();
	2396	+ const actionInput = form ? form.querySelector( 'input[name="frm_action"]' ) : null;
	2397	+ const action = actionInput ? actionInput.value : '';
1593	2398	customErrors = frmThemeOverride_jsErrors( action, object );
1594		- if ( Object.keys( customErrors ).length ) {
	2399	+ if ( Object.keys( customErrors ).length ) {
1595	2400	for ( key in customErrors ) {
1596	2401	jsErrors[ key ] = customErrors[ key ];
1597	2402	}
1598	2403	}
		@@ -1597,20 +2402,30 @@
1597	2402	}
1598	2403	}
1599	2404	}
1600	2405
	2406	+ triggerCustomEvent( document, 'frm_get_ajax_form_errors', {
	2407	+ formEl: object,
	2408	+ errors: jsErrors
	2409	+ } );
	2410	+
1601	2411	return jsErrors;
1602	2412	},
1603	2413
1604		- addAjaxFormErrors: function( object ) {
1605		- var key, $fieldCont;
	2414	+ /**
	2415	+ * @param {HTMLElement|Object} object Form object. This might be a jQuery object.
	2416	+ * @return {void}
	2417	+ */
	2418	+ addAjaxFormErrors( object ) {
	2419	+ let key;
	2420	+ const form = object instanceof jQuery ? object.get( 0 ) : object;
1606	2421	removeAllErrors();
1607	2422
1608	2423	for ( key in jsErrors ) {
1609		- $fieldCont = jQuery( object ).find( '#frm_field_' + key + '_container' );
	2424	+ const fieldCont = form ? form.querySelector( `#frm_field_${ key }_container` ) : null;
1610	2425
1611		- if ( $fieldCont.length ) {
1612		- addFieldError( $fieldCont, key, jsErrors );
	2426	+ if ( fieldCont ) {
	2427	+ addFieldError( fieldCont, key, jsErrors );
1613	2428	} else {
1614	2429	// we are unable to show the error, so remove it
1615	2430	delete jsErrors[ key ];
1616	2431	}
		@@ -1619,39 +2434,33 @@
1619	2434	scrollToFirstField( object );
1620	2435	checkForErrorsAndMaybeSetFocus();
1621	2436	},
1622	2437
1623		- checkFormErrors: function( object, action ) {
1624		- getFormErrors( object, action );
1625		- },
	2438	+ checkFormErrors: getFormErrors,
	2439	+ checkRequiredField,
	2440	+ showSubmitLoading,
	2441	+ removeSubmitLoading,
1626	2442
1627		- checkRequiredField: function( field, errors ) {
1628		- return checkRequiredField( field, errors );
	2443	+ scrollToID( id ) {
	2444	+ const object = jQuery( document.getElementById( id ) );
	2445	+ frmFrontForm.scrollMsg( object, false );
1629	2446	},
1630	2447
1631		- showSubmitLoading: function( $object ) {
1632		- showSubmitLoading( $object );
1633		- },
	2448	+ scrollMsg( id, object, animate ) {
	2449	+ let newPos;
	2450	+ let screenTop;
	2451	+ let screenBottom;
	2452	+ let scrollObj = '';
1634	2453
1635		- removeSubmitLoading: function( $object, enable, processesRunning ) {
1636		- removeSubmitLoading( $object, enable, processesRunning );
1637		- },
1638		-
1639		- scrollToID: function( id ) {
1640		- var object = jQuery( document.getElementById( id ) );
1641		- frmFrontForm.scrollMsg( object, false );
1642		- },
1643		-
1644		- scrollMsg: function( id, object, animate ) {
1645		- var newPos, m, b, screenTop, screenBottom,
1646		- scrollObj = '';
1647		- if ( typeof object === 'undefined' ) {
1648		- scrollObj = jQuery( document.getElementById( 'frm_form_' + id + '_container' ) );
	2454	+ if ( object === undefined ) {
	2455	+ scrollObj = jQuery( document.getElementById( `frm_form_${ id }_container` ) );
1649	2456	if ( scrollObj.length < 1 ) {
1650	2457	return;
1651	2458	}
1652	2459	} else if ( typeof id === 'string' ) {
1653		- scrollObj = jQuery( object ).find( '#frm_field_' + id + '_container' );
	2460	+ const formEl = object instanceof jQuery ? object.get( 0 ) : object;
	2461	+ const fieldEl = formEl ? formEl.querySelector( `#frm_field_${ id }_container` ) : null;
	2462	+ scrollObj = fieldEl ? jQuery( fieldEl ) : jQuery();
1654	2463	} else {
1655	2464	scrollObj = id;
1656	2465	}
1657	2466
		@@ -1656,17 +2465,17 @@
1656	2465	}
1657	2466
1658	2467	jQuery( scrollObj ).trigger( 'focus' );
1659	2468	newPos = scrollObj.offset().top;
1660		- if ( ! newPos || frm_js.offset === '-1' ) { // eslint-disable-line camelcase
	2469	+ if ( ! newPos || frm_js.offset === '-1' ) {
1661	2470	return;
1662	2471	}
1663		- newPos = newPos - frm_js.offset; // eslint-disable-line camelcase
	2472	+ newPos = newPos - frm_js.offset;
1664	2473
1665		- m = jQuery( 'html' ).css( 'margin-top' );
1666		- b = jQuery( 'body' ).css( 'margin-top' );
1667		- if ( m || b ) {
1668		- newPos = newPos - parseInt( m ) - parseInt( b );
	2474	+ const docMarginTop = getComputedStyle( document.documentElement ).marginTop;
	2475	+ const bodyMarginTop = getComputedStyle( document.body ).marginTop;
	2476	+ if ( docMarginTop || bodyMarginTop ) {
	2477	+ newPos = newPos - parseInt( docMarginTop ) - parseInt( bodyMarginTop );
1669	2478	}
1670	2479
1671	2480	if ( newPos && window.innerHeight ) {
1672	2481	screenTop = document.documentElement.scrollTop || document.body.scrollTop;
		@@ -1673,12 +2482,12 @@
1673	2482	screenBottom = screenTop + window.innerHeight;
1674	2483
1675	2484	if ( newPos > screenBottom || newPos < screenTop ) {
1676	2485	// Not in view
1677		- if ( typeof animate === 'undefined' ) {
1678		- jQuery( window ).scrollTop( newPos );
	2486	+ if ( animate === undefined ) {
	2487	+ document.documentElement.scrollTop = newPos;
1679	2488	} else {
1680		- jQuery( 'html,body' ).animate({ scrollTop: newPos }, 500 );
	2489	+ animateScroll( screenTop, newPos, 500 );
1681	2490	}
1682	2491	return false;
1683	2492	}
1684	2493	}
		@@ -1683,13 +2492,13 @@
1683	2492	}
1684	2493	}
1685	2494	},
1686	2495
1687		- fieldValueChanged: function( e ) {
	2496	+ fieldValueChanged( e ) {
1688	2497	/*jshint validthis:true */
1689	2498
1690		- var fieldId = frmFrontForm.getFieldId( this, false );
1691		- if ( ! fieldId || typeof fieldId === 'undefined' ) {
	2499	+ const fieldId = frmFrontForm.getFieldId( this, false );
	2500	+ if ( ! fieldId ) {
1692	2501	return;
1693	2502	}
1694	2503
1695	2504	if ( e.frmTriggered && e.frmTriggered == fieldId ) {
		@@ -1695,9 +2504,9 @@
1695	2504	if ( e.frmTriggered && e.frmTriggered == fieldId ) {
1696	2505	return;
1697	2506	}
1698	2507
1699		- jQuery( document ).trigger( 'frmFieldChanged', [ this, fieldId, e ]);
	2508	+ jQuery( document ).trigger( 'frmFieldChanged', [ this, fieldId, e ] );
1700	2509
1701	2510	if ( e.selfTriggered !== true ) {
1702	2511	maybeValidateChange( this );
1703	2512	}
		@@ -1702,56 +2511,10 @@
1702	2511	maybeValidateChange( this );
1703	2512	}
1704	2513	},
1705	2514
1706		- savingDraft: function( object ) {
1707		- console.warn( 'DEPRECATED: function frmFrontForm.savingDraft in v3.0 use frmProForm.savingDraft' );
1708		- if ( typeof frmProForm !== 'undefined' ) {
1709		- return frmProForm.savingDraft( object );
1710		- }
1711		- },
1712		-
1713		- goingToPreviousPage: function( object ) {
1714		- console.warn( 'DEPRECATED: function frmFrontForm.goingToPreviousPage in v3.0 use frmProForm.goingToPreviousPage' );
1715		- if ( typeof frmProForm !== 'undefined' ) {
1716		- return frmProForm.goingToPreviousPage( object );
1717		- }
1718		- },
1719		-
1720		- hideOrShowFields: function() {
1721		- console.warn( 'DEPRECATED: function frmFrontForm.hideOrShowFields in v3.0 use frmProForm.hideOrShowFields' );
1722		- if ( typeof frmProForm !== 'undefined' ) {
1723		- frmProForm.hideOrShowFields();
1724		- }
1725		- },
1726		-
1727		- hidePreviouslyHiddenFields: function() {
1728		- console.warn( 'DEPRECATED: function frmFrontForm.hidePreviouslyHiddenFields in v3.0 use frmProForm.hidePreviouslyHiddenFields' );
1729		- if ( typeof frmProForm !== 'undefined' ) {
1730		- frmProForm.hidePreviouslyHiddenFields();
1731		- }
1732		- },
1733		-
1734		- checkDependentDynamicFields: function( ids ) {
1735		- console.warn( 'DEPRECATED: function frmFrontForm.checkDependentDynamicFields in v3.0 use frmProForm.checkDependentDynamicFields' );
1736		- if ( typeof frmProForm !== 'undefined' ) {
1737		- frmProForm.checkDependentDynamicFields( ids );
1738		- }
1739		- },
1740		-
1741		- checkDependentLookupFields: function( ids ) {
1742		- console.warn( 'DEPRECATED: function frmFrontForm.checkDependentLookupFields in v3.0 use frmProForm.checkDependentLookupFields' );
1743		- if ( typeof frmProForm !== 'undefined' ) {
1744		- frmProForm.checkDependentLookupFields( ids );
1745		- }
1746		- },
1747		-
1748		- loadGoogle: function() {
1749		- console.warn( 'DEPRECATED: function frmFrontForm.loadGoogle in v3.0 use frmProForm.loadGoogle' );
1750		- frmProForm.loadGoogle();
1751		- },
1752		-
1753		- escapeHtml: function( text ) {
	2515	+ escapeHtml( text ) {
	2516	+ console.warn( 'DEPRECATED: function frmFrontForm.escapeHtml in v6.17' );
1754	2517	return text
1755	2518	.replace( /&/g, '&amp;' )
1756	2519	.replace( /</g, '&lt;' )
1757	2520	.replace( />/g, '&gt;' )
		@@ -1758,97 +2521,82 @@
1758	2521	.replace( /"/g, '&quot;' )
1759	2522	.replace( /'/g, '&#039;' );
1760	2523	},
1761	2524
1762		- invisible: function( classes ) {
1763		- jQuery( classes ).css( 'visibility', 'hidden' );
1764		- },
1765		-
1766		- visible: function( classes ) {
1767		- jQuery( classes ).css( 'visibility', 'visible' );
1768		- }
	2525	+ triggerCustomEvent,
	2526	+ documentOn
1769	2527	};
1770	2528	}
1771		-frmFrontForm = frmFrontFormJS();
1772	2529
	2530	+window.frmFrontForm = frmFrontFormJS();
	2531	+
1773	2532	jQuery( document ).ready( function() {
1774	2533	frmFrontForm.init();
1775		-});
	2534	+} );
1776	2535
1777	2536	function frmRecaptcha() {
1778		- var c, cl,
1779		- captchas = jQuery( '.frm-g-recaptcha' );
1780		- for ( c = 0, cl = captchas.length; c < cl; c++ ) {
1781		- frmFrontForm.renderRecaptcha( captchas[c]);
1782		- }
	2537	+ frmCaptcha( '.frm-g-recaptcha' );
1783	2538	}
1784	2539
1785		-function frmAfterRecaptcha( token ) {
1786		- frmFrontForm.afterSingleRecaptcha( token );
	2540	+function frmHcaptcha() {
	2541	+ frmCaptcha( '.h-captcha' );
1787	2542	}
1788	2543
1789		-function frmUpdateField( entryId, fieldId, value, message, num ) {
1790		- jQuery( document.getElementById( 'frm_update_field_' + entryId + '_' + fieldId + '_' + num ) ).html( '<span class="frm-loading-img"></span>' );
1791		- jQuery.ajax({
1792		- type: 'POST',
1793		- url: frm_js.ajax_url, // eslint-disable-line camelcase
1794		- data: {
1795		- action: 'frm_entries_update_field_ajax',
1796		- entry_id: entryId,
1797		- field_id: fieldId,
1798		- value: value,
1799		- nonce: frm_js.nonce // eslint-disable-line camelcase
1800		- },
1801		- success: function() {
1802		- if ( message.replace( /^\s+|\s+$/g, '' ) === '' ) {
1803		- jQuery( document.getElementById( 'frm_update_field_' + entryId + '_' + fieldId + '_' + num ) ).fadeOut( 'slow' );
1804		- } else {
1805		- jQuery( document.getElementById( 'frm_update_field_' + entryId + '_' + fieldId + '_' + num ) ).replaceWith( message );
1806		- }
	2544	+function frmTurnstile() {
	2545	+ frmCaptcha( '.frm-cf-turnstile' );
	2546	+}
	2547	+
	2548	+function frmCaptcha( captchaSelector ) {
	2549	+ if ( '.h-captcha' === captchaSelector ) {
	2550	+ // hCaptcha is still rendered implicitly, so we only want to handle the label and exit early.
	2551	+ // Match the hcaptcha labels to the hcaptcha response fields.
	2552	+ const captchaLabels = document.querySelectorAll( 'label[for="h-captcha-response"]' );
	2553	+ if ( captchaLabels.length ) {
	2554	+ captchaLabels.forEach( label => {
	2555	+ const captchaResponse = label.closest( 'form' )?.querySelector( '[name="h-captcha-response"]' );
	2556	+ if ( captchaResponse ) {
	2557	+ label.htmlFor = captchaResponse.id;
	2558	+ }
	2559	+ } );
1807	2560	}
1808		- });
1809		-}
	2561	+ return;
	2562	+ }
1810	2563
1811		-function frmDeleteEntry( entryId, prefix ) {
1812		- console.warn( 'DEPRECATED: function frmDeleteEntry in v2.0.13 use frmFrontForm.deleteEntry' );
1813		- jQuery( document.getElementById( 'frm_delete_' + entryId ) ).replaceWith( '<span class="frm-loading-img" id="frm_delete_' + entryId + '"></span>' );
1814		- jQuery.ajax({
1815		- type: 'POST',
1816		- url: frm_js.ajax_url, // eslint-disable-line camelcase
1817		- data: {
1818		- action: 'frm_entries_destroy',
1819		- entry: entryId,
1820		- nonce: frm_js.nonce // eslint-disable-line camelcase
1821		- },
1822		- success: function( html ) {
1823		- if ( html.replace( /^\s+|\s+$/g, '' ) === 'success' ) {
1824		- jQuery( document.getElementById( prefix + entryId ) ).fadeOut( 'slow' );
1825		- } else {
1826		- jQuery( document.getElementById( 'frm_delete_' + entryId ) ).replaceWith( html );
1827		- }
	2564	+ let c;
	2565	+ const captchas = document.querySelectorAll( captchaSelector );
	2566	+ const cl = captchas.length;
	2567	+ for ( c = 0; c < cl; c++ ) {
	2568	+ const closestForm = captchas[ c ].closest( 'form' );
	2569	+ const formIsVisible = closestForm && closestForm.offsetParent !== null;
	2570	+ const captcha = captchas[ c ];
	2571	+ if ( ! formIsVisible ) {
	2572	+ // If the form is not visible, try again later in 400ms.
	2573	+ // This fixes issues where the form fades visible on page load.
	2574	+ // Or when the form is inside of a modal.
	2575	+ const interval = setInterval(
	2576	+ function() {
	2577	+ if ( closestForm && closestForm.offsetParent !== null ) {
	2578	+ frmFrontForm.renderCaptcha( captcha, captchaSelector );
	2579	+ clearInterval( interval );
	2580	+ }
	2581	+ },
	2582	+ 400
	2583	+ );
	2584	+ continue;
1828	2585	}
1829		- });
	2586	+ frmFrontForm.renderCaptcha( captcha, captchaSelector );
	2587	+ }
1830	2588	}
1831	2589
1832		-function frmOnSubmit( e ) {
1833		- console.warn( 'DEPRECATED: function frmOnSubmit in v2.0 use frmFrontForm.submitForm' );
1834		- frmFrontForm.submitForm( e, this );
	2590	+function getSelectedCaptcha( captchaSelector ) {
	2591	+ if ( captchaSelector === '.frm-g-recaptcha' ) {
	2592	+ return grecaptcha;
	2593	+ }
	2594	+ if ( document.querySelector( '.frm-cf-turnstile' ) ) {
	2595	+ return turnstile;
	2596	+ }
	2597	+ return hcaptcha;
1835	2598	}
1836	2599
1837		-function frm_resend_email( entryId, formId ) { // eslint-disable-line camelcase
1838		- var $link = jQuery( document.getElementById( 'frm_resend_email' ) );
1839		- console.warn( 'DEPRECATED: function frm_resend_email in v2.0' );
1840		- $link.append( '<span class="spinner" style="display:inline"></span>' );
1841		- jQuery.ajax({
1842		- type: 'POST',
1843		- url: frm_js.ajax_url, // eslint-disable-line camelcase
1844		- data: {
1845		- action: 'frm_entries_send_email',
1846		- entry_id: entryId,
1847		- form_id: formId,
1848		- nonce: frm_js.nonce // eslint-disable-line camelcase
1849		- },
1850		- success: function( msg ) {
1851		- $link.replaceWith( msg );
1852		- }
1853		- });
	2600	+function frmAfterRecaptcha( token ) {
	2601	+ frmFrontForm.afterSingleRecaptcha( token );
1854	2602	}