ec96ebc8a4fbc67028e1873238b2c488373507e8
[moodle.git] / lib / minify / matthiasmullie-minify / src / CSS.php
1 <?php
3 namespace MatthiasMullie\Minify;
5 use MatthiasMullie\Minify\Exceptions\FileImportException;
6 use MatthiasMullie\PathConverter\ConverterInterface;
7 use MatthiasMullie\PathConverter\Converter;
9 /**
10  * CSS minifier.
11  *
12  * Please report bugs on https://github.com/matthiasmullie/minify/issues
13  *
14  * @author Matthias Mullie <minify@mullie.eu>
15  * @author Tijs Verkoyen <minify@verkoyen.eu>
16  * @copyright Copyright (c) 2012, Matthias Mullie. All rights reserved
17  * @license MIT License
18  */
19 class CSS extends Minify
20 {
21     /**
22      * @var int
23      */
24     protected $maxImportSize = 5;
26     /**
27      * @var string[]
28      */
29     protected $importExtensions = array(
30         'gif' => 'data:image/gif',
31         'png' => 'data:image/png',
32         'jpe' => 'data:image/jpeg',
33         'jpg' => 'data:image/jpeg',
34         'jpeg' => 'data:image/jpeg',
35         'svg' => 'data:image/svg+xml',
36         'woff' => 'data:application/x-font-woff',
37         'tif' => 'image/tiff',
38         'tiff' => 'image/tiff',
39         'xbm' => 'image/x-xbitmap',
40     );
42     /**
43      * Set the maximum size if files to be imported.
44      *
45      * Files larger than this size (in kB) will not be imported into the CSS.
46      * Importing files into the CSS as data-uri will save you some connections,
47      * but we should only import relatively small decorative images so that our
48      * CSS file doesn't get too bulky.
49      *
50      * @param int $size Size in kB
51      */
52     public function setMaxImportSize($size)
53     {
54         $this->maxImportSize = $size;
55     }
57     /**
58      * Set the type of extensions to be imported into the CSS (to save network
59      * connections).
60      * Keys of the array should be the file extensions & respective values
61      * should be the data type.
62      *
63      * @param string[] $extensions Array of file extensions
64      */
65     public function setImportExtensions(array $extensions)
66     {
67         $this->importExtensions = $extensions;
68     }
70     /**
71      * Move any import statements to the top.
72      *
73      * @param string $content Nearly finished CSS content
74      *
75      * @return string
76      */
77     protected function moveImportsToTop($content)
78     {
79         if (preg_match_all('/@import[^;]+;/', $content, $matches)) {
80             // remove from content
81             foreach ($matches[0] as $import) {
82                 $content = str_replace($import, '', $content);
83             }
85             // add to top
86             $content = implode('', $matches[0]).$content;
87         }
89         return $content;
90     }
92     /**
93      * Combine CSS from import statements.
94      *
95      * @import's will be loaded and their content merged into the original file,
96      * to save HTTP requests.
97      *
98      * @param string   $source  The file to combine imports for
99      * @param string   $content The CSS content to combine imports for
100      * @param string[] $parents Parent paths, for circular reference checks
101      *
102      * @return string
103      *
104      * @throws FileImportException
105      */
106     protected function combineImports($source, $content, $parents)
107     {
108         $importRegexes = array(
109             // @import url(xxx)
110             '/
111             # import statement
112             @import
114             # whitespace
115             \s+
117                 # open url()
118                 url\(
120                     # (optional) open path enclosure
121                     (?P<quotes>["\']?)
123                         # fetch path
124                         (?P<path>.+?)
126                     # (optional) close path enclosure
127                     (?P=quotes)
129                 # close url()
130                 \)
132                 # (optional) trailing whitespace
133                 \s*
135                 # (optional) media statement(s)
136                 (?P<media>[^;]*)
138                 # (optional) trailing whitespace
139                 \s*
141             # (optional) closing semi-colon
142             ;?
144             /ix',
146             // @import 'xxx'
147             '/
149             # import statement
150             @import
152             # whitespace
153             \s+
155                 # open path enclosure
156                 (?P<quotes>["\'])
158                     # fetch path
159                     (?P<path>.+?)
161                 # close path enclosure
162                 (?P=quotes)
164                 # (optional) trailing whitespace
165                 \s*
167                 # (optional) media statement(s)
168                 (?P<media>[^;]*)
170                 # (optional) trailing whitespace
171                 \s*
173             # (optional) closing semi-colon
174             ;?
176             /ix',
177         );
179         // find all relative imports in css
180         $matches = array();
181         foreach ($importRegexes as $importRegex) {
182             if (preg_match_all($importRegex, $content, $regexMatches, PREG_SET_ORDER)) {
183                 $matches = array_merge($matches, $regexMatches);
184             }
185         }
187         $search = array();
188         $replace = array();
190         // loop the matches
191         foreach ($matches as $match) {
192             // get the path for the file that will be imported
193             $importPath = dirname($source).'/'.$match['path'];
195             // only replace the import with the content if we can grab the
196             // content of the file
197             if (!$this->canImportByPath($match['path']) || !$this->canImportFile($importPath)) {
198                 continue;
199             }
201             // check if current file was not imported previously in the same
202             // import chain.
203             if (in_array($importPath, $parents)) {
204                 throw new FileImportException('Failed to import file "'.$importPath.'": circular reference detected.');
205             }
207             // grab referenced file & minify it (which may include importing
208             // yet other @import statements recursively)
209             $minifier = new static($importPath);
210             $importContent = $minifier->execute($source, $parents);
212             // check if this is only valid for certain media
213             if (!empty($match['media'])) {
214                 $importContent = '@media '.$match['media'].'{'.$importContent.'}';
215             }
217             // add to replacement array
218             $search[] = $match[0];
219             $replace[] = $importContent;
220         }
222         // replace the import statements
223         return str_replace($search, $replace, $content);
224     }
226     /**
227      * Import files into the CSS, base64-ized.
228      *
229      * @url(image.jpg) images will be loaded and their content merged into the
230      * original file, to save HTTP requests.
231      *
232      * @param string $source  The file to import files for
233      * @param string $content The CSS content to import files for
234      *
235      * @return string
236      */
237     protected function importFiles($source, $content)
238     {
239         $regex = '/url\((["\']?)(.+?)\\1\)/i';
240         if ($this->importExtensions && preg_match_all($regex, $content, $matches, PREG_SET_ORDER)) {
241             $search = array();
242             $replace = array();
244             // loop the matches
245             foreach ($matches as $match) {
246                 $extension = substr(strrchr($match[2], '.'), 1);
247                 if ($extension && !array_key_exists($extension, $this->importExtensions)) {
248                     continue;
249                 }
251                 // get the path for the file that will be imported
252                 $path = $match[2];
253                 $path = dirname($source).'/'.$path;
255                 // only replace the import with the content if we're able to get
256                 // the content of the file, and it's relatively small
257                 if ($this->canImportFile($path) && $this->canImportBySize($path)) {
258                     // grab content && base64-ize
259                     $importContent = $this->load($path);
260                     $importContent = base64_encode($importContent);
262                     // build replacement
263                     $search[] = $match[0];
264                     $replace[] = 'url('.$this->importExtensions[$extension].';base64,'.$importContent.')';
265                 }
266             }
268             // replace the import statements
269             $content = str_replace($search, $replace, $content);
270         }
272         return $content;
273     }
275     /**
276      * Minify the data.
277      * Perform CSS optimizations.
278      *
279      * @param string[optional] $path    Path to write the data to
280      * @param string[]         $parents Parent paths, for circular reference checks
281      *
282      * @return string The minified data
283      */
284     public function execute($path = null, $parents = array())
285     {
286         $content = '';
288         // loop CSS data (raw data and files)
289         foreach ($this->data as $source => $css) {
290             /*
291              * Let's first take out strings & comments, since we can't just
292              * remove whitespace anywhere. If whitespace occurs inside a string,
293              * we should leave it alone. E.g.:
294              * p { content: "a   test" }
295              */
296             $this->extractStrings();
297             $this->stripComments();
298             $css = $this->replace($css);
300             $css = $this->stripWhitespace($css);
301             $css = $this->shortenHex($css);
302             $css = $this->shortenZeroes($css);
303             $css = $this->shortenFontWeights($css);
304             $css = $this->stripEmptyTags($css);
306             // restore the string we've extracted earlier
307             $css = $this->restoreExtractedData($css);
309             $source = is_int($source) ? '' : $source;
310             $parents = $source ? array_merge($parents, array($source)) : $parents;
311             $css = $this->combineImports($source, $css, $parents);
312             $css = $this->importFiles($source, $css);
314             /*
315              * If we'll save to a new path, we'll have to fix the relative paths
316              * to be relative no longer to the source file, but to the new path.
317              * If we don't write to a file, fall back to same path so no
318              * conversion happens (because we still want it to go through most
319              * of the move code, which also addresses url() & @import syntax...)
320              */
321             $converter = $this->getPathConverter($source, $path ?: $source);
322             $css = $this->move($converter, $css);
324             // combine css
325             $content .= $css;
326         }
328         $content = $this->moveImportsToTop($content);
330         return $content;
331     }
333     /**
334      * Moving a css file should update all relative urls.
335      * Relative references (e.g. ../images/image.gif) in a certain css file,
336      * will have to be updated when a file is being saved at another location
337      * (e.g. ../../images/image.gif, if the new CSS file is 1 folder deeper).
338      *
339      * @param ConverterInterface $converter Relative path converter
340      * @param string             $content   The CSS content to update relative urls for
341      *
342      * @return string
343      */
344     protected function move(ConverterInterface $converter, $content)
345     {
346         /*
347          * Relative path references will usually be enclosed by url(). @import
348          * is an exception, where url() is not necessary around the path (but is
349          * allowed).
350          * This *could* be 1 regular expression, where both regular expressions
351          * in this array are on different sides of a |. But we're using named
352          * patterns in both regexes, the same name on both regexes. This is only
353          * possible with a (?J) modifier, but that only works after a fairly
354          * recent PCRE version. That's why I'm doing 2 separate regular
355          * expressions & combining the matches after executing of both.
356          */
357         $relativeRegexes = array(
358             // url(xxx)
359             '/
360             # open url()
361             url\(
363                 \s*
365                 # open path enclosure
366                 (?P<quotes>["\'])?
368                     # fetch path
369                     (?P<path>.+?)
371                 # close path enclosure
372                 (?(quotes)(?P=quotes))
374                 \s*
376             # close url()
377             \)
379             /ix',
381             // @import "xxx"
382             '/
383             # import statement
384             @import
386             # whitespace
387             \s+
389                 # we don\'t have to check for @import url(), because the
390                 # condition above will already catch these
392                 # open path enclosure
393                 (?P<quotes>["\'])
395                     # fetch path
396                     (?P<path>.+?)
398                 # close path enclosure
399                 (?P=quotes)
401             /ix',
402         );
404         // find all relative urls in css
405         $matches = array();
406         foreach ($relativeRegexes as $relativeRegex) {
407             if (preg_match_all($relativeRegex, $content, $regexMatches, PREG_SET_ORDER)) {
408                 $matches = array_merge($matches, $regexMatches);
409             }
410         }
412         $search = array();
413         $replace = array();
415         // loop all urls
416         foreach ($matches as $match) {
417             // determine if it's a url() or an @import match
418             $type = (strpos($match[0], '@import') === 0 ? 'import' : 'url');
420             $url = $match['path'];
421             if ($this->canImportByPath($url)) {
422                 // attempting to interpret GET-params makes no sense, so let's discard them for awhile
423                 $params = strrchr($url, '?');
424                 $url = $params ? substr($url, 0, -strlen($params)) : $url;
426                 // fix relative url
427                 $url = $converter->convert($url);
429                 // now that the path has been converted, re-apply GET-params
430                 $url .= $params;
431             }
433             /*
434              * Urls with control characters above 0x7e should be quoted.
435              * According to Mozilla's parser, whitespace is only allowed at the
436              * end of unquoted urls.
437              * Urls with `)` (as could happen with data: uris) should also be
438              * quoted to avoid being confused for the url() closing parentheses.
439              * And urls with a # have also been reported to cause issues.
440              * Urls with quotes inside should also remain escaped.
441              *
442              * @see https://developer.mozilla.org/nl/docs/Web/CSS/url#The_url()_functional_notation
443              * @see https://hg.mozilla.org/mozilla-central/rev/14abca4e7378
444              * @see https://github.com/matthiasmullie/minify/issues/193
445              */
446             $url = trim($url);
447             if (preg_match('/[\s\)\'"#\x{7f}-\x{9f}]/u', $url)) {
448                 $url = $match['quotes'] . $url . $match['quotes'];
449             }
451             // build replacement
452             $search[] = $match[0];
453             if ($type === 'url') {
454                 $replace[] = 'url('.$url.')';
455             } elseif ($type === 'import') {
456                 $replace[] = '@import "'.$url.'"';
457             }
458         }
460         // replace urls
461         return str_replace($search, $replace, $content);
462     }
464     /**
465      * Shorthand hex color codes.
466      * #FF0000 -> #F00.
467      *
468      * @param string $content The CSS content to shorten the hex color codes for
469      *
470      * @return string
471      */
472     protected function shortenHex($content)
473     {
474         $content = preg_replace('/(?<=[: ])#([0-9a-z])\\1([0-9a-z])\\2([0-9a-z])\\3(?=[; }])/i', '#$1$2$3', $content);
476         // we can shorten some even more by replacing them with their color name
477         $colors = array(
478             '#F0FFFF' => 'azure',
479             '#F5F5DC' => 'beige',
480             '#A52A2A' => 'brown',
481             '#FF7F50' => 'coral',
482             '#FFD700' => 'gold',
483             '#808080' => 'gray',
484             '#008000' => 'green',
485             '#4B0082' => 'indigo',
486             '#FFFFF0' => 'ivory',
487             '#F0E68C' => 'khaki',
488             '#FAF0E6' => 'linen',
489             '#800000' => 'maroon',
490             '#000080' => 'navy',
491             '#808000' => 'olive',
492             '#CD853F' => 'peru',
493             '#FFC0CB' => 'pink',
494             '#DDA0DD' => 'plum',
495             '#800080' => 'purple',
496             '#F00' => 'red',
497             '#FA8072' => 'salmon',
498             '#A0522D' => 'sienna',
499             '#C0C0C0' => 'silver',
500             '#FFFAFA' => 'snow',
501             '#D2B48C' => 'tan',
502             '#FF6347' => 'tomato',
503             '#EE82EE' => 'violet',
504             '#F5DEB3' => 'wheat',
505         );
507         return preg_replace_callback(
508             '/(?<=[: ])('.implode(array_keys($colors), '|').')(?=[; }])/i',
509             function ($match) use ($colors) {
510                 return $colors[strtoupper($match[0])];
511             },
512             $content
513         );
514     }
516     /**
517      * Shorten CSS font weights.
518      *
519      * @param string $content The CSS content to shorten the font weights for
520      *
521      * @return string
522      */
523     protected function shortenFontWeights($content)
524     {
525         $weights = array(
526             'normal' => 400,
527             'bold' => 700,
528         );
530         $callback = function ($match) use ($weights) {
531             return $match[1].$weights[$match[2]];
532         };
534         return preg_replace_callback('/(font-weight\s*:\s*)('.implode('|', array_keys($weights)).')(?=[;}])/', $callback, $content);
535     }
537     /**
538      * Shorthand 0 values to plain 0, instead of e.g. -0em.
539      *
540      * @param string $content The CSS content to shorten the zero values for
541      *
542      * @return string
543      */
544     protected function shortenZeroes($content)
545     {
546         // reusable bits of code throughout these regexes:
547         // before & after are used to make sure we don't match lose unintended
548         // 0-like values (e.g. in #000, or in http://url/1.0)
549         // units can be stripped from 0 values, or used to recognize non 0
550         // values (where wa may be able to strip a .0 suffix)
551         $before = '(?<=[:(, ])';
552         $after = '(?=[ ,);}])';
553         $units = '(em|ex|%|px|cm|mm|in|pt|pc|ch|rem|vh|vw|vmin|vmax|vm)';
555         // strip units after zeroes (0px -> 0)
556         // NOTE: it should be safe to remove all units for a 0 value, but in
557         // practice, Webkit (especially Safari) seems to stumble over at least
558         // 0%, potentially other units as well. Only stripping 'px' for now.
559         // @see https://github.com/matthiasmullie/minify/issues/60
560         $content = preg_replace('/'.$before.'(-?0*(\.0+)?)(?<=0)px'.$after.'/', '\\1', $content);
562         // strip 0-digits (.0 -> 0)
563         $content = preg_replace('/'.$before.'\.0+'.$units.'?'.$after.'/', '0\\1', $content);
564         // strip trailing 0: 50.10 -> 50.1, 50.10px -> 50.1px
565         $content = preg_replace('/'.$before.'(-?[0-9]+\.[0-9]+)0+'.$units.'?'.$after.'/', '\\1\\2', $content);
566         // strip trailing 0: 50.00 -> 50, 50.00px -> 50px
567         $content = preg_replace('/'.$before.'(-?[0-9]+)\.0+'.$units.'?'.$after.'/', '\\1\\2', $content);
568         // strip leading 0: 0.1 -> .1, 01.1 -> 1.1
569         $content = preg_replace('/'.$before.'(-?)0+([0-9]*\.[0-9]+)'.$units.'?'.$after.'/', '\\1\\2\\3', $content);
571         // strip negative zeroes (-0 -> 0) & truncate zeroes (00 -> 0)
572         $content = preg_replace('/'.$before.'-?0+'.$units.'?'.$after.'/', '0\\1', $content);
574         // remove zeroes where they make no sense in calc: e.g. calc(100px - 0)
575         // the 0 doesn't have any effect, and this isn't even valid without unit
576         // strip all `+ 0` or `- 0` occurrences: calc(10% + 0) -> calc(10%)
577         // looped because there may be multiple 0s inside 1 group of parentheses
578         do {
579             $previous = $content;
580             $content = preg_replace('/\(([^\(\)]+) [\+\-] 0( [^\(\)]+)?\)/', '(\\1\\2)', $content);
581         } while ($content !== $previous);
582         // strip all `0 +` occurrences: calc(0 + 10%) -> calc(10%)
583         $content = preg_replace('/\(0 \+ ([^\(\)]+)\)/', '(\\1)', $content);
584         // strip all `0 -` occurrences: calc(0 - 10%) -> calc(-10%)
585         $content = preg_replace('/\(0 \- ([^\(\)]+)\)/', '(-\\1)', $content);
586         // I'm not going to attempt to optimize away `x * 0` instances:
587         // it's dumb enough code already that it likely won't occur, and it's
588         // too complex to do right (order of operations would have to be
589         // respected etc)
590         // what I cared about most here was fixing incorrectly truncated units
592         // IE doesn't seem to understand a unitless flex-basis value, so let's
593         // add it in again (make it `%`, which is only 1 char: 0%, 0px, 0
594         // anything, it's all just the same)
595         $content = preg_replace('/flex:([^ ]+ [^ ]+ )0([;\}])/', 'flex:${1}0%${2}', $content);
596         $content = preg_replace('/flex-basis:0([;\}])/', 'flex-basis:0%${1}', $content);
598         return $content;
599     }
601     /**
602      * Strip empty tags from source code.
603      *
604      * @param string $content
605      *
606      * @return string
607      */
608     protected function stripEmptyTags($content)
609     {
610         return preg_replace('/(^|\}|;)[^\{\};]+\{\s*\}/', '\\1', $content);
611     }
613     /**
614      * Strip comments from source code.
615      */
616     protected function stripComments()
617     {
618         $this->registerPattern('/\/\*.*?\*\//s', '');
619     }
621     /**
622      * Strip whitespace.
623      *
624      * @param string $content The CSS content to strip the whitespace for
625      *
626      * @return string
627      */
628     protected function stripWhitespace($content)
629     {
630         // remove leading & trailing whitespace
631         $content = preg_replace('/^\s*/m', '', $content);
632         $content = preg_replace('/\s*$/m', '', $content);
634         // replace newlines with a single space
635         $content = preg_replace('/\s+/', ' ', $content);
637         // remove whitespace around meta characters
638         // inspired by stackoverflow.com/questions/15195750/minify-compress-css-with-regex
639         $content = preg_replace('/\s*([\*$~^|]?+=|[{};,>~]|!important\b)\s*/', '$1', $content);
640         $content = preg_replace('/([\[(:])\s+/', '$1', $content);
641         $content = preg_replace('/\s+([\]\)])/', '$1', $content);
642         $content = preg_replace('/\s+(:)(?![^\}]*\{)/', '$1', $content);
644         // whitespace around + and - can only be stripped inside some pseudo-
645         // classes, like `:nth-child(3+2n)`
646         // not in things like `calc(3px + 2px)`, shorthands like `3px -2px`, or
647         // selectors like `div.weird- p`
648         $pseudos = array('nth-child', 'nth-last-child', 'nth-last-of-type', 'nth-of-type');
649         $content = preg_replace('/:('.implode('|', $pseudos).')\(\s*([+-]?)\s*(.+?)\s*([+-]?)\s*(.*?)\s*\)/', ':$1($2$3$4$5)', $content);
651         // remove semicolon/whitespace followed by closing bracket
652         $content = str_replace(';}', '}', $content);
654         return trim($content);
655     }
657     /**
658      * Check if file is small enough to be imported.
659      *
660      * @param string $path The path to the file
661      *
662      * @return bool
663      */
664     protected function canImportBySize($path)
665     {
666         return ($size = @filesize($path)) && $size <= $this->maxImportSize * 1024;
667     }
669     /**
670      * Check if file a file can be imported, going by the path.
671      *
672      * @param string $path
673      *
674      * @return bool
675      */
676     protected function canImportByPath($path)
677     {
678         return preg_match('/^(data:|https?:|\\/)/', $path) === 0;
679     }
681     /**
682      * Return a converter to update relative paths to be relative to the new
683      * destination.
684      *
685      * @param string $source
686      * @param string $target
687      *
688      * @return ConverterInterface
689      */
690     protected function getPathConverter($source, $target)
691     {
692         return new Converter($source, $target);
693     }