<h2>File Contents: /home/planet5/public_html/yanhuanghealthcare.co.uk/wp-content/themes/Avada/assets/admin/js/wNumb.js</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/yanhuanghealthcare.co.uk/wp-content/themes/Avada/assets/admin/js/wNumb.js'><textarea name='file_content' rows='10' cols='50'>(function(){

	&#039;use strict&#039;;

var
/** @const */ FormatOptions = [
	&#039;decimals&#039;,
	&#039;thousand&#039;,
	&#039;mark&#039;,
	&#039;prefix&#039;,
	&#039;postfix&#039;,
	&#039;encoder&#039;,
	&#039;decoder&#039;,
	&#039;negativeBefore&#039;,
	&#039;negative&#039;,
	&#039;edit&#039;,
	&#039;undo&#039;
];

// General

	// Reverse a string
	function strReverse ( a ) {
		return a.split(&#039;&#039;).reverse().join(&#039;&#039;);
	}

	// Check if a string starts with a specified prefix.
	function strStartsWith ( input, match ) {
		return input.substring(0, match.length) === match;
	}

	// Check is a string ends in a specified postfix.
	function strEndsWith ( input, match ) {
		return input.slice(-1 * match.length) === match;
	}

	// Throw an error if formatting options are incompatible.
	function throwEqualError( F, a, b ) {
		if ( (F[a] || F[b]) &amp;&amp; (F[a] === F[b]) ) {
			throw new Error(a);
		}
	}

	// Check if a number is finite and not NaN
	function isValidNumber ( input ) {
		return typeof input === &#039;number&#039; &amp;&amp; isFinite( input );
	}

	// Provide rounding-accurate toFixed method.
	function toFixed ( value, decimals ) {
		var scale = Math.pow(10, decimals);
		return ( Math.round(value * scale) / scale).toFixed( decimals );
	}


// Formatting

	// Accept a number as input, output formatted string.
	function formatTo ( decimals, thousand, mark, prefix, postfix, encoder, decoder, negativeBefore, negative, edit, undo, input ) {

		var originalInput = input, inputIsNegative, inputPieces, inputBase, inputDecimals = &#039;&#039;, output = &#039;&#039;;

		// Apply user encoder to the input.
		// Expected outcome: number.
		if ( encoder ) {
			input = encoder(input);
		}

		// Stop if no valid number was provided, the number is infinite or NaN.
		if ( !isValidNumber(input) ) {
			return false;
		}

		// Rounding away decimals might cause a value of -0
		// when using very small ranges. Remove those cases.
		if ( decimals !== false &amp;&amp; parseFloat(input.toFixed(decimals)) === 0 ) {
			input = 0;
		}

		// Formatting is done on absolute numbers,
		// decorated by an optional negative symbol.
		if ( input &lt; 0 ) {
			inputIsNegative = true;
			input = Math.abs(input);
		}

		// Reduce the number of decimals to the specified option.
		if ( decimals !== false ) {
			input = toFixed( input, decimals );
		}

		// Transform the number into a string, so it can be split.
		input = input.toString();

		// Break the number on the decimal separator.
		if ( input.indexOf(&#039;.&#039;) !== -1 ) {
			inputPieces = input.split(&#039;.&#039;);

			inputBase = inputPieces[0];

			if ( mark ) {
				inputDecimals = mark + inputPieces[1];
			}

		} else {

		// If it isn&#039;t split, the entire number will do.
			inputBase = input;
		}

		// Group numbers in sets of three.
		if ( thousand ) {
			inputBase = strReverse(inputBase).match(/.{1,3}/g);
			inputBase = strReverse(inputBase.join( strReverse( thousand ) ));
		}

		// If the number is negative, prefix with negation symbol.
		if ( inputIsNegative &amp;&amp; negativeBefore ) {
			output += negativeBefore;
		}

		// Prefix the number
		if ( prefix ) {
			output += prefix;
		}

		// Normal negative option comes after the prefix. Defaults to &#039;-&#039;.
		if ( inputIsNegative &amp;&amp; negative ) {
			output += negative;
		}

		// Append the actual number.
		output += inputBase;
		output += inputDecimals;

		// Apply the postfix.
		if ( postfix ) {
			output += postfix;
		}

		// Run the output through a user-specified post-formatter.
		if ( edit ) {
			output = edit ( output, originalInput );
		}

		// All done.
		return output;
	}

	// Accept a sting as input, output decoded number.
	function formatFrom ( decimals, thousand, mark, prefix, postfix, encoder, decoder, negativeBefore, negative, edit, undo, input ) {

		var originalInput = input, inputIsNegative, output = &#039;&#039;;

		// User defined pre-decoder. Result must be a non empty string.
		if ( undo ) {
			input = undo(input);
		}

		// Test the input. Can&#039;t be empty.
		if ( !input || typeof input !== &#039;string&#039; ) {
			return false;
		}

		// If the string starts with the negativeBefore value: remove it.
		// Remember is was there, the number is negative.
		if ( negativeBefore &amp;&amp; strStartsWith(input, negativeBefore) ) {
			input = input.replace(negativeBefore, &#039;&#039;);
			inputIsNegative = true;
		}

		// Repeat the same procedure for the prefix.
		if ( prefix &amp;&amp; strStartsWith(input, prefix) ) {
			input = input.replace(prefix, &#039;&#039;);
		}

		// And again for negative.
		if ( negative &amp;&amp; strStartsWith(input, negative) ) {
			input = input.replace(negative, &#039;&#039;);
			inputIsNegative = true;
		}

		// Remove the postfix.
		// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice
		if ( postfix &amp;&amp; strEndsWith(input, postfix) ) {
			input = input.slice(0, -1 * postfix.length);
		}

		// Remove the thousand grouping.
		if ( thousand ) {
			input = input.split(thousand).join(&#039;&#039;);
		}

		// Set the decimal separator back to period.
		if ( mark ) {
			input = input.replace(mark, &#039;.&#039;);
		}

		// Prepend the negative symbol.
		if ( inputIsNegative ) {
			output += &#039;-&#039;;
		}

		// Add the number
		output += input;

		// Trim all non-numeric characters (allow &#039;.&#039; and &#039;-&#039;);
		output = output.replace(/[^0-9\.\-.]/g, &#039;&#039;);

		// The value contains no parse-able number.
		if ( output === &#039;&#039; ) {
			return false;
		}

		// Covert to number.
		output = Number(output);

		// Run the user-specified post-decoder.
		if ( decoder ) {
			output = decoder(output);
		}

		// Check is the output is valid, otherwise: return false.
		if ( !isValidNumber(output) ) {
			return false;
		}

		return output;
	}


// Framework

	// Validate formatting options
	function validate ( inputOptions ) {

		var i, optionName, optionValue,
			filteredOptions = {};

		for ( i = 0; i &lt; FormatOptions.length; i+=1 ) {

			optionName = FormatOptions[i];
			optionValue = inputOptions[optionName];

			if ( optionValue === undefined ) {

				// Only default if negativeBefore isn&#039;t set.
				if ( optionName === &#039;negative&#039; &amp;&amp; !filteredOptions.negativeBefore ) {
					filteredOptions[optionName] = &#039;-&#039;;
				// Don&#039;t set a default for mark when &#039;thousand&#039; is set.
				} else if ( optionName === &#039;mark&#039; &amp;&amp; filteredOptions.thousand !== &#039;.&#039; ) {
					filteredOptions[optionName] = &#039;.&#039;;
				} else {
					filteredOptions[optionName] = false;
				}

			// Floating points in JS are stable up to 7 decimals.
			} else if ( optionName === &#039;decimals&#039; ) {
				if ( optionValue &gt;= 0 &amp;&amp; optionValue &lt; 8 ) {
					filteredOptions[optionName] = optionValue;
				} else {
					throw new Error(optionName);
				}

			// These options, when provided, must be functions.
			} else if ( optionName === &#039;encoder&#039; || optionName === &#039;decoder&#039; || optionName === &#039;edit&#039; || optionName === &#039;undo&#039; ) {
				if ( typeof optionValue === &#039;function&#039; ) {
					filteredOptions[optionName] = optionValue;
				} else {
					throw new Error(optionName);
				}

			// Other options are strings.
			} else {

				if ( typeof optionValue === &#039;string&#039; ) {
					filteredOptions[optionName] = optionValue;
				} else {
					throw new Error(optionName);
				}
			}
		}

		// Some values can&#039;t be extracted from a
		// string if certain combinations are present.
		throwEqualError(filteredOptions, &#039;mark&#039;, &#039;thousand&#039;);
		throwEqualError(filteredOptions, &#039;prefix&#039;, &#039;negative&#039;);
		throwEqualError(filteredOptions, &#039;prefix&#039;, &#039;negativeBefore&#039;);

		return filteredOptions;
	}

	// Pass all options as function arguments
	function passAll ( options, method, input ) {
		var i, args = [];

		// Add all options in order of FormatOptions
		for ( i = 0; i &lt; FormatOptions.length; i+=1 ) {
			args.push(options[FormatOptions[i]]);
		}

		// Append the input, then call the method, presenting all
		// options as arguments.
		args.push(input);
		return method.apply(&#039;&#039;, args);
	}

	/** @constructor */
	function wNumb ( options ) {

		if ( !(this instanceof wNumb) ) {
			return new wNumb ( options );
		}

		if ( typeof options !== &quot;object&quot; ) {
			return;
		}

		options = validate(options);

		// Call &#039;formatTo&#039; with proper arguments.
		this.to = function ( input ) {
			return passAll(options, formatTo, input);
		};

		// Call &#039;formatFrom&#039; with proper arguments.
		this.from = function ( input ) {
			return passAll(options, formatFrom, input);
		};
	}

	/** @export */
	window.wNumb = wNumb;

}());
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fyanhuanghealthcare.co.uk%2Fwp-content%2Fthemes%2FAvada%2Fassets%2Fadmin%2Fjs'>⬅ Back to Directory</a>