<h2>File Contents: /home/planet5/.trash/9monarch/core/components/data/Utils.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/.trash/9monarch/core/components/data/Utils.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

/**
 * Utility class for manipulating various data formats. Includes methods for
 * transforming array data to another format based on key mapping, methods for
 * generating XML-RPC method call strings, methods for working with arrays, and more.
 *
 * @since   3.0.62
 *
 * @package ET\Core\Data
 */
class ET_Core_Data_Utils {

	private static $_instance;

	private $_pick;
	private $_pick_value = &#039;_undefined_&#039;;
	private $_sort_by;

	/**
	 * Sort arguments being passed through to callbacks.
	 * See self::_user_sort()
	 *
	 * @var array
	 */
	protected $sort_arguments = array(
		&#039;array&#039;      =&gt; array(),
		&#039;array_map&#039;  =&gt; array(),
		&#039;sort&#039;       =&gt; &#039;__return_false&#039;,
		&#039;comparison&#039; =&gt; &#039;__return_false&#039;,
	);

	/**
	 * Generate an XML-RPC array.
	 *
	 * @param array $values
	 *
	 * @return string
	 */
	private function _create_xmlrpc_array( $values ) {
		$output = &#039;&#039;;

		foreach ( $values as $value ) {
			$output .= $this-&gt;_create_xmlrpc_value( $value );
		}

		return &quot;&lt;array&gt;&lt;data&gt;{$output}&lt;/data&gt;&lt;/array&gt;&quot;;
	}

	/**
	 * Generate an XML-RPC struct.
	 *
	 * @param array $members
	 *
	 * @return string
	 */
	private function _create_xmlrpc_struct( $members ) {
		$output = &#039;&#039;;

		foreach ( $members as $name =&gt; $value ) {
			$output .= sprintf( &#039;&lt;member&gt;&lt;name&gt;%1$s&lt;/name&gt;%2$s&lt;/member&gt;&#039;, esc_html( $name ), $this-&gt;_create_xmlrpc_value( $value ) );
		}

		return &quot;&lt;struct&gt;{$output}&lt;/struct&gt;&quot;;
	}

	/**
	 * Generate an XML-RPC value.
	 *
	 * @param mixed $value
	 *
	 * @return string
	 */
	private function _create_xmlrpc_value( $value ) {
		$output = &#039;&#039;;

		if ( is_string( $value ) ) {
			$value = esc_html( wp_strip_all_tags( $value ) );
			$output = &quot;&lt;string&gt;{$value}&lt;/string&gt;&quot;;
		} else if ( is_bool( $value ) ) {
			$value  = (int) $value;
			$output = &quot;&lt;boolean&gt;{$value}&lt;/boolean&gt;&quot;;
		} else if ( is_int( $value ) ) {
			$output = &quot;&lt;int&gt;{$value}&lt;/int&gt;&quot;;
		} else if ( is_array( $value ) &amp;&amp; $this-&gt;is_assoc_array( $value ) ) {
			$output = $this-&gt;_create_xmlrpc_struct( $value );
		} else if ( is_array( $value ) ) {
			$output = $this-&gt;_create_xmlrpc_array( $value );
		}

		return &quot;&lt;value&gt;{$output}&lt;/value&gt;&quot;;
	}

	/**
	 * Convert a SimpleXMLElement to a native PHP data type.
	 *
	 * @param SimpleXMLElement $value
	 *
	 * @return mixed
	 */
	private function _parse_value( $value ) {
		switch ( true ) {
			case is_string( $value ):
				$result = $value;
				break;
			case count( $value-&gt;struct ) &gt; 0:
				$result = new stdClass();

				foreach ( $value-&gt;struct-&gt;member as $member ) {
					$name          = (string) $member-&gt;name;
					$member_value  = $this-&gt;_parse_value( $member-&gt;value );
					$result-&gt;$name = $member_value;
				}

				break;
			case count( $value-&gt;array ) &gt; 0:
				$result = array();

				foreach ( $value-&gt;array-&gt;data-&gt;value as $array_value ) {
					$result[] = $this-&gt;_parse_value( $array_value );
				}

				break;
			case count( $value-&gt;i4 ) &gt; 0:
				$result = (int) $value-&gt;i4;
				break;
			case count( $value-&gt;int ) &gt; 0:
				$result = (int) $value-&gt;int;
				break;
			case count( $value-&gt;boolean ) &gt; 0:
				$result = (boolean) $value-&gt;boolean;
				break;
			case count( $value-&gt;double ) &gt; 0:
				$result = (double) $value-&gt;double;
				break;
			default:
				$result = (string) $value;
		}

		return $result;
	}

	private function _remove_empty_directories( $path ) {
		if ( ! is_dir( $path ) ) {
			return false;
		}

		$empty              = true;
		$directory_contents = glob( untrailingslashit( $path ) . &#039;/*&#039; );

		foreach ( (array) $directory_contents as $item ) {
			if ( ! $this-&gt;_remove_empty_directories( $item ) ) {
				$empty = false;
			}
		}

		return $empty ? @rmdir( $path ) : false;
	}

	public function _array_pick_callback( $item ) {
		$pick  = $this-&gt;_pick;
		$value = $this-&gt;_pick_value;

		if ( is_array( $item ) &amp;&amp; isset( $item[ $pick ] ) ) {
			return &#039;_undefined_&#039; !== $value ? $value === $item[ $pick ] : $item[ $pick ];
		} else if ( is_object( $item ) &amp;&amp; isset( $item-&gt;$pick ) ) {
			return &#039;_undefined_&#039; !== $value ? $value === $item-&gt;$pick : $item-&gt;$pick;
		}

		return false;
	}

	public function _array_sort_by_callback( $a, $b ) {
		$sort_by = $this-&gt;_sort_by;

		if ( is_array( $a ) ) {
			return strcmp( $a[ $sort_by ], $b[ $sort_by ] );
		} else if ( is_object( $a ) ) {
			return strcmp( $a-&gt;$sort_by, $b-&gt;$sort_by );
		}

		return 0;
	}

	/**
	 * Returns `true` if all values in `$array` are not empty, `false` otherwise.
	 * If `$condition` is provided then values are checked against it instead of `empty()`.
	 *
	 * @param array $array
	 * @param bool  $condition Compare values to this instead of `empty()`. Optional.
	 *
	 * @return bool
	 */
	public function all( array $array, $condition = null ) {
		if ( null === $condition ) {
			foreach( $array as $key =&gt; $value ) {
				if ( empty( $value ) ) {
					return false;
				}
			}
		} else {
			foreach( $array as $key =&gt; $value ) {
				if ( $value !== $condition ) {
					return false;
				}
			}
		}

		return true;
	}

	/**
	 * Flattens a multi-dimensional array.
	 *
	 * @since 3.0.99
	 *
	 * @param array $array An array to flatten.
	 *
	 * @return array
	 */
	function array_flatten( array $array ) {
		$iterator = new RecursiveIteratorIterator( new RecursiveArrayIterator( $array ) );
		$use_keys = true;

		return iterator_to_array( $iterator, $use_keys );
	}

	/**
	 * Gets a value from a nested array using an address string.
	 *
	 * @param array  $array   An array which contains value located at `$address`.
	 * @param string|array $address The location of the value within `$array` (dot notation).
	 * @param mixed  $default Value to return if not found. Default is an empty string.
	 *
	 * @return mixed The value, if found, otherwise $default.
	 */
	public function array_get( $array, $address, $default = &#039;&#039; ) {
		$keys   = is_array( $address ) ? $address : explode( &#039;.&#039;, $address );
		$value  = $array;

		foreach ( $keys as $key ) {
			if ( ! empty( $key ) &amp;&amp; isset( $key[0] ) &amp;&amp; &#039;[&#039; === $key[0] ) {
				$index = substr( $key, 1, -1 );

				if ( is_numeric( $index ) ) {
					$key = (int) $index;
				}
			}

			if ( ! isset( $value[ $key ] ) ) {
				return $default;
			}

			$value = $value[ $key ];
		}

		return $value;
	}

	/**
	 * Wrapper for {@see self::array_get()} that sanitizes the value before returning it.
	 *
	 * @since 4.0.7
	 *
	 * @param array  $array     An array which contains value located at `$address`.
	 * @param string $address   The location of the value within `$array` (dot notation).
	 * @param mixed  $default   Value to return if not found. Default is an empty string.
	 * @param string $sanitizer Sanitize function to use. Default is &#039;sanitize_text_field&#039;.
	 *
	 * @return mixed The sanitized value if found, otherwise $default.
	 */
	public function array_get_sanitized( $array, $address, $default = &#039;&#039;, $sanitizer = &#039;sanitize_text_field&#039; ) {
		if ( $value = $this-&gt;array_get( $array, $address, $default ) ) {
			$value = $sanitizer( $value );
		}

		return $value;
	}

	/**
	 * Creates a new array containing only the items that have a key or property or only the items that
	 * have a key or property that is equal to a certain value.
	 *
	 * @param array        $array   The array to pick from.
	 * @param string|array $pick_by The key or property to look for or an array mapping the key or property
	 *                              to a value to look for.
	 *
	 * @return array
	 */
	public function array_pick( $array, $pick_by ) {
		if ( is_string( $pick_by ) || is_int( $pick_by ) ) {
			$this-&gt;_pick = $pick_by;
		} else if ( is_array( $pick_by ) &amp;&amp; 1 === count( $pick_by ) ) {
			$this-&gt;_pick       = key( $pick_by );
			$this-&gt;_pick_value = array_pop( $pick_by );
		} else {
			return array();
		}

		return array_filter( $array, array( $this, &#039;_array_pick_callback&#039; ) );
	}

	/**
	 * Sets a value in a nested array using an address string (dot notation)
	 *
	 * @see http://stackoverflow.com/a/9628276/419887
	 *
	 * @param array        $array The array to modify
	 * @param string|array $path  The path in the array
	 * @param mixed        $value The value to set
	 */
	public function array_set( &amp;$array, $path, $value ) {
		$path_parts = is_array( $path ) ? $path : explode( &#039;.&#039;, $path );
		$current    = &amp;$array;

		foreach ( $path_parts as $key ) {
			if ( ! is_array( $current ) ) {
				$current = array();
			}

			if ( &#039;[&#039; === $key[0] &amp;&amp; is_numeric( substr( $key, 1, - 1 ) ) ) {
				$key = (int) $key;
			}

			$current = &amp;$current[ $key ];
		}

		$current = $value;
	}

	public function array_sort_by( $array, $key_or_prop ) {
		if ( ! is_string( $key_or_prop ) &amp;&amp; ! is_int( $key_or_prop ) ) {
			return $array;
		}

		$this-&gt;_sort_by = $key_or_prop;

		if ( $this-&gt;is_assoc_array( $array ) ) {
			uasort( $array, array( $this, &#039;_array_sort_by_callback&#039; ) );
		} else {
			usort( $array, array( $this, &#039;_array_sort_by_callback&#039; ) );
		}

		return $array;
	}

	/**
	 * Update a nested array value found at the provided path using {@see array_merge()}.
	 *
	 * @since 4.0.7
	 *
	 * @param array $array
	 * @param $path
	 * @param $value
	 */
	public function array_update( &amp;$array, $path, $value ) {
		$current_value = $this-&gt;array_get( $array, $path, array() );

		$this-&gt;array_set( $array, $path, array_merge( $current_value, $value ) );
	}

	/**
	 * Whether or not a string ends with a substring.
	 *
	 * @since 4.5.3
	 *
	 * @param string $haystack The string to look in.
	 * @param string $needle   The string to look for.
	 *
	 * @return bool
	 */
	public function ends_with( $haystack, $needle ) {
		$length = strlen( $needle );

		if ( 0 === $length ) {
			return true;
		}

		return ( substr( $haystack, -$length ) === $needle );
	}

	public function ensure_directory_exists( $path ) {
		if ( file_exists( $path ) ) {
			return is_dir( $path );
		}

		// Try to create the directory
		$path = $this-&gt;normalize_path( $path );

		if ( ! $this-&gt;WPFS()-&gt;mkdir( $path ) ) {
			// Walk up the tree and create any missing parent directories
			$this-&gt;ensure_directory_exists( dirname( $path ) );
			$this-&gt;WPFS()-&gt;mkdir( $path );
		}

		return is_dir( $path );
	}

	public static function instance() {
		if ( ! self::$_instance ) {
			self::$_instance = new ET_Core_Data_Utils();
		}

		return self::$_instance;
	}

	/**
	 * Determine if an array has any `string` keys (thus would be considered an object in JSON)
	 *
	 * @param $array
	 *
	 * @return bool
	 */
	public function is_assoc_array( $array ) {
		return is_array( $array ) &amp;&amp; count( array_filter( array_keys( $array ), &#039;is_string&#039; ) ) &gt; 0;
	}

	/**
	 * Determine if value is an XML-RPC error.
	 *
	 * @param SimpleXMLElement $value
	 *
	 * @return bool
	 */
	public function is_xmlrpc_error( $value ) {
		return is_object( $value ) &amp;&amp; isset( $value-&gt;faultCode );
	}

	/**
	 * Replaces any Windows style directory separators in $path with Linux style separators.
	 * Windows actually supports both styles, even mixed together. However, its better not
	 * to mix them (especially when doing string comparisons on paths).
	 *
	 * @since 4.0.8     Use {@see wp_normalize_path()} if it exists. Remove all occurrences of &#039;..&#039; from paths.
	 * @since 3.0.52
	 *
	 * @param string $path
	 *
	 * @return string
	 */
	public function normalize_path( $path = &#039;&#039; ) {
		$path = (string) $path;
		$path = str_replace( &#039;..&#039;, &#039;&#039;, $path );

		if ( function_exists( &#039;wp_normalize_path&#039; ) ) {
			return wp_normalize_path( $path );
		}

		return str_replace( &#039;\\&#039;, &#039;/&#039;, $path );
	}

	/**
	 * Generate post data for a XML-RPC method call
	 *
	 * @param string $method_name
	 * @param array  $params
	 *
	 * @return string
	 */
	public function prepare_xmlrpc_method_call( $method_name, $params = array() ) {
		$output = &#039;&#039;;

		foreach ( $params as $param ) {
			$value = $this-&gt;_create_xmlrpc_value( $param );
			$output .= &quot;&lt;param&gt;{$value}&lt;/param&gt;&quot;;
		}

		$method_name = esc_html( $method_name );

		return
			&quot;&lt;?xml version=&#039;1.0&#039; encoding=&#039;UTF-8&#039;?&gt;
			&lt;methodCall&gt;
				&lt;methodName&gt;{$method_name}&lt;/methodName&gt;
				&lt;params&gt;
					{$output}
				&lt;/params&gt;
			&lt;/methodCall&gt;&quot;;
	}

	/**
	 * Disable XML entity loader.
	 *
	 * @since 4.7.5 Don&#039;t execute deprecated `libxml_disable_entity_loader()` on PHP 8.0.
	 *
	 * @param bool $disable
	 *
	 * @return void
	 */
	public function libxml_disable_entity_loader( $disable ) {
		// The `libxml_disable_entity_loader()` method is deprecated since PHP 8.0 because
		// PHP 8.0 and later uses libxml versions from 2.9.0, which disabled XXE by default.
		if ( PHP_VERSION_ID &lt; 80000 &amp;&amp; function_exists( &#039;libxml_disable_entity_loader&#039; ) ) {
			libxml_disable_entity_loader( $disable );
		}
	}

	/**
	 * Securely use simplexml_load_string.
	 *
	 * @param string $data XML data string.
	 *
	 * @return SimpleXMLElement
	 */
	public function simplexml_load_string( $data ) {
		$this-&gt;libxml_disable_entity_loader( true );
		return simplexml_load_string( $data );
	}

	/**
	 * Creates a path string using the provided arguments.
	 *
	 * Examples:
	 *   - ```
	 *      et_()-&gt;path( &#039;/this/is&#039;, &#039;a&#039;, &#039;path&#039; );
	 *      // Returns &#039;/this/is/a/path&#039;
	 *     ```
	 *   - ```
	 *      et_()-&gt;path( [&#039;/this/is&#039;, &#039;a&#039;, &#039;path&#039;, &#039;to&#039;, &#039;file.php&#039;] );
	 *      // Returns &#039;/this/is/a/path/to/file.php&#039;
	 *     ```
	 *
	 * @since 4.0.6
	 *
	 * @param string|string[] ...$parts
	 *
	 * @return string
	 */
	public function path() {
		$parts = func_get_args();
		$path  = &#039;&#039;;

		if ( 1 === count( $parts ) &amp;&amp; is_array( reset( $parts ) ) ) {
			$parts = array_pop( $parts );
		}

		foreach ( $parts as $part ) {
			$path .= &quot;{$part}/&quot;;
		}

		return substr( $path, 0, -1 );
	}

	/**
	 * Process an XML-RPC response string.
	 *
	 * @param $response
	 *
	 * @return mixed
	 */
	public function process_xmlrpc_response( $response, $skip_processing = false ) {
		$response = $this-&gt;simplexml_load_string( $response );
		$result   = array();

		if ( $skip_processing ) {
			return $response;
		}

		if ( count( $response-&gt;fault ) &gt; 0 ) {
			// An error was returned
			return $this-&gt;_parse_value( $response-&gt;fault-&gt;value );
		}

		$single = count( $response-&gt;params-&gt;param ) === 1;

		foreach ( $response-&gt;params-&gt;param as $param ) {
			$value = $this-&gt;_parse_value( $param-&gt;value );

			if ( $single ) {
				return $value;
			} else {
				$result[] = $value;
			}
		}

		return $result;
	}

	/**
	 * Removes empty directories recursively starting at and (possibly) including `$path`. `$path` must be
	 * an absolute path located under {@see WP_CONTENT_DIR}. Current user must have &#039;manage_options&#039;
	 * capability. If the path or permissions check fails, no directories will be removed.
	 *
	 * @param string $path Absolute path to parent directory.
	 */
	public function remove_empty_directories( $path ) {
		$path = realpath( $path );

		if ( empty( $path ) ) {
			// $path doesn&#039;t exist
			return;
		}

		$path        = $this-&gt;normalize_path( $path );
		$content_dir = $this-&gt;normalize_path( WP_CONTENT_DIR );

		if ( 0 !== strpos( $path, $content_dir ) || $content_dir === $path ) {
			return;
		}

		$capability = 0 === strpos( $path, &quot;{$content_dir}/cache/et&quot; ) ? &#039;edit_posts&#039; : &#039;manage_options&#039;;

		if ( ! wp_doing_cron() &amp;&amp; ! et_core_security_check_passed( $capability ) ) {
			return;
		}

		$this-&gt;_remove_empty_directories( $path );
	}

	/**
	 * Whether or not a value includes another value.
	 *
	 * @param mixed  $haystack The value to look in.
	 * @param string $needle   The value to look for.
	 *
	 * @return bool
	 */
	public function includes( $haystack, $needle ) {
		if ( is_string( $haystack ) ) {
			return false !== strpos( $haystack, $needle );
		}

		if ( is_object( $haystack ) ) {
			return property_exists( $haystack, $needle );
		}

		if ( is_array( $haystack ) ) {
			return in_array( $needle, $haystack );
		}

		return false;
	}

	public function sanitize_text_fields( $fields ) {
		if ( ! is_array( $fields ) ) {
			return sanitize_text_field( $fields );
		}

		$result = array();

		foreach ( $fields as $field_id =&gt; $field_value ) {
			$field_id = sanitize_text_field( $field_id );

			if ( is_array( $field_value ) ) {
				$field_value = $this-&gt;sanitize_text_fields( $field_value );
			} else {
				$field_value = sanitize_text_field( $field_value );
			}

			$result[ $field_id ] = $field_value;
		}

		return $result;
	}

	/**
	 * Recursively traverses an array and escapes the keys and values according to passed escaping function.
	 *
	 * @since 3.17.3
	 *
	 * @param array  $values            The array to be recursively escaped.
	 * @param string $escaping_function The escaping function to be used on keys and values. Default &#039;esc_html&#039;. Optional.
	 *
	 * @return array
	 */

	public function esc_array( $values, $escaping_function = &#039;esc_html&#039; ) {
		if ( ! is_array( $values ) ) {
			return $escaping_function( $values );
		}

		$result = array();

		foreach ( $values as $key =&gt; $value ) {
			$key = $escaping_function( $key );

			if ( is_array( $value ) ) {
				$value = $this-&gt;esc_array( $value, $escaping_function );
			} else {
				$value = $escaping_function( $value );
			}

			$result[ $key ] = $value;
		}

		return $result;
	}

	/**
	 * Transforms an array of data into a new array based on the provided transformation definition.
	 *
	 * @since 3.10     Renamed from `transform_data_to` to `array_transform`.
	 * @since 3.0.68
	 *
	 * @param array  $data         The data to transform.
	 * @param array  $data_map     Transformation definition. See examples below.
	 * @param string $direction    The direction in which to transform. Accepts &#039;-&gt;&#039;, &#039;&lt;-&#039;. Default &#039;-&gt;&#039;
	 * @param array  $exclude_keys Keys that should be excluded from the result. Optional.
	 *
	 * @return array
	 */
	public function array_transform( $data, $data_map, $direction = &#039;-&gt;&#039;, $exclude_keys = array() ) {
		$result = array();

		if ( ! in_array( $direction, array( &#039;-&gt;&#039;, &#039;&lt;-&#039; ) ) ) {
			return $result;
		}

		foreach ( $data_map as $address_1 =&gt; $address_2 ) {
			$from_address = &#039;-&gt;&#039; === $direction ? $address_1 : $address_2;
			$to_address   = &#039;-&gt;&#039; === $direction ? $address_2 : $address_1;

			$array_value_required = $negate_bool_value = false;

			if ( 0 === strpos( $to_address, &#039;@&#039; ) || 0 === strpos( $from_address, &#039;@&#039; ) ) {
				$array_value_required = true;
				$to_address           = ltrim( $to_address, &#039;@&#039; );
				$from_address         = ltrim( $from_address, &#039;@&#039; );

			} else if ( 0 === strpos( $to_address, &#039;!&#039; ) || 0 === strpos( $from_address, &#039;!&#039; ) ) {
				$negate_bool_value = true;
				$to_address        = ltrim( $to_address, &#039;!&#039; );
				$from_address      = ltrim( $from_address, &#039;!&#039; );
			}

			if ( ! empty( $exclude_keys ) &amp;&amp; array_key_exists( $to_address, $exclude_keys ) ) {
				continue;
			}

			$value = $this-&gt;array_get( $data, $from_address, null );

			if ( null === $value ) {
				// Unknown key, skip it.
				continue;
			}

			if ( $array_value_required &amp;&amp; ! is_array( $value ) ) {
				$value = array( $value );

			} else if ( $negate_bool_value ) {
				$value = (bool) $value;
				$value = ! $value;
			}

			$this-&gt;array_set( $result, $to_address, $value );
		}

		return $result;
	}

	/**
	 * Converts xml data to array. Useful in cases where the xml doesn&#039;t adhere to XML-RPC spec.
	 *
	 * @param string|\SimpleXMLElement $xml_data
	 *
	 * @return array
	 */
	public function xml_to_array( $xml_data ) {
		if ( is_string( $xml_data ) ) {
			$xml_data = $this-&gt;simplexml_load_string( $xml_data );
		}

		$json = wp_json_encode( $xml_data );
		return json_decode( $json, true );
	}

	/**
	 * Make sure that in provided selector do not exist sub-selectors that targets inputs placeholders
	 *
	 * If they exist they should be split in an apart selector.
	 *
	 * @param string $selector
	 *
	 * @return array Return a list of selectors
	 */
	public function sanitize_css_placeholders( $selector ) {
		$selectors     = explode( &#039;,&#039;, $selector );
		$selectors     = array_map( &#039;trim&#039;, $selectors );
		$selectors     = array_filter( $selectors );
		$main_selector = array();
		$exceptions    = array();
		$placeholders  = array(
			&#039;::-webkit-input-placeholder&#039;,
			&#039;::-moz-placeholder&#039;,
			&#039;:-ms-input-placeholder&#039;,
		);

		// No need to sanitize if is a single selector or even no selectors at all
		// Also if selectors do not contain placeholder meta-selector
		if ( count( $selectors ) &lt; 2 || ! preg_match( &#039;/&#039; . implode( &#039;|&#039;, $placeholders ) . &#039;/&#039;, $selector ) ) {
			return array( $selector );
		}

		foreach ( $selectors as $_selector ) {
			foreach ( $placeholders as $placeholder ) {
				if ( strpos( $_selector, $placeholder ) !== false ) {
					$exceptions[] = $_selector;
					continue 2;
				}
			}

			$main_selector[] = $_selector;
		}

		return array_filter( array_merge( array( implode( &#039;, &#039;, $main_selector ) ), $exceptions ) );
	}

	/**
	 * Whether or not a string starts with a substring.
	 *
	 * @since 4.0
	 *
	 * @param string $string
	 * @param string $substring
	 *
	 * @return bool
	 */
	public function starts_with( $string, $substring ) {
		return 0 === strpos( $string, $substring );
	}

	/**
	 * Convert string to camel case format.
	 *
	 * @since 4.0
	 *
	 * @param string $string Original string data.
	 * @param array  $no_strip Additional regex pattern exclusion.
	 *
	 * @return string
	 */
	public function camel_case( $string, $no_strip = array() ) {
		$words = preg_split( &#039;/[^a-zA-Z0-9&#039; . implode( &#039;&#039;, $no_strip ) . &#039;]+/i&#039;, strtolower( $string ) );

		if ( count( $words ) === 1 ) {
			return $words[0];
		}

		$camel_cased = implode( &#039;&#039;, array_map( &#039;ucwords&#039;, $words ) );

		$camel_cased[0] = strtolower( $camel_cased[0] );

		return $camel_cased;
	}

	/**
	 * Returns the WP Filesystem instance.
	 *
	 * @since 4.0.6
	 *
	 * @return WP_Filesystem_Base {@see ET_Core_PageResource::wpfs()}
	 */
	public function WPFS() {
		return et_core_cache_dir()-&gt;wpfs;
	}

	/**
	 * Equivalent of usort but preserves relative order of equally weighted values.
	 *
	 * @since 4.0.9
	 *
	 * @param array &amp;$array
	 * @param callable $comparison_function
	 *
	 * @return array
	 */
	public function usort( &amp;$array, $comparison_function ) {
		return $this-&gt;_user_sort( $array, &#039;usort&#039;, $comparison_function );
	}

	/**
	 * Equivalent of uasort but preserves relative order of equally weighted values.
	 *
	 * @since 4.0.9
	 *
	 * @param array &amp;$array
	 * @param callable $comparison_function
	 *
	 * @return array
	 */
	public function uasort( &amp;$array, $comparison_function ) {
		return $this-&gt;_user_sort( $array, &#039;uasort&#039;, $comparison_function );
	}

	/**
	 * Equivalent of uksort but preserves relative order of equally weighted values.
	 *
	 * @since 4.0.9
	 *
	 * @param array &amp;$array
	 * @param callable $comparison_function
	 *
	 * @return array
	 */
	public function uksort( &amp;$array, $comparison_function ) {
		return $this-&gt;_user_sort( $array, &#039;uksort&#039;, $comparison_function );
	}

	/**
	 * Returns a string with a valid CSS property value.
	 *
	 * With some locales (ex: ro_RO) the decimal point can be &#039;,&#039; (comma) and
	 * we need to convert that to a &#039;.&#039; (period) decimal point to ensure that
	 * the value is a valid CSS property value.
	 *
	 * @since 4.4.8
	 *
	 * @param float $float Original float value.
	 *
	 * @return string
	 */
	public function to_css_decimal( $float ) {
		return strtr( $float, &#039;,&#039;, &#039;.&#039; );
	}

	/**
	 * Sort using a custom function accounting for the common undefined order
	 * pitfall due to a return value of 0.
	 *
	 * @since 4.0.9
	 *
	 * @param array &amp;$array Array to sort
	 * @param callable $sort_function &quot;usort&quot;, &quot;uasort&quot; or &quot;uksort&quot;
	 * @param callable $comparison_function Custom comparison function
	 *
	 * @return array
	 */
	protected function _user_sort( &amp;$array, $sort_function, $comparison_function ) {
		$allowed_sort_functions = array( &#039;usort&#039;, &#039;uasort&#039;, &#039;uksort&#039; );

		if ( ! $this-&gt;includes( $allowed_sort_functions, $sort_function ) ) {
			_doing_it_wrong( __FUNCTION__, esc_html__( &#039;Only custom sorting functions can be used.&#039;, &#039;et_core&#039; ), esc_html( et_get_theme_version() ) );
		}

		// Use properties temporarily to pass values in order to preserve PHP 5.2 support.
		$this-&gt;sort_arguments[&#039;array&#039;]      = $array;
		$this-&gt;sort_arguments[&#039;sort&#039;]       = $sort_function;
		$this-&gt;sort_arguments[&#039;comparison&#039;] = $comparison_function;
		$this-&gt;sort_arguments[&#039;array_map&#039;]  = &#039;uksort&#039; === $sort_function
			? array_flip( array_keys( $array ) )
			: array_values( $array );

		$sort_function( $array, array( $this, &#039;_user_sort_callback&#039; ) );

		$this-&gt;sort_arguments[&#039;array&#039;]      = array();
		$this-&gt;sort_arguments[&#039;array_map&#039;]  = array();
		$this-&gt;sort_arguments[&#039;sort&#039;]       = &#039;__return_false&#039;;
		$this-&gt;sort_arguments[&#039;comparison&#039;] = &#039;__return_false&#039;;

		return $array;
	}

	/**
	 * Sort callback only meant to acompany self::sort().
	 * Do not use outside of self::_user_sort().
	 *
	 * @since 4.0.9
	 *
	 * @param mixed $a
	 * @param mixed $b
	 *
	 * @return integer
	 */
	protected function _user_sort_callback( $a, $b ) {
		// @phpcs:ignore Generic.PHP.ForbiddenFunctions.Found
		$result = (int) call_user_func( $this-&gt;sort_arguments[&#039;comparison&#039;], $a, $b );

		if ( 0 !== $result ) {
			return $result;
		}

		if ( &#039;uksort&#039; === $this-&gt;sort_arguments[&#039;sort&#039;] ) {
			// Intentional isset() use for performance reasons.
			$a_order = isset( $this-&gt;sort_arguments[&#039;array_map&#039;][ $a ] ) ? $this-&gt;sort_arguments[&#039;array_map&#039;][ $a ] : false;
			$b_order = isset( $this-&gt;sort_arguments[&#039;array_map&#039;][ $b ] ) ? $this-&gt;sort_arguments[&#039;array_map&#039;][ $b ] : false;
		} else {
			$a_order = array_search( $a, $this-&gt;sort_arguments[&#039;array_map&#039;] );
			$b_order = array_search( $b, $this-&gt;sort_arguments[&#039;array_map&#039;] );
		}

		if ( false === $a_order || false === $b_order ) {
			// This should not be possible so we fallback to the undefined
			// sorting behavior by returning 0.
			return 0;
		}

		return $a_order - $b_order;
	}

	/**
	 * Returns RFC 4211 compliant Universally Unique Identifier (UUID) version 4
	 * https://tools.ietf.org/html/rfc4122
	 *
	 * @since 4.5.0
	 *
	 * @param array $random_sequence The initial random sequence. Mostly used for test purposes.
	 *
	 * @return string
	 */
	public static function uuid_v4( $random_sequence = null ) {
		$buffer = array();

		for ( $i = 0; $i &lt; 16; $i++) {
			$buffer[] = isset( $random_sequence[ $i ] ) ? $random_sequence[ $i ] : mt_rand(0, 0xff);
		}

		// The high field of the timestamp multiplexed with the version number
		$buffer[6] = ( $buffer[6] &amp; 0x0f ) | 0x40;

		// The high field of the clock sequence multiplexed with the variant
		$buffer[8] = ( $buffer[8] &amp; 0x3f ) | 0x80;

		return sprintf(
			&#039;%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x&#039;,

			// Time low
			$buffer[0],
			$buffer[1],
			$buffer[2],
			$buffer[3],

			// Time mid
			$buffer[4],
			$buffer[5],

			// Time hi and version
			$buffer[6],
			$buffer[7],

			// Clock seq hi and reserved
			$buffer[8],

			// Clock seq low
			$buffer[9],

			// Node
			$buffer[10],
			$buffer[11],
			$buffer[12],
			$buffer[13],
			$buffer[14],
			$buffer[15]
		);
	}
}


function et_core_data_utils_minify_css( $string = &#039;&#039; ) {
	$comments = &lt;&lt;&lt; EOS
(?sx)
	# don&#039;t change anything inside of quotes
	( &quot;(?:[^&quot;\\\]++|\\\.)*+&quot; | &#039;(?:[^&#039;\\\]++|\\\.)*+&#039; )
|
	# comments
	/\* (?&gt; .*? \*/ )
EOS;

	$everything_else = &lt;&lt;&lt; EOS
(?six)
	# don&#039;t change anything inside of quotes
	( &quot;(?:[^&quot;\\\]++|\\\.)*+&quot; | &#039;(?:[^&#039;\\\]++|\\\.)*+&#039; )
|
	# spaces before and after ; and }
	\s*+ ; \s*+ ( } ) \s*+
|
	# all spaces around meta chars/operators (excluding + and -)
	\s*+ ( [*$~^|]?+= | [{};,&gt;~] | !important\b ) \s*+
|
	# all spaces around + and - (in selectors only!)
	\s*([+-])\s*(?=[^}]*{)
|
	# spaces right of ( [ :
	( [[(:] ) \s++
|
	# spaces left of ) ]
	\s++ ( [])] )
|
	# spaces left (and right) of : (but not in selectors)!
	\s+(:)(?![^\}]*\{)
|
	# spaces at beginning/end of string
	^ \s++ | \s++ \z
|
	# double spaces to single
	(\s)\s+
EOS;

	$search_patterns  = array( &quot;%{$comments}%&quot;, &quot;%{$everything_else}%&quot; );
	$replace_patterns = array( &#039;$1&#039;, &#039;$1$2$3$4$5$6$7$8&#039; );

	return preg_replace( $search_patterns, $replace_patterns, $string );
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2F.trash%2F9monarch%2Fcore%2Fcomponents%2Fdata'>⬅ Back to Directory</a>