<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: CssCompressor.java</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>/*
 * YUI Compressor
 * http://developer.yahoo.com/yui/compressor/
 * Author: Julien Lecomte -  http://www.julienlecomte.net/
 * Author: Isaac Schlueter - http://foohack.com/
 * Author: Stoyan Stefanov - http://phpied.com/
 * Copyright (c) 2011 Yahoo! Inc.  All rights reserved.
 * The copyrights embodied in the content of this file are licensed
 * by Yahoo! Inc. under the BSD (revised) open source license.
 */
package com.yahoo.platform.yui.compressor;

import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.ArrayList;

public class CssCompressor {

    private StringBuffer srcsb = new StringBuffer();

    public CssCompressor(Reader in) throws IOException {
        // Read the stream...
        int c;
        while ((c = in.read()) != -1) {
            srcsb.append((char) c);
        }
    }

    // Leave data urls alone to increase parse performance.
    protected String extractDataUrls(String css, ArrayList preservedTokens) {

    	int maxIndex = css.length() - 1;
        int appendIndex = 0;

    	StringBuffer sb = new StringBuffer();

        Pattern p = Pattern.compile(&quot;url\\(\\s*([\&quot;']?)data\\:&quot;);
        Matcher m = p.matcher(css);
        
        /* 
         * Since we need to account for non-base64 data urls, we need to handle 
         * ' and ) being part of the data string. Hence switching to indexOf,
         * to determine whether or not we have matching string terminators and
         * handling sb appends directly, instead of using matcher.append* methods.
         */

        while (m.find()) {

        	int startIndex = m.start() + 4;  	// &quot;url(&quot;.length()
    		String terminator = m.group(1);     // ', &quot; or empty (not quoted)
    		
    		if (terminator.length() == 0) {
    		 	terminator = &quot;)&quot;;
    		}

    		boolean foundTerminator = false;

    		int endIndex = m.end() - 1;
    		while(foundTerminator == false &amp;&amp; endIndex+1 &lt;= maxIndex) {
    			endIndex = css.indexOf(terminator, endIndex+1);

    			if ((endIndex &gt; 0) &amp;&amp; (css.charAt(endIndex-1) != '\\')) {
    				foundTerminator = true;
    				if (!&quot;)&quot;.equals(terminator)) {
    					endIndex = css.indexOf(&quot;)&quot;, endIndex); 
    				}
    			}
    		}

    		// Enough searching, start moving stuff over to the buffer
			sb.append(css.substring(appendIndex, m.start()));

    		if (foundTerminator) {
    			String token = css.substring(startIndex, endIndex);
    			token = token.replaceAll(&quot;\\s+&quot;, &quot;&quot;);
	    		preservedTokens.add(token);

	    		String preserver = &quot;url(___YUICSSMIN_PRESERVED_TOKEN_&quot; + (preservedTokens.size() - 1) + &quot;___)&quot;;
	    		sb.append(preserver);

	    		appendIndex = endIndex + 1;
    		} else {
    			// No end terminator found, re-add the whole match. Should we throw/warn here?
    			sb.append(css.substring(m.start(), m.end()));
    			appendIndex = m.end();
    		}
        }

        sb.append(css.substring(appendIndex));

        return sb.toString();
    }

    public void compress(Writer out, int linebreakpos)
            throws IOException {

        Pattern p;
        Matcher m;
        String css = srcsb.toString();

        int startIndex = 0;
        int endIndex = 0;
        int i = 0;
        int max = 0;
        ArrayList preservedTokens = new ArrayList(0);
        ArrayList comments = new ArrayList(0);
        String token;
        int totallen = css.length();
        String placeholder;

        css = this.extractDataUrls(css, preservedTokens);

        StringBuffer sb = new StringBuffer(css);

        // collect all comment blocks...
        while ((startIndex = sb.indexOf(&quot;/*&quot;, startIndex)) &gt;= 0) {
            endIndex = sb.indexOf(&quot;*/&quot;, startIndex + 2);
            if (endIndex &lt; 0) {
                endIndex = totallen;
            }

            token = sb.substring(startIndex + 2, endIndex);
            comments.add(token);
            sb.replace(startIndex + 2, endIndex, &quot;___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_&quot; + (comments.size() - 1) + &quot;___&quot;);
            startIndex += 2;
        }
        css = sb.toString();

        // preserve strings so their content doesn't get accidentally minified
        sb = new StringBuffer();
        p = Pattern.compile(&quot;(\&quot;([^\\\\\&quot;]|\\\\.|\\\\)*\&quot;)|(\'([^\\\\\']|\\\\.|\\\\)*\')&quot;);
        m = p.matcher(css);
        while (m.find()) {
            token = m.group();
            char quote = token.charAt(0);
            token = token.substring(1, token.length() - 1);

            // maybe the string contains a comment-like substring?
            // one, maybe more? put'em back then
            if (token.indexOf(&quot;___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_&quot;) &gt;= 0) {
                for (i = 0, max = comments.size(); i &lt; max; i += 1) {
                    token = token.replace(&quot;___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_&quot; + i + &quot;___&quot;, comments.get(i).toString());
                }
            }

            // minify alpha opacity in filter strings
            token = token.replaceAll(&quot;(?i)progid:DXImageTransform.Microsoft.Alpha\\(Opacity=&quot;, &quot;alpha(opacity=&quot;);

            preservedTokens.add(token);
            String preserver = quote + &quot;___YUICSSMIN_PRESERVED_TOKEN_&quot; + (preservedTokens.size() - 1) + &quot;___&quot; + quote;
            m.appendReplacement(sb, preserver);
        }
        m.appendTail(sb);
        css = sb.toString();


        // strings are safe, now wrestle the comments
        for (i = 0, max = comments.size(); i &lt; max; i += 1) {

            token = comments.get(i).toString();
            placeholder = &quot;___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_&quot; + i + &quot;___&quot;;

            // ! in the first position of the comment means preserve
            // so push to the preserved tokens while stripping the !
            if (token.startsWith(&quot;!&quot;)) {
                preservedTokens.add(token);
                css = css.replace(placeholder,  &quot;___YUICSSMIN_PRESERVED_TOKEN_&quot; + (preservedTokens.size() - 1) + &quot;___&quot;);
                continue;
            }

            // \ in the last position looks like hack for Mac/IE5
            // shorten that to /*\*/ and the next one to /**/
            if (token.endsWith(&quot;\\&quot;)) {
                preservedTokens.add(&quot;\\&quot;);
                css = css.replace(placeholder,  &quot;___YUICSSMIN_PRESERVED_TOKEN_&quot; + (preservedTokens.size() - 1) + &quot;___&quot;);
                i = i + 1; // attn: advancing the loop
                preservedTokens.add(&quot;&quot;);
                css = css.replace(&quot;___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_&quot; + i + &quot;___&quot;,  &quot;___YUICSSMIN_PRESERVED_TOKEN_&quot; + (preservedTokens.size() - 1) + &quot;___&quot;);
                continue;
            }

            // keep empty comments after child selectors (IE7 hack)
            // e.g. html &gt;/**/ body
            if (token.length() == 0) {
                startIndex = css.indexOf(placeholder);
                if (startIndex &gt; 2) {
                    if (css.charAt(startIndex - 3) == '&gt;') {
                        preservedTokens.add(&quot;&quot;);
                        css = css.replace(placeholder,  &quot;___YUICSSMIN_PRESERVED_TOKEN_&quot; + (preservedTokens.size() - 1) + &quot;___&quot;);
                    }
                }
            }

            // in all other cases kill the comment
            css = css.replace(&quot;/*&quot; + placeholder + &quot;*/&quot;, &quot;&quot;);
        }


        // Normalize all whitespace strings to single spaces. Easier to work with that way.
        css = css.replaceAll(&quot;\\s+&quot;, &quot; &quot;);

        // Remove the spaces before the things that should not have spaces before them.
        // But, be careful not to turn &quot;p :link {...}&quot; into &quot;p:link{...}&quot;
        // Swap out any pseudo-class colons with the token, and then swap back.
        sb = new StringBuffer();
        p = Pattern.compile(&quot;(^|\\})(([^\\{:])+:)+([^\\{]*\\{)&quot;);
        m = p.matcher(css);
        while (m.find()) {
            String s = m.group();
            s = s.replaceAll(&quot;:&quot;, &quot;___YUICSSMIN_PSEUDOCLASSCOLON___&quot;);
            s = s.replaceAll( &quot;\\\\&quot;, &quot;\\\\\\\\&quot; ).replaceAll( &quot;\\$&quot;, &quot;\\\\\\$&quot; );
            m.appendReplacement(sb, s);
        }
        m.appendTail(sb);
        css = sb.toString();
        // Remove spaces before the things that should not have spaces before them.
        css = css.replaceAll(&quot;\\s+([!{};:&gt;+\\(\\)\\],])&quot;, &quot;$1&quot;);
        // bring back the colon
        css = css.replaceAll(&quot;___YUICSSMIN_PSEUDOCLASSCOLON___&quot;, &quot;:&quot;);

        // retain space for special IE6 cases
        css = css.replaceAll(&quot;:first\\-(line|letter)(\\{|,)&quot;, &quot;:first-$1 $2&quot;);

        // no space after the end of a preserved comment
        css = css.replaceAll(&quot;\\*/ &quot;, &quot;*/&quot;);

        // If there is a @charset, then only allow one, and push to the top of the file.
        css = css.replaceAll(&quot;^(.*)(@charset \&quot;[^\&quot;]*\&quot;;)&quot;, &quot;$2$1&quot;);
        css = css.replaceAll(&quot;^(\\s*@charset [^;]+;\\s*)+&quot;, &quot;$1&quot;);

        // Put the space back in some cases, to support stuff like
        // @media screen and (-webkit-min-device-pixel-ratio:0){
        css = css.replaceAll(&quot;\\band\\(&quot;, &quot;and (&quot;);

        // Remove the spaces after the things that should not have spaces after them.
        css = css.replaceAll(&quot;([!{}:;&gt;+\\(\\[,])\\s+&quot;, &quot;$1&quot;);

        // remove unnecessary semicolons
        css = css.replaceAll(&quot;;+}&quot;, &quot;}&quot;);

        // Replace 0(px,em,%) with 0.
        css = css.replaceAll(&quot;([\\s:])(0)(px|em|%|in|cm|mm|pc|pt|ex)&quot;, &quot;$1$2&quot;);

        // Replace 0 0 0 0; with 0.
        css = css.replaceAll(&quot;:0 0 0 0(;|})&quot;, &quot;:0$1&quot;);
        css = css.replaceAll(&quot;:0 0 0(;|})&quot;, &quot;:0$1&quot;);
        css = css.replaceAll(&quot;:0 0(;|})&quot;, &quot;:0$1&quot;);


        // Replace background-position:0; with background-position:0 0;
        // same for transform-origin
        sb = new StringBuffer();
        p = Pattern.compile(&quot;(?i)(background-position|transform-origin|webkit-transform-origin|moz-transform-origin|o-transform-origin|ms-transform-origin):0(;|})&quot;);
        m = p.matcher(css);
        while (m.find()) {
            m.appendReplacement(sb, m.group(1).toLowerCase() + &quot;:0 0&quot; + m.group(2));
        }
        m.appendTail(sb);
        css = sb.toString();

        // Replace 0.6 to .6, but only when preceded by : or a white-space
        css = css.replaceAll(&quot;(:|\\s)0+\\.(\\d+)&quot;, &quot;$1.$2&quot;);

        // Shorten colors from rgb(51,102,153) to #336699
        // This makes it more likely that it'll get further compressed in the next step.
        p = Pattern.compile(&quot;rgb\\s*\\(\\s*([0-9,\\s]+)\\s*\\)&quot;);
        m = p.matcher(css);
        sb = new StringBuffer();
        while (m.find()) {
            String[] rgbcolors = m.group(1).split(&quot;,&quot;);
            StringBuffer hexcolor = new StringBuffer(&quot;#&quot;);
            for (i = 0; i &lt; rgbcolors.length; i++) {
                int val = Integer.parseInt(rgbcolors[i]);
                if (val &lt; 16) {
                    hexcolor.append(&quot;0&quot;);
                }
                hexcolor.append(Integer.toHexString(val));
            }
            m.appendReplacement(sb, hexcolor.toString());
        }
        m.appendTail(sb);
        css = sb.toString();

        // Shorten colors from #AABBCC to #ABC. Note that we want to make sure
        // the color is not preceded by either &quot;, &quot; or =. Indeed, the property
        //     filter: chroma(color=&quot;#FFFFFF&quot;);
        // would become
        //     filter: chroma(color=&quot;#FFF&quot;);
        // which makes the filter break in IE.
        // We also want to make sure we're only compressing #AABBCC patterns inside { }, not id selectors ( #FAABAC {} )
        // We also want to avoid compressing invalid values (e.g. #AABBCCD to #ABCD)
        p = Pattern.compile(&quot;(\\=\\s*?[\&quot;']?)?&quot; + &quot;#([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])&quot; + &quot;(:?\\}|[^0-9a-fA-F{][^{]*?\\})&quot;);

        m = p.matcher(css);
        sb = new StringBuffer();
        int index = 0;

        while (m.find(index)) {

        	sb.append(css.substring(index, m.start()));

        	boolean isFilter = (m.group(1) != null &amp;&amp; !&quot;&quot;.equals(m.group(1))); 

        	if (isFilter) {
        		// Restore, as is. Compression will break filters
        		sb.append(m.group(1) + &quot;#&quot; + m.group(2) + m.group(3) + m.group(4) + m.group(5) + m.group(6) + m.group(7));
        	} else {
        		if( m.group(2).equalsIgnoreCase(m.group(3)) &amp;&amp;
                    m.group(4).equalsIgnoreCase(m.group(5)) &amp;&amp;
                    m.group(6).equalsIgnoreCase(m.group(7))) {

	        		// #AABBCC pattern
	                sb.append(&quot;#&quot; + (m.group(3) + m.group(5) + m.group(7)).toLowerCase());

        		} else {

        			// Non-compressible color, restore, but lower case.
        			sb.append(&quot;#&quot; + (m.group(2) + m.group(3) + m.group(4) + m.group(5) + m.group(6) + m.group(7)).toLowerCase());
        		}
            }

        	index = m.end(7);
        }

        sb.append(css.substring(index));
        css = sb.toString();

        // border: none -&gt; border:0
        sb = new StringBuffer();
        p = Pattern.compile(&quot;(?i)(border|border-top|border-right|border-bottom|border-right|outline|background):none(;|})&quot;);
        m = p.matcher(css);
        while (m.find()) {
            m.appendReplacement(sb, m.group(1).toLowerCase() + &quot;:0&quot; + m.group(2));
        }
        m.appendTail(sb);
        css = sb.toString();

        // shorter opacity IE filter
        css = css.replaceAll(&quot;(?i)progid:DXImageTransform.Microsoft.Alpha\\(Opacity=&quot;, &quot;alpha(opacity=&quot;);

        // Remove empty rules.
        css = css.replaceAll(&quot;[^\\}\\{/;]+\\{\\}&quot;, &quot;&quot;);

        // TODO: Should this be after we re-insert tokens. These could alter the break points. However then
        // we'd need to make sure we don't break in the middle of a string etc.
        if (linebreakpos &gt;= 0) {
            // Some source control tools don't like it when files containing lines longer
            // than, say 8000 characters, are checked in. The linebreak option is used in
            // that case to split long lines after a specific column.
            i = 0;
            int linestartpos = 0;
            sb = new StringBuffer(css);
            while (i &lt; sb.length()) {
                char c = sb.charAt(i++);
                if (c == '}' &amp;&amp; i - linestartpos &gt; linebreakpos) {
                    sb.insert(i, '\n');
                    linestartpos = i;
                }
            }

            css = sb.toString();
        }

        // Replace multiple semi-colons in a row by a single one
        // See SF bug #1980989
        css = css.replaceAll(&quot;;;+&quot;, &quot;;&quot;);

        // restore preserved comments and strings
        for(i = 0, max = preservedTokens.size(); i &lt; max; i++) {
            css = css.replace(&quot;___YUICSSMIN_PRESERVED_TOKEN_&quot; + i + &quot;___&quot;, preservedTokens.get(i).toString());
        }

        // Trim the final string (for any leading or trailing white spaces)
        css = css.trim();

        // Write the output...
        out.write(css);
    }
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250804013034%2Fplugins%2Fw3-total-cache%2Flib%2FMinify%2FMinify%2FYUI'>🔙 Back</a>