<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: autoptimizeStyles.php</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>&lt;?php
/**
 * Class for CSS optimization.
 */

if ( ! defined( 'ABSPATH' ) ) {
    exit;
}

class autoptimizeStyles extends autoptimizeBase
{
    const ASSETS_REGEX = '/url\s*\(\s*(?![&quot;\']?data:)(?![\'|\&quot;]?[\#|\%|])([^)]+)\s*\)([^;},\s]*)/i';

    /**
     * Font-face regex-fu from HamZa at: https://stackoverflow.com/a/21395083
     */
    const FONT_FACE_REGEX = '~@font-face\s*(\{(?:[^{}]+|(?1))*\})~xsi'; // added `i` flag for case-insensitivity.

    /**
     * Store CSS.
     *
     * @var array
     */
    private $css = array();

    /**
     * To store CSS code
     *
     * @var array
     */
    private $csscode = array();

    /**
     * To store urls
     *
     * @var array
     */
    private $url = array();

    /**
     * String to store rest of content (when old setting &quot;only in head&quot; is used)
     *
     * @var string
     */
    private $restofcontent = '';

    /**
     * Setting to change small images to inline CSS
     *
     * @var bool
     */
    private $datauris = false;

    /**
     * Array to store hashmap
     *
     * @var array
     */
    private $hashmap = array();

    /**
     * Flag to indicate if CSS is already minified
     *
     * @var bool
     */
    private $alreadyminified = false;

    /**
     * Setting if CSS should be aggregated
     *
     * @var bool
     */
    private $aggregate = true;

    /**
     * Setting if all CSS should be inlined
     *
     * @var bool
     */
    private $inline = false;

    /**
     * Setting if CSS should be deferred
     *
     * @var bool
     */
    private $defer = false;

    /**
     * Setting for to be inlined CSS.
     *
     * @var string
     */
    private $defer_inline = '';

    /**
     * Setting for allowlist of what should be aggregated.
     *
     * @var string
     */
    private $allowlist = '';

    /**
     * Setting (only filter) for size under which CSS should be inlined instead of linked.
     *
     * @var string
     */
    private $cssinlinesize = '';

    /**
     * Setting (only filter) of CSS that can be removed.
     *
     * @var array
     */
    private $cssremovables = array();

    /**
     * Setting: should inline CSS be aggregated.
     *
     * @var bool
     */
    private $include_inline = false;

    /**
     * Setting (only filter) if minified CSS can be injected after minificatoin of aggregated CSS.
     *
     * @var bool
     */
    private $inject_min_late = true;

    /**
     * Holds all exclusions.
     *
     * @var array
     */
    private $dontmove = array();

    /**
     * Holds all options.
     *
     * @var array
     */
    private $options = array();

    /**
     * Setting; should excluded CSS-files be minified.
     *
     * @var bool
     */
    private $minify_excluded = true;

    /**
     * Setting (filter only); should all media-attributes be forced to &quot;all&quot;.
     *
     * @var bool
     */
    private $media_force_all = false;

    /**
     * Reads the page and collects style tags.
     *
     * @param array $options all options.
     */
    public function read( $options )
    {
        $noptimize_css = apply_filters( 'autoptimize_filter_css_noptimize', false, $this-&gt;content );
        if ( $noptimize_css || false === autoptimizeConfig::get_post_meta_ao_settings( 'ao_post_css_optimize' ) ) {
            return false;
        }

        $allowlist_css = apply_filters( 'autoptimize_filter_css_allowlist', '', $this-&gt;content );
        if ( ! empty( $allowlist_css ) ) {
            $this-&gt;allowlist = array_filter( array_map( 'trim', explode( ',', $allowlist_css ) ) );
        }

        $removable_css = apply_filters( 'autoptimize_filter_css_removables', '' );
        if ( ! empty( $removable_css ) ) {
            $this-&gt;cssremovables = array_filter( array_map( 'trim', explode( ',', $removable_css ) ) );
        }

        $this-&gt;cssinlinesize = apply_filters( 'autoptimize_filter_css_inlinesize', 256 );

        // filter to &quot;late inject minified CSS&quot;, default to true for now (it is faster).
        $this-&gt;inject_min_late = apply_filters( 'autoptimize_filter_css_inject_min_late', true );

        // Remove everything that's not the header.
        if ( apply_filters( 'autoptimize_filter_css_justhead', $options['justhead'] ) ) {
            $content             = explode( '&lt;/head&gt;', $this-&gt;content, 2 );
            $this-&gt;content       = $content[0] . '&lt;/head&gt;';
            $this-&gt;restofcontent = $content[1];
        }

        // Determine whether we're doing CSS-files aggregation or not.
        if ( isset( $options['aggregate'] ) &amp;&amp; ! $options['aggregate'] ) {
            $this-&gt;aggregate = false;
        }
        // Returning true for &quot;dontaggregate&quot; turns off aggregation.
        if ( $this-&gt;aggregate &amp;&amp; apply_filters( 'autoptimize_filter_css_dontaggregate', false ) ) {
            $this-&gt;aggregate = false;
        }
        // and the filter that should have been there to begin with.
        $this-&gt;aggregate = apply_filters( 'autoptimize_filter_css_aggregate', $this-&gt;aggregate );

        // include inline?
        if ( apply_filters( 'autoptimize_css_include_inline', $options['include_inline'] ) ) {
            $this-&gt;include_inline = true;
        }

        // List of CSS strings which are excluded from autoptimization.
        $exclude_css = apply_filters( 'autoptimize_filter_css_exclude', $options['css_exclude'], $this-&gt;content );
        if ( '' !== $exclude_css ) {
            $this-&gt;dontmove = array_filter( array_map( 'trim', explode( ',', $exclude_css ) ) );
        } else {
            $this-&gt;dontmove = array();
        }

        // forcefully exclude CSS with data-noptimize attrib.
        $this-&gt;dontmove[] = 'data-noptimize';

        // forcefully exclude inline CSS with &quot;.wp-container-&quot; which due to the random-ish nature busts AO's cache continuously.
        $this-&gt;dontmove[] = '.wp-container-';

        // Should we defer css?
        // value: true / false.
        $this-&gt;defer = $options['defer'];
        $this-&gt;defer = apply_filters( 'autoptimize_filter_css_defer', $this-&gt;defer, $this-&gt;content );

        // If page/ post check post_meta to see if optimize is off.
        if ( $this-&gt;defer &amp;&amp; false === autoptimizeConfig::get_post_meta_ao_settings( 'ao_post_ccss' ) ) {
             $this-&gt;defer = false;
        }

        // Should we inline while deferring?
        // value: inlined CSS.
        $this-&gt;defer_inline = apply_filters( 'autoptimize_filter_css_defer_inline', $this-&gt;sanitize_css( $options['defer_inline'] ), $this-&gt;content );

        // Should we inline?
        // value: true / false.
        $this-&gt;inline = $options['inline'];
        $this-&gt;inline = apply_filters( 'autoptimize_filter_css_inline', $this-&gt;inline, $this-&gt;content );

        // Store cdn url.
        $this-&gt;cdn_url = $options['cdn_url'];

        // Store data: URIs setting for later use.
        $this-&gt;datauris = $options['datauris'];

        // Determine whether excluded files should be minified if not yet so.
        if ( ! $options['minify_excluded'] &amp;&amp; $options['aggregate'] ) {
            $this-&gt;minify_excluded = false;
        }
        $this-&gt;minify_excluded = apply_filters( 'autoptimize_filter_css_minify_excluded', $this-&gt;minify_excluded, '' );

        // should we force all media-attributes to all?
        $this-&gt;media_force_all = apply_filters( 'autoptimize_filter_css_tagmedia_forceall', false );

        // noptimize me.
        $this-&gt;content = $this-&gt;hide_noptimize( $this-&gt;content );

        // Exclude (no)script, as those may contain CSS which should be left as is.
        $this-&gt;content = $this-&gt;replace_contents_with_marker_if_exists(
            'SCRIPT',
            '&lt;script',
            '#&lt;(?:no)?script.*?&lt;\/(?:no)?script&gt;#is',
            $this-&gt;content
        );

        // Save IE hacks.
        $this-&gt;content = $this-&gt;hide_iehacks( $this-&gt;content );

        // Hide HTML comments.
        $this-&gt;content = $this-&gt;hide_comments( $this-&gt;content );

        // Get &lt;style&gt; and &lt;link&gt;.
        if ( preg_match_all( '#(&lt;style[^&gt;]*&gt;.*&lt;/style&gt;)|(&lt;link[^&gt;]*stylesheet[^&gt;]*&gt;)#Usmi', $this-&gt;content, $matches ) ) {

            foreach ( $matches[0] as $tag ) {
                if ( $this-&gt;isremovable( $tag, $this-&gt;cssremovables ) ) {
                    $this-&gt;content = str_replace( $tag, '', $this-&gt;content );
                } elseif ( $this-&gt;ismovable( $tag ) ) {
                    // Get the media.
                    if ( false !== strpos( $tag, 'media=' ) ) {
                        preg_match( '#media=(?:&quot;|\')([^&gt;]*)(?:&quot;|\')#Ui', $tag, $medias );
                        if ( ! empty( $medias ) ) {
                            $medias = explode( ',', $medias[1] );
                            $media  = array();
                            foreach ( $medias as $elem ) {
                                if ( empty( $elem ) ) {
                                    $elem = 'all';
                                }

                                $media[] = $elem;
                            }
                        } else {
                            $media = array( 'all' );
                        }
                    } else {
                        // No media specified - applies to all.
                        $media = array( 'all' );
                    }

                    // forcing media attribute to all to merge all in one file.
                    if ( $this-&gt;media_force_all ) {
                        $media = array( 'all' );
                    }

                    $media = apply_filters( 'autoptimize_filter_css_tagmedia', $media, $tag );

                    if ( preg_match( '#&lt;link.*href=(&quot;|\')(.*)(&quot;|\')#Usmi', $tag, $source ) ) {
                        // &lt;link&gt;.
                        $url  = current( explode( '?', $source[2], 2 ) );
                        $path = $this-&gt;getpath( $url );

                        if ( false !== $path &amp;&amp; preg_match( '#\.css$#', $path ) ) {
                            // Good link.
                            $this-&gt;css[] = array( $media, $path );
                        } else {
                            // Link is dynamic (.php etc).
                            $new_tag = $this-&gt;optionally_defer_excluded( $tag, 'none' );
                            if ( '' !== $new_tag &amp;&amp; $new_tag !== $tag ) {
                                $this-&gt;content = str_replace( $tag, $new_tag, $this-&gt;content );
                            }
                            $tag = '';
                        }
                    } else {
                        // Inline css in style tags can be wrapped in comment tags, so restore comments.
                        $tag = $this-&gt;restore_comments( $tag );
                        preg_match( '#&lt;style.*&gt;(.*)&lt;/style&gt;#Usmi', $tag, $code );

                        // And re-hide them to be able to to the removal based on tag.
                        $tag = $this-&gt;hide_comments( $tag );

                        if ( $this-&gt;include_inline ) {
                            $code        = preg_replace( '#^.*&lt;!\[CDATA\[(?:\s*\*/)?(.*)(?://|/\*)\s*?\]\]&gt;.*$#sm', '$1', $code[1] );
                            $this-&gt;css[] = array( $media, 'INLINE;' . $code );
                        } else {
                            $tag = '';
                        }
                    }

                    // Remove the original style tag.
                    $this-&gt;content = str_replace( $tag, '', $this-&gt;content );
                } else {
                    if ( preg_match( '#&lt;link.*href=(&quot;|\')(.*)(&quot;|\')#Usmi', $tag, $source ) ) {
                        $exploded_url = explode( '?', $source[2], 2 );
                        $url          = $exploded_url[0];
                        $path         = $this-&gt;getpath( $url );
                        $new_tag      = $tag;

                        // Excluded CSS, minify that file:
                        // -&gt; if aggregate is on and exclude minify is on
                        // -&gt; if aggregate is off and the file is not in dontmove.
                        if ( $path &amp;&amp; $this-&gt;minify_excluded ) {
                            $consider_minified_array = apply_filters( 'autoptimize_filter_css_consider_minified', false );
                            if ( ( false === $this-&gt;aggregate &amp;&amp; str_replace( $this-&gt;dontmove, '', $path ) === $path ) || ( true === $this-&gt;aggregate &amp;&amp; ( false === $consider_minified_array || str_replace( $consider_minified_array, '', $path ) === $path ) ) ) {
                                $minified_url = $this-&gt;minify_single( $path );
                                if ( ! empty( $minified_url ) ) {
                                    // Replace orig URL with cached minified URL.
                                    $new_tag = str_replace( $url, $minified_url, $tag );
                                } elseif ( apply_filters( 'autoptimize_filter_ccsjs_remove_empty_minified_url', false ) ) {
                                    // Remove the original style tag, because cache content is empty but only if
                                    // filter is true-ed because $minified_url is also false if file is minified already.
                                    $new_tag = '';
                                }
                            }
                        }

                        if ( '' !== $new_tag ) {
                            // Optionally defer (preload) non-aggregated CSS.
                            $new_tag = $this-&gt;optionally_defer_excluded( $new_tag, $url );

                            // Check if we still need to CDN (esp. for already minified resources).
                            if ( ! empty( $this-&gt;cdn_url ) || has_filter( 'autoptimize_filter_base_replace_cdn' ) ) {
                                $new_tag = str_replace( $url, $this-&gt;url_replace_cdn( $url ), $new_tag );
                            }
                        }

                        // And replace!
                        if ( ( '' !== $new_tag &amp;&amp; $new_tag !== $tag ) || ( '' === $new_tag &amp;&amp; apply_filters( 'autoptimize_filter_css_remove_empty_files', false ) ) ) {
                            $this-&gt;content = str_replace( $tag, $new_tag, $this-&gt;content );
                        }
                    }
                }
            }
            return true;
        }

        // Really, no styles?
        return false;
    }

    /**
     * Checks if non-optimized CSS is to be preloaded and if so return
     * the tag with preload code.
     *
     * @param string $tag (required).
     * @param string $url (optional).
     *
     * @return string $new_tag
     */
    private function optionally_defer_excluded( $tag, $url = '' )
    {
        // Defer single CSS if &quot;inline &amp; defer&quot; is ON and there is inline CSS.
        if ( ! empty( $tag ) &amp;&amp; false === strpos( $tag, ' onload=' ) &amp;&amp; $this-&gt;defer &amp;&amp; ! empty( $this-&gt;defer_inline ) &amp;&amp; apply_filters( 'autoptimize_filter_css_defer_excluded', true, $tag ) ) {
            // get media attribute and based on that create onload JS attribute value.
            if ( false === strpos( $tag, 'media=' ) ) {
                $tag = str_replace( '&lt;link', &quot;&lt;link media='all'&quot;, $tag );
            }

            preg_match( '#media=(?:&quot;|\')([^&gt;]*)(?:&quot;|\')#Ui', $tag, $_medias );
            $_media          = $_medias[1];
            $_preload_onload = autoptimizeConfig::get_ao_css_preload_onload( $_media );

            if ( 'print' !== $_media ) {
                // If not media=print, adapt original &lt;link&gt; element for CSS to be preloaded and add &lt;noscript&gt;-version for fallback.
                $new_tag = '&lt;noscript&gt;' . autoptimizeUtils::remove_id_from_node( $tag ) . '&lt;/noscript&gt;' . str_replace(
                    $_medias[0],
                    &quot;media='print' onload=\&quot;&quot; . $_preload_onload . '&quot;',
                    $tag
                );

                // Optionally (but default false) preload the (excluded) CSS-file.
                if ( apply_filters( 'autoptimize_fitler_css_preload_and_print', false ) &amp;&amp; 'none' !== $url ) {
                    $new_tag = '&lt;link rel=&quot;preload&quot; as=&quot;stylesheet&quot; href=&quot;' . $url . '&quot;/&gt;' . $new_tag;
                }
            } else {
                $new_tag = $tag;
            }

            return $new_tag;
        }

        // Return unchanged $tag.
        return $tag;
    }

    /**
     * Checks if the local file referenced by $path is a valid
     * candidate for being inlined into a data: URI
     *
     * @param string $path image path.
     * @return boolean
     */
    private function is_datauri_candidate( $path )
    {
        // Call only once since it's called from a loop.
        static $max_size = null;
        if ( null === $max_size ) {
            $max_size = $this-&gt;get_datauri_maxsize();
        }

        if ( $path &amp;&amp; preg_match( '#\.(jpe?g|png|gif|webp|bmp)$#i', $path ) &amp;&amp;
            file_exists( $path ) &amp;&amp; is_readable( $path ) &amp;&amp; filesize( $path ) &lt;= $max_size ) {

            // Seems we have a candidate.
            $is_candidate = true;
        } else {
            // Filter allows overriding default decision (which checks for local file existence).
            $is_candidate = apply_filters( 'autoptimize_filter_css_is_datauri_candidate', false, $path );
        }

        return $is_candidate;
    }

    /**
     * Returns the amount of bytes that shouldn't be exceeded if a file is to
     * be inlined into a data: URI. Defaults to 4096, passed through
     * `autoptimize_filter_css_datauri_maxsize` filter.
     *
     * @return mixed
     */
    private function get_datauri_maxsize()
    {
        static $max_size = null;

        /**
         * No need to apply the filter multiple times in case the
         * method itself is invoked multiple times during a single request.
         * This prevents some wild stuff like having different maxsizes
         * for different files/site-sections etc. But if you're into that sort
         * of thing you're probably better of building assets completely
         * outside of WordPress anyway.
         */
        if ( null === $max_size ) {
            $max_size = (int) apply_filters( 'autoptimize_filter_css_datauri_maxsize', 4096 );
        }

        return $max_size;
    }

    private function check_datauri_exclude_list( $url )
    {
        static $exclude_list = null;
        static $no_datauris  = array();

        // Again, skip doing certain stuff repeatedly when loop-called.
        if ( null === $exclude_list ) {
            $exclude_list = apply_filters( 'autoptimize_filter_css_datauri_exclude', '' );
            $no_datauris  = array_filter( array_map( 'trim', explode( ',', $exclude_list ) ) );
        }

        $matched = false;

        if ( ! empty( $exclude_list ) ) {
            foreach ( $no_datauris as $no_datauri ) {
                if ( false !== strpos( $url, $no_datauri ) ) {
                    $matched = true;
                    break;
                }
            }
        }

        return $matched;
    }

    private function build_or_get_datauri_image( $path )
    {
        /**
         * TODO/FIXME: document the required return array format, or better yet,
         * use a string, since we don't really need an array for this. That would, however,
         * require changing even more code, which is not happening right now...
         */

        // Allows short-circuiting datauri generation for an image.
        $result = apply_filters( 'autoptimize_filter_css_datauri_image', array(), $path );
        if ( ! empty( $result ) ) {
            if ( is_array( $result ) &amp;&amp; isset( $result['full'] ) &amp;&amp; isset( $result['base64data'] ) ) {
                return $result;
            }
        }

        $hash  = md5( $path );
        $check = new autoptimizeCache( $hash, 'img' );
        if ( $check-&gt;check() ) {
            // we have the base64 image in cache.
            $head_and_data = $check-&gt;retrieve();
            $_base64data   = explode( ';base64,', $head_and_data );
            $base64data    = $_base64data[1];
            unset( $_base64data );
        } else {
            // It's an image and we don't have it in cache, get the type by extension.
            $exploded_path = explode( '.', $path );
            $type          = end( $exploded_path );

            switch ( $type ) {
                case 'jpg':
                case 'jpeg':
                    $dataurihead = 'data:image/jpeg;base64,';
                    break;
                case 'gif':
                    $dataurihead = 'data:image/gif;base64,';
                    break;
                case 'png':
                    $dataurihead = 'data:image/png;base64,';
                    break;
                case 'bmp':
                    $dataurihead = 'data:image/bmp;base64,';
                    break;
                case 'webp':
                    $dataurihead = 'data:image/webp;base64,';
                    break;
                default:
                    $dataurihead = 'data:application/octet-stream;base64,';
            }

            // Encode the data.
            $base64data    = base64_encode( file_get_contents( $path ) );
            $head_and_data = $dataurihead . $base64data;

            // Save in cache.
            $check-&gt;cache( $head_and_data, 'text/plain' );
        }
        unset( $check );

        return array(
            'full'       =&gt; $head_and_data,
            'base64data' =&gt; $base64data,
        );
    }

    /**
     * Given an array of key/value pairs to replace in $string,
     * it does so by replacing the longest-matching strings first.
     *
     * @param string $string string in which to replace.
     * @param array  $replacements to be replaced strings and replacement.
     *
     * @return string
     */
    protected static function replace_longest_matches_first( $string, $replacements = array() )
    {
        if ( ! empty( $replacements ) ) {
            // Sort the replacements array by key length in desc order (so that the longest strings are replaced first).
            $keys = array_map( 'strlen', array_keys( $replacements ) );
            array_multisort( $keys, SORT_DESC, $replacements );
            $string = str_replace( array_keys( $replacements ), array_values( $replacements ), $string );
        }

        return $string;
    }

    /**
     * Rewrites/Replaces any ASSETS_REGEX-matching urls in a string.
     * Removes quotes/cruft around each one and passes it through to
     * `autoptimizeBase::url_replace_cdn()`.
     * Replacements are performed in a `longest-match-replaced-first` way.
     *
     * @param string $code CSS code.
     *
     * @return string
     */
    public function replace_urls( $code = '' )
    {
        $replacements = array();

        preg_match_all( self::ASSETS_REGEX, $code, $url_src_matches );
        if ( is_array( $url_src_matches ) &amp;&amp; ! empty( $url_src_matches ) ) {
            foreach ( $url_src_matches[1] as $count =&gt; $original_url ) {
                // Removes quotes and other cruft.
                $url = trim( $original_url, &quot; \t\n\r\0\x0B\&quot;'&quot; );

                /**
                 * TODO/FIXME: Add a way for other code / callable to be called here
                 * and provide it's own results for the $replacements array
                 * for the &quot;current&quot; key.
                 * If such a result is returned/provided, we sholud then avoid
                 * calling url_replace_cdn() here for the current iteration.
                 *
                 * This would maybe allow the inlining logic currently present
                 * in `autoptimizeStyles::rewrite_assets()` to be &quot;pulled out&quot;
                 * and given as a callable to this method or something... and
                 * then we could &quot;just&quot; call `replace_urls()` from within
                 * `autoptimizeStyles::rewrite_assets()` and avoid some
                 * (currently present) code/logic duplication.
                 */

                // Do CDN replacement if needed.
                if ( ! empty( $this-&gt;cdn_url ) ) {
                    $replacement_url = $this-&gt;url_replace_cdn( $url );
                    // Prepare replacements array.
                    $replacements[ $url_src_matches[1][ $count ] ] = str_replace(
                        $original_url,
                        $replacement_url,
                        $url_src_matches[1][ $count ]
                    );
                }
            }
        }

        $code = self::replace_longest_matches_first( $code, $replacements );

        return $code;
    }

    /**
     * &quot;Hides&quot; @font-face declarations by replacing them with `%%FONTFACE%%` markers.
     * Also does CDN replacement of any font-urls within those declarations if the `autoptimize_filter_css_fonts_cdn`
     * filter is used.
     *
     * @param string $code HTML being processed to hide fonts.
     * @return string
     */
    public function hide_fontface_and_maybe_cdn( $code )
    {
        // Proceed only if @font-face declarations exist within $code.
        preg_match_all( self::FONT_FACE_REGEX, $code, $fontfaces );
        if ( isset( $fontfaces[0] ) ) {
            // Check if we need to cdn fonts or not.
            $do_font_cdn = apply_filters( 'autoptimize_filter_css_fonts_cdn', false );

            foreach ( $fontfaces[0] as $full_match ) {
                // Keep original match so we can search/replace it.
                $match_search = $full_match;

                // Do font cdn if needed.
                if ( $do_font_cdn ) {
                    $full_match = $this-&gt;replace_urls( $full_match );
                }

                // Replace declaration with its base64 encoded string.
                $replacement = self::build_marker( 'FONTFACE', $full_match );
                $code        = str_replace( $match_search, $replacement, $code );
            }
        }

        return $code;
    }

    /**
     * Restores original @font-face declarations that have been &quot;hidden&quot;
     * using `hide_fontface_and_maybe_cdn()`.
     *
     * @param string $code HTML being processed to unhide fonts.
     * @return string
     */
    public function restore_fontface( $code )
    {
        return $this-&gt;restore_marked_content( 'FONTFACE', $code );
    }

    /**
     * Re-write (and/or inline) referenced assets.
     *
     * @param string $code HTML being processed rewrite assets.
     * @return string
     */
    public function rewrite_assets( $code )
    {
        // Handle @font-face rules by hiding and processing them separately.
        $code = $this-&gt;hide_fontface_and_maybe_cdn( $code );

        /**
         * TODO/FIXME:
         * Certain code parts below are kind-of repeated now in `replace_urls()`, which is not ideal.
         * There is maybe a way to separate/refactor things and then be able to keep
         * the ASSETS_REGEX rewriting/handling logic in a single place (along with removing quotes/cruft from matched urls).
         * See comments in `replace_urls()` regarding this. The idea is to extract the inlining
         * logic out (which is the only real difference between replace_urls() and the code below), but still
         * achieve identical results as before.
         */

        // Re-write (and/or inline) URLs to point them to the CDN host.
        $url_src_matches = array();
        $imgreplace      = array();

        // Matches and captures anything specified within the literal `url()` and excludes those containing data: URIs.
        preg_match_all( self::ASSETS_REGEX, $code, $url_src_matches );
        if ( is_array( $url_src_matches ) &amp;&amp; ! empty( $url_src_matches ) ) {
            foreach ( $url_src_matches[1] as $count =&gt; $original_url ) {
                // Removes quotes and other cruft.
                $url = trim( $original_url, &quot; \t\n\r\0\x0B\&quot;'&quot; );

                // If datauri inlining is turned on, do it.
                $inlined = false;
                if ( $this-&gt;datauris ) {
                    $iurl = $url;
                    if ( false !== strpos( $iurl, '?' ) ) {
                        $iurl = strtok( $iurl, '?' );
                    }

                    $ipath = $this-&gt;getpath( $iurl );

                    $excluded = $this-&gt;check_datauri_exclude_list( $ipath );
                    if ( ! $excluded ) {
                        $is_datauri_candidate = $this-&gt;is_datauri_candidate( $ipath );
                        if ( $is_datauri_candidate ) {
                            $datauri    = $this-&gt;build_or_get_datauri_image( $ipath );
                            $base64data = $datauri['base64data'];
                            // Add it to the list for replacement.
                            $imgreplace[ $url_src_matches[1][ $count ] ] = str_replace(
                                $original_url,
                                $datauri['full'],
                                $url_src_matches[1][ $count ]
                            );
                            $inlined                                     = true;
                        }
                    }
                }

                /**
                 * Doing CDN URL replacement for every found match (if CDN is
                 * specified). This way we make sure to do it even if
                 * inlining isn't turned on, or if a resource is skipped from
                 * being inlined for whatever reason above.
                 */
                if ( ! $inlined &amp;&amp; ( ! empty( $this-&gt;cdn_url ) || has_filter( 'autoptimize_filter_base_replace_cdn' ) ) ) {
                    // Just do the &quot;simple&quot; CDN replacement.
                    $replacement_url                             = $this-&gt;url_replace_cdn( $url );
                    $imgreplace[ $url_src_matches[1][ $count ] ] = str_replace(
                        $original_url,
                        $replacement_url,
                        $url_src_matches[1][ $count ]
                    );
                }
            }
        }

        $code = self::replace_longest_matches_first( $code, $imgreplace );

        // Replace back font-face markers with actual font-face declarations.
        $code = $this-&gt;restore_fontface( $code );

        return $code;
    }

    /**
     * Joins and optimizes CSS.
     */
    public function minify()
    {
        foreach ( $this-&gt;css as $group ) {
            list( $media, $css ) = $group;
            if ( preg_match( '#^INLINE;#', $css ) ) {
                // &lt;style&gt;.
                $css      = preg_replace( '#^INLINE;#', '', $css );
                $css      = self::fixurls( ABSPATH . 'index.php', $css ); // ABSPATH already contains a trailing slash.
                $tmpstyle = apply_filters( 'autoptimize_css_individual_style', $css, '' );
                if ( has_filter( 'autoptimize_css_individual_style' ) &amp;&amp; ! empty( $tmpstyle ) ) {
                    $css                   = $tmpstyle;
                    $this-&gt;alreadyminified = true;
                }
            } else {
                // &lt;link&gt;
                if ( false !== $css &amp;&amp; file_exists( $css ) &amp;&amp; is_readable( $css ) ) {
                    $css_path = $css;
                    $css      = self::fixurls( $css_path, file_get_contents( $css_path ) );
                    $css      = preg_replace( '/\x{EF}\x{BB}\x{BF}/', '', $css );
                    $tmpstyle = apply_filters( 'autoptimize_css_individual_style', $css, $css_path );
                    if ( has_filter( 'autoptimize_css_individual_style' ) &amp;&amp; ! empty( $tmpstyle ) ) {
                        $css                   = $tmpstyle;
                        $this-&gt;alreadyminified = true;
                    } elseif ( $this-&gt;can_inject_late( $css_path, $css ) ) {
                        $css = self::build_injectlater_marker( $css_path, md5( $css ) );
                    }
                } else {
                    // Couldn't read CSS. Maybe getpath isn't working?
                    $css = '';
                }
            }

            foreach ( $media as $elem ) {
                if ( ! empty( $css ) ) {
                    if ( ! isset( $this-&gt;csscode[ $elem ] ) ) {
                        $this-&gt;csscode[ $elem ] = '';
                    }
                    $this-&gt;csscode[ $elem ] .= &quot;\n/*FILESTART*/&quot; . $css;
                }
            }
        }

        // Check for duplicate code.
        $md5list = array();
        $tmpcss  = $this-&gt;csscode;
        foreach ( $tmpcss as $media =&gt; $code ) {
            $md5sum    = md5( $code );
            $medianame = $media;
            foreach ( $md5list as $med =&gt; $sum ) {
                // If same code.
                if ( $sum === $md5sum ) {
                    // Add the merged code.
                    $medianame                   = $med . ', ' . $media;
                    $this-&gt;csscode[ $medianame ] = $code;
                    $md5list[ $medianame ]       = $md5list[ $med ];
                    unset( $this-&gt;csscode[ $med ], $this-&gt;csscode[ $media ], $md5list[ $med ] );
                }
            }
            $md5list[ $medianame ] = $md5sum;
        }
        unset( $tmpcss );

        // Manage @imports, while is for recursive import management.
        foreach ( $this-&gt;csscode as &amp;$thiscss ) {
            // Flag to trigger import reconstitution and var to hold external imports.
            $fiximports       = false;
            $external_imports = '';

            // remove comments to avoid importing commented-out imports.
            $thiscss_nocomments = preg_replace( '#/\*.*\*/#Us', '', $thiscss );
            while ( preg_match_all( '#@import +(?:url)?(?:(?:\(([&quot;\']?)(?:[^&quot;\')]+)\1\)|([&quot;\'])(?:[^&quot;\']+)\2)(?:[^,;&quot;\']+(?:,[^,;&quot;\']+)*)?)(?:;)#mi', $thiscss_nocomments, $matches ) ) {
                foreach ( $matches[0] as $import ) {
                    if ( $this-&gt;isremovable( $import, $this-&gt;cssremovables ) ) {
                        $thiscss   = str_replace( $import, '', $thiscss );
                        $import_ok = true;
                    } else {
                        $url       = trim( preg_replace( '#^.*((?:https?:|ftp:)?//.*\.css).*$#', '$1', trim( $import ) ), &quot; \t\n\r\0\x0B\&quot;'&quot; );
                        $path      = $this-&gt;getpath( $url );
                        $import_ok = false;
                        if ( file_exists( $path ) &amp;&amp; is_readable( $path ) ) {
                            $code     = addcslashes( self::fixurls( $path, file_get_contents( $path ) ), '\\' );
                            $code     = preg_replace( '/\x{EF}\x{BB}\x{BF}/', '', $code );
                            $tmpstyle = apply_filters( 'autoptimize_css_individual_style', $code, '' );
                            if ( has_filter( 'autoptimize_css_individual_style' ) &amp;&amp; ! empty( $tmpstyle ) ) {
                                $code                  = $tmpstyle;
                                $this-&gt;alreadyminified = true;
                            } elseif ( $this-&gt;can_inject_late( $path, $code ) ) {
                                $code = self::build_injectlater_marker( $path, md5( $code ) );
                            }

                            if ( ! empty( $code ) ) {
                                $tmp_thiscss = str_replace( $import, stripcslashes( $code ), $thiscss );
                                if ( ! empty( $tmp_thiscss ) ) {
                                    $thiscss   = $tmp_thiscss;
                                    $import_ok = true;
                                    unset( $tmp_thiscss );
                                }
                            }
                            unset( $code );
                        }
                    }
                    if ( ! $import_ok ) {
                        // External imports and general fall-back.
                        $external_imports .= $import;

                        $thiscss    = str_replace( $import, '', $thiscss );
                        $fiximports = true;
                    }
                }
                $thiscss = preg_replace( '#/\*FILESTART\*/#', '', $thiscss );
                $thiscss = preg_replace( '#/\*FILESTART2\*/#', '/*FILESTART*/', $thiscss );

                // and update $thiscss_nocomments before going into next iteration in while loop.
                $thiscss_nocomments = preg_replace( '#/\*.*\*/#Us', '', $thiscss );
            }
            unset( $thiscss_nocomments );

            // Add external imports to top of aggregated CSS.
            if ( $fiximports ) {
                $thiscss = $external_imports . $thiscss;
            }
        }
        unset( $thiscss );

        // $this-&gt;csscode has all the uncompressed code now.
        foreach ( $this-&gt;csscode as &amp;$code ) {
            // Check for already-minified code.
            $hash = md5( $code );
            do_action( 'autoptimize_action_css_hash', $hash );
            $ccheck = new autoptimizeCache( $hash, 'css' );
            if ( $ccheck-&gt;check() ) {
                $code                          = $ccheck-&gt;retrieve();
                $this-&gt;hashmap[ md5( $code ) ] = $hash;
                continue;
            }
            unset( $ccheck );

            // Rewrite and/or inline referenced assets.
            $code = $this-&gt;rewrite_assets( $code );

            // Minify.
            $code = $this-&gt;run_minifier_on( $code );

            // Bring back INJECTLATER stuff.
            $code = $this-&gt;inject_minified( $code );

            // Filter results.
            $tmp_code = apply_filters( 'autoptimize_css_after_minify', $code );
            if ( ! empty( $tmp_code ) ) {
                $code = $tmp_code;
                unset( $tmp_code );
            }

            $this-&gt;hashmap[ md5( $code ) ] = $hash;
        }

        unset( $code );
        return true;
    }

    public function run_minifier_on( $code )
    {
        if ( ! $this-&gt;alreadyminified ) {
            $do_minify = apply_filters( 'autoptimize_css_do_minify', true );

            if ( $do_minify ) {
                $cssmin   = new autoptimizeCSSmin();
                $tmp_code = trim( $cssmin-&gt;run( $code ) );

                if ( ! empty( $tmp_code ) ) {
                    $code = $tmp_code;
                    unset( $tmp_code );
                }
            }
        }

        return $code;
    }

    /**
     * Caches the CSS in uncompressed, deflated and gzipped form.
     */
    public function cache()
    {
        // CSS cache.
        foreach ( $this-&gt;csscode as $media =&gt; $code ) {
            if ( empty( $code ) ) {
                continue;
            }

            $md5   = $this-&gt;hashmap[ md5( $code ) ];
            $cache = new autoptimizeCache( $md5, 'css' );
            if ( ! $cache-&gt;check() ) {
                // Cache our code.
                $cache-&gt;cache( $code, 'text/css' );
            }
            $this-&gt;url[ $media ] = AUTOPTIMIZE_CACHE_URL . $cache-&gt;getname();
        }
    }

    /**
     * Returns the content.
     */
    public function getcontent()
    {
        // Restore the full content (only applies when &quot;autoptimize_filter_css_justhead&quot; filter is true).
        if ( ! empty( $this-&gt;restofcontent ) ) {
            $this-&gt;content      .= $this-&gt;restofcontent;
            $this-&gt;restofcontent = '';
        }

        // type is not added by default.
        $type_css = '';
        if ( apply_filters( 'autoptimize_filter_cssjs_addtype', false ) ) {
            $type_css = 'type=&quot;text/css&quot; ';
        }

        // Inject the new stylesheets, if possible after SEO stuff, but we need to
        // already restore script to be able to inject before ld+json instead of title
        // this should be safe here as all has been extracted  already but behind a filter anyway.
        if ( $this-&gt;inline &amp;&amp; true === apply_filters( 'autoptimize_filter_css_restore_js_early', true ) ) {
            $this-&gt;content = $this-&gt;restore_marked_content( 'SCRIPT', $this-&gt;content );
        }
        $_strpos_ldjson = strpos( $this-&gt;content, '&lt;script type=&quot;application/ld+json&quot;' );
        if ( false !== $_strpos_ldjson &amp;&amp; $_strpos_ldjson &lt; strpos( $this-&gt;content, '&lt;/head' ) ) {
            $replace_tag = array( '&lt;script type=&quot;application/ld+json&quot;', 'before' );            
        } else {
            $replace_tag = array( '&lt;title', 'before' );
        }
        $replace_tag = apply_filters( 'autoptimize_filter_css_replacetag', $replace_tag, $this-&gt;content );

        if ( $this-&gt;inline ) {
            foreach ( $this-&gt;csscode as $media =&gt; $code ) {
                $this-&gt;inject_in_html( apply_filters( 'autoptimize_filter_css_bodyreplacementpayload', '&lt;style ' . $type_css . 'media=&quot;' . $media . '&quot;&gt;' . $code . '&lt;/style&gt;' ), $replace_tag );
            }
        } else {
            if ( $this-&gt;defer ) {
                $preload_css_block  = '';
                $inlined_ccss_block = '';
                $noscript_css_block = '&lt;noscript id=&quot;aonoscrcss&quot;&gt;';

                $defer_inline_code = $this-&gt;defer_inline;
                if ( ! empty( $defer_inline_code ) ) {
                    if ( apply_filters( 'autoptimize_filter_css_critcss_minify', true ) ) {
                        $icss_hash  = md5( $defer_inline_code );
                        $icss_cache = new autoptimizeCache( $icss_hash, 'css' );
                        if ( $icss_cache-&gt;check() ) {
                            // we have the optimized inline CSS in cache.
                            $defer_inline_code = $icss_cache-&gt;retrieve();
                        } else {
                            $cssmin   = new autoptimizeCSSmin();
                            $tmp_code = trim( $cssmin-&gt;run( $defer_inline_code ) );

                            if ( ! empty( $tmp_code ) ) {
                                $defer_inline_code = $tmp_code;
                                $icss_cache-&gt;cache( $defer_inline_code, 'text/css' );
                                unset( $tmp_code );
                            }
                        }
                    }
                    // inlined critical css set here, but injected when full CSS is injected
                    // to avoid CSS containing SVG with &lt;title tag receiving the full CSS link.
                    $inlined_ccss_block = '&lt;style ' . $type_css . 'id=&quot;aoatfcss&quot; media=&quot;all&quot;&gt;' . $defer_inline_code . '&lt;/style&gt;';
                }
            }

            foreach ( $this-&gt;url as $media =&gt; $url ) {
                $url = $this-&gt;url_replace_cdn( $url );

                // Add the stylesheet either deferred (import at bottom) or normal links in head.
                if ( $this-&gt;defer &amp;&amp; 'print' !== $media ) {
                    $preload_onload = autoptimizeConfig::get_ao_css_preload_onload( $media );

                    $preload_css_block .= apply_filters( 'autoptimize_filter_css_single_deferred_link', '&lt;link rel=&quot;stylesheet&quot; media=&quot;print&quot; href=&quot;' . $url . '&quot; onload=&quot;' . $preload_onload . '&quot;&gt;' );
                    if ( apply_filters( 'autoptimize_fitler_css_preload_and_print', false ) ) {
                        $preload_css_block = '&lt;link rel=&quot;preload&quot; as=&quot;stylesheet&quot; href=&quot;' . $url . '&quot;/&gt;' . $preload_css_block;
                    }
                    $noscript_css_block .= '&lt;link ' . $type_css . 'media=&quot;' . $media . '&quot; href=&quot;' . $url . '&quot; rel=&quot;stylesheet&quot;&gt;';
                } else {
                    if ( strlen( $this-&gt;csscode[ $media ] ) &gt; $this-&gt;cssinlinesize ) {
                        $this-&gt;inject_in_html( apply_filters( 'autoptimize_filter_css_bodyreplacementpayload', '&lt;link ' . $type_css . 'media=&quot;' . $media . '&quot; href=&quot;' . $url . '&quot; rel=&quot;stylesheet&quot;&gt;' ), $replace_tag );
                    } elseif ( strlen( $this-&gt;csscode[ $media ] ) &gt; 0 ) {
                        $this-&gt;inject_in_html( apply_filters( 'autoptimize_filter_css_bodyreplacementpayload', '&lt;style ' . $type_css . 'media=&quot;' . $media . '&quot;&gt;' . $this-&gt;csscode[ $media ] . '&lt;/style&gt;' ), $replace_tag );
                    }
                }
            }

            if ( $this-&gt;defer ) {
                $noscript_css_block .= '&lt;/noscript&gt;';
                // Inject inline critical CSS, the preloaded full CSS and the noscript-CSS.
                $this-&gt;inject_in_html( apply_filters( 'autoptimize_filter_css_bodyreplacementpayload', $inlined_ccss_block . $preload_css_block . $noscript_css_block ), $replace_tag );
            }
        }

        // restore comments.
        $this-&gt;content = $this-&gt;restore_comments( $this-&gt;content );

        // restore IE hacks.
        $this-&gt;content = $this-&gt;restore_iehacks( $this-&gt;content );

        // restore (no)script.
        $this-&gt;content = $this-&gt;restore_marked_content( 'SCRIPT', $this-&gt;content );

        // Restore noptimize.
        $this-&gt;content = $this-&gt;restore_noptimize( $this-&gt;content );

        // Return the modified stylesheet.
        return $this-&gt;content;
    }

    /**
     * Make sure URL's are absolute iso relative to original CSS location.
     *
     * @param string $file filename of optimized CSS-file.
     * @param string $code CSS-code in which to fix URL's.
     */
    static function fixurls( $file, $code )
    {
        // Switch all imports to the url() syntax.
        $code = preg_replace( '#@import (&quot;|\')(.+?)\.css.*?(&quot;|\')#', '@import url(&quot;${2}.css&quot;)', $code );

        if ( preg_match_all( self::ASSETS_REGEX, $code, $matches ) ) {
            $file = str_replace( WP_ROOT_DIR, '/', $file );
            /**
             * Rollback as per https://github.com/futtta/autoptimize/issues/94
             * $file = str_replace( AUTOPTIMIZE_WP_CONTENT_NAME, '', $file );
             */
            $dir = dirname( $file ); // Like /themes/expound/css.

            /**
             * $dir should not contain backslashes, since it's used to replace
             * urls, but it can contain them when running on Windows because
             * fixurls() is sometimes called with `ABSPATH . 'index.php'`
             */
            $dir = str_replace( '\\', '/', $dir );
            unset( $file ); // not used below at all.

            $replace = array();
            foreach ( $matches[1] as $k =&gt; $url ) {
                // Remove quotes.
                $url      = trim( $url, &quot; \t\n\r\0\x0B\&quot;'&quot; );
                $no_q_url = trim( $url, &quot;\&quot;'&quot; );
                if ( $url !== $no_q_url ) {
                    $removed_quotes = true;
                } else {
                    $removed_quotes = false;
                }

                if ( '' === $no_q_url ) {
                    continue;
                }

                $url = $no_q_url;
                if ( '/' === $url[0] || preg_match( '#^(https?://|ftp://|data:)#i', $url ) ) {
                    // URL is protocol-relative, host-relative or something we don't touch.
                    continue;
                } else { // Relative URL.

                    /*
                     * rollback as per https://github.com/futtta/autoptimize/issues/94
                     * $newurl = preg_replace( '/https?:/', '', str_replace( ' ', '%20', AUTOPTIMIZE_WP_CONTENT_URL . str_replace( '//', '/', $dir . '/' . $url ) ) );
                     */
                    $newurl = preg_replace( '/https?:/', '', str_replace( ' ', '%20', AUTOPTIMIZE_WP_ROOT_URL . str_replace( '//', '/', $dir . '/' . $url ) ) );
                    $newurl = apply_filters( 'autoptimize_filter_css_fixurl_newurl', $newurl );

                    /**
                     * Hash the url + whatever was behind potentially for replacement
                     * We must do this, or different css classes referencing the same bg image (but
                     * different parts of it, say, in sprites and such) loose their stuff...
                     */
                    $hash = md5( $url . $matches[2][ $k ] );
                    $code = str_replace( $matches[0][ $k ], $hash, $code );

                    if ( $removed_quotes ) {
                        $replace[ $hash ] = &quot;url('&quot; . $newurl . &quot;')&quot; . $matches[2][ $k ];
                    } else {
                        $replace[ $hash ] = 'url(' . $newurl . ')' . $matches[2][ $k ];
                    }
                }
            }

            $code = self::replace_longest_matches_first( $code, $replace );
        }

        return $code;
    }

    private function ismovable( $tag )
    {
        if ( ! $this-&gt;aggregate ) {
            return false;
        }

        if ( ! empty( $this-&gt;allowlist ) ) {
            foreach ( $this-&gt;allowlist as $match ) {
                if ( false !== strpos( $tag, $match ) ) {
                    return true;
                }
            }
            // no match with allowlist.
            return false;
        } else {
            if ( is_array( $this-&gt;dontmove ) &amp;&amp; ! empty( $this-&gt;dontmove ) ) {
                foreach ( $this-&gt;dontmove as $match ) {
                    if ( false !== strpos( $tag, $match ) ) {
                        // Matched something.
                        return false;
                    }
                }
            }

            // If we're here it's safe to move.
            return true;
        }
    }

    private function can_inject_late( $css_path, $css )
    {
        $consider_minified_array = apply_filters( 'autoptimize_filter_css_consider_minified', false, $css_path );
        if ( true !== $this-&gt;inject_min_late ) {
            // late-inject turned off.
            return false;
        } elseif ( ( false === strpos( $css_path, 'min.css' ) ) &amp;&amp; ( str_replace( $consider_minified_array, '', $css_path ) === $css_path ) ) {
            // file not minified based on filename &amp; filter.
            return false;
        } elseif ( false !== strpos( $css, '@import' ) ) {
            // can't late-inject files with imports as those need to be aggregated.
            return false;
        } elseif ( ( false !== strpos( $css, '@font-face' ) ) &amp;&amp; ( apply_filters( 'autoptimize_filter_css_fonts_cdn', false ) === true ) &amp;&amp; ( ! empty( $this-&gt;cdn_url ) ) ) {
            // don't late-inject CSS with font-src's if fonts are set to be CDN'ed.
            return false;
        } elseif ( ( ( true == $this-&gt;datauris ) || ( ! empty( $this-&gt;cdn_url ) ) ) &amp;&amp; preg_match( '#background[^;}]*url\(#Ui', $css ) ) {
            // don't late-inject CSS with images if CDN is set OR if image inlining is on.
            return false;
        } else {
            // phew, all is safe, we can late-inject.
            return true;
        }
    }

    /**
     * Minifies (and cdn-replaces) a single local css file
     * and returns its (cached) url.
     *
     * @param string $filepath Filepath.
     * @param bool   $cache_miss Optional. Force a cache miss. Default false.
     *
     * @return bool|string Url pointing to the minified css file or false.
     */
    public function minify_single( $filepath, $cache_miss = false )
    {
        $contents = $this-&gt;prepare_minify_single( $filepath );

        if ( empty( $contents ) ) {
            // if aggregate is off and CCSS is used but all files are minified already, then we
            // must make sure the autoptimize_action_css_hash action still fires for CCSS's sake.
            $ao_ccss_key = get_option( 'autoptimize_ccss_key', '' );
            if ( false === $this-&gt;aggregate &amp;&amp; isset( $ao_ccss_key ) &amp;&amp; ! empty( $ao_ccss_key ) ) {
                $hash = 'single_' . md5( file_get_contents( $filepath ) );
                do_action( 'autoptimize_action_css_hash', $hash );
            }
            return false;
        }

        // Check cache.
        $hash  = 'single_' . md5( $contents );
        $cache = new autoptimizeCache( $hash, 'css' );
        do_action( 'autoptimize_action_css_hash', $hash );

        // If not in cache already, minify...
        if ( ! $cache-&gt;check() || $cache_miss ) {
            // Fixurls...
            $contents = self::fixurls( $filepath, $contents );
            // CDN-replace any referenced assets if needed...
            $contents = $this-&gt;hide_fontface_and_maybe_cdn( $contents );
            $contents = $this-&gt;replace_urls( $contents );
            $contents = $this-&gt;restore_fontface( $contents );
            // Now minify...
            $cssmin   = new autoptimizeCSSmin();
            $contents = trim( $cssmin-&gt;run( $contents ) );

            // Check if minified cache content is empty.
            if ( empty( $contents ) ) {
                return false;
            }

            // Filter contents of excluded minified CSS.
            $contents = apply_filters( 'autoptimize_filter_css_single_after_minify', $contents );

            // Store in cache.
            $cache-&gt;cache( $contents, 'text/css' );
        }

        $url = $this-&gt;build_minify_single_url( $cache );

        return $url;
    }

    /**
     * Returns whether we're doing aggregation or not.
     *
     * @return bool
     */
    public function aggregating()
    {
        return $this-&gt;aggregate;
    }

    public function getOptions()
    {
        return $this-&gt;options;
    }

    public function replaceOptions( $options )
    {
        $this-&gt;options = $options;
    }

    public function setOption( $name, $value )
    {
        $this-&gt;options[ $name ] = $value;
        $this-&gt;$name            = $value;
    }

    public function getOption( $name )
    {
        return $this-&gt;options[ $name ];
    }

    /**
     * Sanitize user-provided CSS.
     *
     * For now just strip_tags (the WordPress way) and preg_replace to escape &lt; in certain cases but might do full CSS escaping in the future, see:
     * https://cheatsheetseries.owasp.org/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html#rule-4-css-encode-and-strictly-validate-before-inserting-untrusted-data-into-html-style-property-values
     * https://github.com/twigphp/Twig/blob/3.x/src/Extension/EscaperExtension.php#L300-L319
     * https://github.com/laminas/laminas-escaper/blob/2.8.x/src/Escaper.php#L205-L221
     *
     * @param string $css the to be sanitized CSS.
     * @return string sanitized CSS.
     */
    public static function sanitize_css( $css )
    {
        $css = wp_strip_all_tags( $css );
        if ( strpos( $css, '&lt;' ) !== false ) {
            $css = preg_replace( '#&lt;(\/?\w+)#', '\00003C$1', $css );
        }
        return $css;
    }
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250804013034%2Fplugins%2Fautoptimize%2Fclasses'>🔙 Back</a>