vendor/dompdf/dompdf/src/Css/Stylesheet.php line 1011

Open in your IDE?
  1. <?php
  2. /**
  3.  * @package dompdf
  4.  * @link    http://dompdf.github.com/
  5.  * @author  Benj Carson <benjcarson@digitaljunkies.ca>
  6.  * @author  Helmut Tischer <htischer@weihenstephan.org>
  7.  * @author  Fabien Ménager <fabien.menager@gmail.com>
  8.  * @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
  9.  */
  10. namespace Dompdf\Css;
  12. use DOMElement;
  13. use DOMXPath;
  14. use Dompdf\Dompdf;
  15. use Dompdf\Helpers;
  16. use Dompdf\Exception;
  17. use Dompdf\FontMetrics;
  18. use Dompdf\Frame\FrameTree;
  20. /**
  21.  * The master stylesheet class
  22.  *
  23.  * The Stylesheet class is responsible for parsing stylesheets and style
  24.  * tags/attributes.  It also acts as a registry of the individual Style
  25.  * objects generated by the current set of loaded CSS files and style
  26.  * elements.
  27.  *
  28.  * @see Style
  29.  * @package dompdf
  30.  */
  31. class Stylesheet
  32. {
  33.     /**
  34.      * The location of the default built-in CSS file.
  35.      */
  36.     const DEFAULT_STYLESHEET = "/lib/res/html.css";
  38.     /**
  39.      * User agent stylesheet origin
  40.      *
  41.      * @var int
  42.      */
  43.     const ORIG_UA = 1;
  45.     /**
  46.      * User normal stylesheet origin
  47.      *
  48.      * @var int
  49.      */
  50.     const ORIG_USER = 2;
  52.     /**
  53.      * Author normal stylesheet origin
  54.      *
  55.      * @var int
  56.      */
  57.     const ORIG_AUTHOR = 3;
  59.     /*
  60.      * The highest possible specificity is 0x01000000 (and that is only for author
  61.      * stylesheets, as it is for inline styles). Origin precedence can be achieved by
  62.      * adding multiples of 0x10000000 to the actual specificity. Important
  63.      * declarations are handled in Style; though technically they should be handled
  64.      * here so that user important declarations can be made to take precedence over
  65.      * user important declarations, this doesn't matter in practice as Dompdf does
  66.      * not support user stylesheets, and user agent stylesheets can not include
  67.      * important declarations.
  68.      */
  69.     private static $_stylesheet_origins = [
  70.         self::ORIG_UA => 0x00000000, // user agent declarations
  71.         self::ORIG_USER => 0x10000000, // user normal declarations
  72.         self::ORIG_AUTHOR => 0x30000000, // author normal declarations
  73.     ];
  75.     /**
  76.      * Non-CSS presentational hints (i.e. HTML 4 attributes) are handled as if added
  77.      * to the beginning of an author stylesheet, i.e. anything in author stylesheets
  78.      * should override them.
  79.      */
  80.     const SPEC_NON_CSS = 0x20000000;
  82.     /**
  83.      * Current dompdf instance
  84.      *
  85.      * @var Dompdf
  86.      */
  87.     private $_dompdf;
  89.     /**
  90.      * Array of currently defined styles
  91.      *
  92.      * @var Style[]
  93.      */
  94.     private $_styles;
  96.     /**
  97.      * Base protocol of the document being parsed
  98.      * Used to handle relative urls.
  99.      *
  100.      * @var string
  101.      */
  102.     private $_protocol = "";
  104.     /**
  105.      * Base hostname of the document being parsed
  106.      * Used to handle relative urls.
  107.      *
  108.      * @var string
  109.      */
  110.     private $_base_host = "";
  112.     /**
  113.      * Base path of the document being parsed
  114.      * Used to handle relative urls.
  115.      *
  116.      * @var string
  117.      */
  118.     private $_base_path = "";
  120.     /**
  121.      * The styles defined by @page rules
  122.      *
  123.      * @var array<Style>
  124.      */
  125.     private $_page_styles;
  127.     /**
  128.      * List of loaded files, used to prevent recursion
  129.      *
  130.      * @var array
  131.      */
  132.     private $_loaded_files;
  134.     /**
  135.      * Current stylesheet origin
  136.      *
  137.      * @var int
  138.      */
  139.     private $_current_origin = self::ORIG_UA;
  141.     /**
  142.      * Accepted CSS media types
  143.      * List of types and parsing rules for future extensions:
  144.      * http://www.w3.org/TR/REC-html40/types.html
  145.      *   screen, tty, tv, projection, handheld, print, braille, aural, all
  146.      * The following are non standard extensions for undocumented specific environments.
  147.      *   static, visual, bitmap, paged, dompdf
  148.      * Note, even though the generated pdf file is intended for print output,
  149.      * the desired content might be different (e.g. screen or projection view of html file).
  150.      * Therefore allow specification of content by dompdf setting Options::defaultMediaType.
  151.      * If given, replace media "print" by Options::defaultMediaType.
  152.      * (Previous version $ACCEPTED_MEDIA_TYPES = $ACCEPTED_GENERIC_MEDIA_TYPES + $ACCEPTED_DEFAULT_MEDIA_TYPE)
  153.      */
  154.     static $ACCEPTED_DEFAULT_MEDIA_TYPE = "print";
  155.     static $ACCEPTED_GENERIC_MEDIA_TYPES = ["all", "static", "visual", "bitmap", "paged", "dompdf"];
  156.     static $VALID_MEDIA_TYPES = ["all", "aural", "bitmap", "braille", "dompdf", "embossed", "handheld", "paged", "print", "projection", "screen", "speech", "static", "tty", "tv", "visual"];
  158.     /**
  159.      * @var FontMetrics
  160.      */
  161.     private $fontMetrics;
  163.     /**
  164.      * The class constructor.
  165.      *
  166.      * The base protocol, host & path are initialized to those of
  167.      * the current script.
  168.      */
  169.     function __construct(Dompdf $dompdf)
  170.     {
  171.         $this->_dompdf = $dompdf;
  172.         $this->setFontMetrics($dompdf->getFontMetrics());
  173.         $this->_styles = [];
  174.         $this->_loaded_files = [];
  175.         $script = __FILE__;
  176.         if (isset($_SERVER["SCRIPT_FILENAME"])) {
  177.             $script = $_SERVER["SCRIPT_FILENAME"];
  178.         }
  179.         list($this->_protocol, $this->_base_host, $this->_base_path) = Helpers::explode_url($script);
  180.         $this->_page_styles = ["base" => new Style($this)];
  181.     }
  183.     /**
  184.      * Set the base protocol
  185.      *
  186.      * @param string $protocol
  187.      */
  188.     function set_protocol(string $protocol)
  189.     {
  190.         $this->_protocol = $protocol;
  191.     }
  193.     /**
  194.      * Set the base host
  195.      *
  196.      * @param string $host
  197.      */
  198.     function set_host(string $host)
  199.     {
  200.         $this->_base_host = $host;
  201.     }
  203.     /**
  204.      * Set the base path
  205.      *
  206.      * @param string $path
  207.      */
  208.     function set_base_path(string $path)
  209.     {
  210.         $this->_base_path = $path;
  211.     }
  213.     /**
  214.      * Return the Dompdf object
  215.      *
  216.      * @return Dompdf
  217.      */
  218.     function get_dompdf()
  219.     {
  220.         return $this->_dompdf;
  221.     }
  223.     /**
  224.      * Return the base protocol for this stylesheet
  225.      *
  226.      * @return string
  227.      */
  228.     function get_protocol()
  229.     {
  230.         return $this->_protocol;
  231.     }
  233.     /**
  234.      * Return the base host for this stylesheet
  235.      *
  236.      * @return string
  237.      */
  238.     function get_host()
  239.     {
  240.         return $this->_base_host;
  241.     }
  243.     /**
  244.      * Return the base path for this stylesheet
  245.      *
  246.      * @return string
  247.      */
  248.     function get_base_path()
  249.     {
  250.         return $this->_base_path;
  251.     }
  253.     /**
  254.      * Return the array of page styles
  255.      *
  256.      * @return Style[]
  257.      */
  258.     function get_page_styles()
  259.     {
  260.         return $this->_page_styles;
  261.     }
  263.     /**
  264.      * Create a new Style object associated with this stylesheet
  265.      *
  266.      * @return Style
  267.      */
  268.     function create_style(): Style
  269.     {
  270.         return new Style($this, $this->_current_origin);
  271.     }
  273.     /**
  274.      * Add a new Style object to the stylesheet
  275.      *
  276.      * The style's origin is changed to the current origin of the stylesheet.
  277.      *
  278.      * @param string $key the Style's selector
  279.      * @param Style $style the Style to be added
  280.      */
  281.     function add_style(string $key, Style $style): void
  282.     {
  283.         if (!isset($this->_styles[$key])) {
  284.             $this->_styles[$key] = [];
  285.         }
  287.         $style->set_origin($this->_current_origin);
  288.         $this->_styles[$key][] = $style;
  289.     }
  291.     /**
  292.      * load and parse a CSS string
  293.      *
  294.      * @param string $css
  295.      * @param int $origin
  296.      */
  297.     function load_css(&$css, $origin = self::ORIG_AUTHOR)
  298.     {
  299.         if ($origin) {
  300.             $this->_current_origin = $origin;
  301.         }
  302.         $this->_parse_css($css);
  303.     }
  305.     /**
  306.      * load and parse a CSS file
  307.      *
  308.      * @param string $file
  309.      * @param int $origin
  310.      */
  311.     function load_css_file($file, $origin = self::ORIG_AUTHOR)
  312.     {
  313.         if ($origin) {
  314.             $this->_current_origin = $origin;
  315.         }
  317.         // Prevent circular references
  318.         if (isset($this->_loaded_files[$file])) {
  319.             return;
  320.         }
  322.         $this->_loaded_files[$file] = true;
  324.         if (strpos($file, "data:") === 0) {
  325.             $parsed = Helpers::parse_data_uri($file);
  326.             $css = $parsed["data"];
  327.         } else {
  328.             $options = $this->_dompdf->getOptions();
  330.             $parsed_url = Helpers::explode_url($file);
  331.             $protocol = $parsed_url["protocol"];
  333.             if ($file !== $this->getDefaultStylesheet()) {
  334.                 $allowed_protocols = $options->getAllowedProtocols();
  335.                 if (!array_key_exists($protocol, $allowed_protocols)) {
  336.                     Helpers::record_warnings(E_USER_WARNING, "Permission denied on $file. The communication protocol is not supported.", __FILE__, __LINE__);
  337.                     return;
  338.                 }
  339.                 foreach ($allowed_protocols[$protocol]["rules"] as $rule) {
  340.                     [$result, $message] = $rule($file);
  341.                     if (!$result) {
  342.                         Helpers::record_warnings(E_USER_WARNING, "Error loading $file: $message", __FILE__, __LINE__);
  343.                         return;
  344.                     }
  345.                 }
  346.             }
  348.             [$css, $http_response_header] = Helpers::getFileContent($file, $this->_dompdf->getHttpContext());
  350.             $good_mime_type = true;
  352.             // See http://the-stickman.com/web-development/php/getting-http-response-headers-when-using-file_get_contents/
  353.             if (isset($http_response_header) && !$this->_dompdf->getQuirksmode()) {
  354.                 foreach ($http_response_header as $_header) {
  355.                     if (preg_match("@Content-Type:\s*([\w/]+)@i", $_header, $matches) &&
  356.                         ($matches[1] !== "text/css")
  357.                     ) {
  358.                         $good_mime_type = false;
  359.                     }
  360.                 }
  361.             }
  362.             if (!$good_mime_type || $css === null) {
  363.                 Helpers::record_warnings(E_USER_WARNING, "Unable to load css file $file", __FILE__, __LINE__);
  364.                 return;
  365.             }
  367.             [$this->_protocol, $this->_base_host, $this->_base_path] = $parsed_url;
  368.         }
  370.         $this->_parse_css($css);
  371.     }
  373.     /**
  374.      * @link http://www.w3.org/TR/CSS21/cascade.html#specificity
  375.      *
  376.      * @param string $selector
  377.      * @param int $origin :
  378.      *    - Stylesheet::ORIG_UA: user agent style sheet
  379.      *    - Stylesheet::ORIG_USER: user style sheet
  380.      *    - Stylesheet::ORIG_AUTHOR: author style sheet
  381.      *
  382.      * @return int
  383.      */
  384.     private function _specificity($selector, $origin = self::ORIG_AUTHOR)
  385.     {
  386.         // http://www.w3.org/TR/CSS21/cascade.html#specificity
  387.         // ignoring the ":" pseudoclass modifiers
  388.         // also ignored in _css_selector_to_xpath
  390.         $a = ($selector === "!attr") ? 1 : 0;
  392.         $b = min(mb_substr_count($selector, "#"), 255);
  394.         $c = min(mb_substr_count($selector, ".") +
  395.             mb_substr_count($selector, "["), 255);
  397.         $d = min(mb_substr_count($selector, " ") +
  398.             mb_substr_count($selector, ">") +
  399.             mb_substr_count($selector, "+") +
  400.             mb_substr_count($selector, "~") -
  401.             mb_substr_count($selector, "~="), 255);
  403.         //If a normal element name is at the beginning of the string,
  404.         //a leading whitespace might have been removed on whitespace collapsing and removal
  405.         //therefore there might be one whitespace less as selected element names
  406.         //this can lead to a too small specificity
  407.         //see _css_selector_to_xpath
  409.         if (!in_array($selector[0], [" ", ">", ".", "#", "+", "~", ":", "["]) && $selector !== "*") {
  410.             $d++;
  411.         }
  413.         if ($this->_dompdf->getOptions()->getDebugCss()) {
  414.             /*DEBUGCSS*/
  415.             print "<pre>\n";
  416.             /*DEBUGCSS*/
  417.             printf("_specificity(): 0x%08x \"%s\"\n", self::$_stylesheet_origins[$origin] + (($a << 24) | ($b << 16) | ($c << 8) | ($d)), $selector);
  418.             /*DEBUGCSS*/
  419.             print "</pre>";
  420.         }
  422.         return self::$_stylesheet_origins[$origin] + (($a << 24) | ($b << 16) | ($c << 8) | ($d));
  423.     }
  425.     /**
  426.      * Converts a CSS selector to an XPath query.
  427.      *
  428.      * @param string $selector
  429.      * @param bool $first_pass
  430.      *
  431.      * @throws Exception
  432.      * @return array
  433.      */
  434.     private function _css_selector_to_xpath(string $selector, bool $first_pass = false): array
  435.     {
  436.         // Collapse white space and strip whitespace around delimiters
  437.         //$search = array("/\\s+/", "/\\s+([.>#+:])\\s+/");
  438.         //$replace = array(" ", "\\1");
  439.         //$selector = preg_replace($search, $replace, trim($selector));
  441.         // Initial query (non-absolute)
  442.         $query = "//";
  444.         // Will contain :before and :after
  445.         $pseudo_elements = [];
  447.         // Will contain :link, etc
  448.         $pseudo_classes = [];
  450.         // Parse the selector
  451.         //$s = preg_split("/([ :>.#+])/", $selector, -1, PREG_SPLIT_DELIM_CAPTURE);
  453.         $delimiters = [" ", ">", ".", "#", "+", "~", ":", "[", "("];
  455.         // Add an implicit * at the beginning of the selector
  456.         // if it begins with an attribute selector
  457.         if ($selector[0] === "[") {
  458.             $selector = "*$selector";
  459.         }
  461.         // Add an implicit space at the beginning of the selector if there is no
  462.         // delimiter there already.
  463.         if (!in_array($selector[0], $delimiters)) {
  464.             $selector = " $selector";
  465.         }
  467.         $tok = "";
  468.         $len = mb_strlen($selector);
  469.         $i = 0;
  471.         while ($i < $len) {
  473.             $s = $selector[$i];
  474.             $i++;
  476.             // Eat characters up to the next delimiter
  477.             $tok = "";
  478.             $in_attr = false;
  479.             $in_func = false;
  481.             while ($i < $len) {
  482.                 $c = $selector[$i];
  483.                 $c_prev = $selector[$i - 1];
  485.                 if (!$in_func && !$in_attr && in_array($c, $delimiters) && !(($c == $c_prev) == ":")) {
  486.                     break;
  487.                 }
  489.                 if ($c_prev === "[") {
  490.                     $in_attr = true;
  491.                 }
  492.                 if ($c_prev === "(") {
  493.                     $in_func = true;
  494.                 }
  496.                 $tok .= $selector[$i++];
  498.                 if ($in_attr && $c === "]") {
  499.                     $in_attr = false;
  500.                     break;
  501.                 }
  502.                 if ($in_func && $c === ")") {
  503.                     $in_func = false;
  504.                     break;
  505.                 }
  506.             }
  508.             switch ($s) {
  510.                 case " ":
  511.                 case ">":
  512.                     // All elements matching the next token that are direct children of
  513.                     // the current token
  514.                     $expr = $s === " " ? "descendant" : "child";
  516.                     if (mb_substr($query, -1, 1) !== "/") {
  517.                         $query .= "/";
  518.                     }
  520.                     // Tag names are case-insensitive
  521.                     $tok = strtolower($tok);
  523.                     if (!$tok) {
  524.                         $tok = "*";
  525.                     }
  527.                     $query .= "$expr::$tok";
  528.                     $tok = "";
  529.                     break;
  531.                 case ".":
  532.                 case "#":
  533.                     // All elements matching the current token with a class/id equal to
  534.                     // the _next_ token.
  536.                     $attr = $s === "." ? "class" : "id";
  538.                     // empty class/id == *
  539.                     if (mb_substr($query, -1, 1) === "/") {
  540.                         $query .= "*";
  541.                     }
  543.                     // Match multiple classes: $tok contains the current selected
  544.                     // class.  Search for class attributes with class="$tok",
  545.                     // class=".* $tok .*" and class=".* $tok"
  547.                     // This doesn't work because libxml only supports XPath 1.0...
  548.                     //$query .= "[matches(@$attr,\"^{$tok}\$|^{$tok}[ ]+|[ ]+{$tok}\$|[ ]+{$tok}[ ]+\")]";
  550.                     $query .= "[contains(concat(' ', normalize-space(@$attr), ' '), concat(' ', '$tok', ' '))]";
  551.                     $tok = "";
  552.                     break;
  554.                 case "+":
  555.                 case "~":
  556.                     // Next-sibling combinator
  557.                     // Subsequent-sibling combinator
  558.                     // https://www.w3.org/TR/selectors-3/#sibling-combinators
  559.                     if (mb_substr($query, -1, 1) !== "/") {
  560.                         $query .= "/";
  561.                     }
  563.                     // Tag names are case-insensitive
  564.                     $tok = strtolower($tok);
  566.                     if (!$tok) {
  567.                         $tok = "*";
  568.                     }
  570.                     $query .= "following-sibling::$tok";
  572.                     if ($s === "+") {
  573.                         $query .= "[1]";
  574.                     }
  576.                     $tok = "";
  577.                     break;
  579.                 case ":":
  580.                     $i2 = $i - strlen($tok) - 2; // the char before ":"
  581.                     if (($i2 < 0 || !isset($selector[$i2]) || (in_array($selector[$i2], $delimiters) && $selector[$i2] != ":")) && substr($query, -1) != "*") {
  582.                         $query .= "*";
  583.                     }
  585.                     $last = false;
  587.                     // Pseudo-classes
  588.                     switch ($tok) {
  590.                         case "first-child":
  591.                             $query .= "[not(preceding-sibling::*)]";
  592.                             $tok = "";
  593.                             break;
  595.                         case "last-child":
  596.                             $query .= "[not(following-sibling::*)]";
  597.                             $tok = "";
  598.                             break;
  600.                         case "first-of-type":
  601.                             $query .= "[position() = 1]";
  602.                             $tok = "";
  603.                             break;
  605.                         case "last-of-type":
  606.                             $query .= "[position() = last()]";
  607.                             $tok = "";
  608.                             break;
  610.                         // an+b, n, odd, and even
  611.                         /** @noinspection PhpMissingBreakStatementInspection */
  612.                         case "nth-last-of-type":
  613.                             $last = true;
  614.                         case "nth-of-type":
  615.                             //FIXME: this fix-up is pretty ugly, would parsing the selector in reverse work better generally?
  616.                             $descendant_delimeter = strrpos($query, "::");
  617.                             $isChild = substr($query, $descendant_delimeter-5, 5) == "child";
  618.                             $el = substr($query, $descendant_delimeter+2);
  619.                             $query = substr($query, 0, strrpos($query, "/")) . ($isChild ? "/" : "//") . $el;
  621.                             $pseudo_classes[$tok] = true;
  622.                             $p = $i + 1;
  623.                             $nth = trim(mb_substr($selector, $p, strpos($selector, ")", $i) - $p));
  624.                             $position = $last ? "(last()-position()+1)" : "position()";
  626.                             // 1
  627.                             if (preg_match("/^\d+$/", $nth)) {
  628.                                 $condition = "$position = $nth";
  629.                             } // odd
  630.                             elseif ($nth === "odd") {
  631.                                 $condition = "($position mod 2) = 1";
  632.                             } // even
  633.                             elseif ($nth === "even") {
  634.                                 $condition = "($position mod 2) = 0";
  635.                             } // an+b
  636.                             else {
  637.                                 $condition = $this->_selector_an_plus_b($nth, $last);
  638.                             }
  640.                             $query .= "[$condition]";
  641.                             $tok = "";
  642.                             break;
  643.                         /** @noinspection PhpMissingBreakStatementInspection */
  644.                         case "nth-last-child":
  645.                             $last = true;
  646.                         case "nth-child":
  647.                             //FIXME: this fix-up is pretty ugly, would parsing the selector in reverse work better generally?
  648.                             $descendant_delimeter = strrpos($query, "::");
  649.                             $isChild = substr($query, $descendant_delimeter-5, 5) == "child";
  650.                             $el = substr($query, $descendant_delimeter+2);
  651.                             $query = substr($query, 0, strrpos($query, "/")) . ($isChild ? "/" : "//") . "*";
  653.                             $pseudo_classes[$tok] = true;
  654.                             $p = $i + 1;
  655.                             $nth = trim(mb_substr($selector, $p, strpos($selector, ")", $i) - $p));
  656.                             $position = $last ? "(last()-position()+1)" : "position()";
  658.                             // 1
  659.                             if (preg_match("/^\d+$/", $nth)) {
  660.                                 $condition = "$position = $nth";
  661.                             } // odd
  662.                             elseif ($nth === "odd") {
  663.                                 $condition = "($position mod 2) = 1";
  664.                             } // even
  665.                             elseif ($nth === "even") {
  666.                                 $condition = "($position mod 2) = 0";
  667.                             } // an+b
  668.                             else {
  669.                                 $condition = $this->_selector_an_plus_b($nth, $last);
  670.                             }
  672.                             $query .= "[$condition]";
  673.                             if ($el != "*") {
  674.                                 $query .= "[name() = '$el']";
  675.                             }
  676.                             $tok = "";
  677.                             break;
  679.                         //TODO: bit of a hack attempt at matches support, currently only matches against elements
  680.                         case "matches":
  681.                             $pseudo_classes[$tok] = true;
  682.                             $p = $i + 1;
  683.                             $matchList = trim(mb_substr($selector, $p, strpos($selector, ")", $i) - $p));
  685.                             // Tag names are case-insensitive
  686.                             $elements = array_map("trim", explode(",", strtolower($matchList)));
  687.                             foreach ($elements as &$element) {
  688.                                 $element = "name() = '$element'";
  689.                             }
  691.                             $query .= "[" . implode(" or ", $elements) . "]";
  692.                             $tok = "";
  693.                             break;
  695.                         case "link":
  696.                             $query .= "[@href]";
  697.                             $tok = "";
  698.                             break;
  700.                         case "first-line":
  701.                         case ":first-line":
  702.                         case "first-letter":
  703.                         case ":first-letter":
  704.                             // TODO
  705.                             $el = trim($tok, ":");
  706.                             $pseudo_elements[$el] = true;
  707.                             break;
  709.                             // N/A
  710.                         case "focus":
  711.                         case "active":
  712.                         case "hover":
  713.                         case "visited":
  714.                             $query .= "[false()]";
  715.                             $tok = "";
  716.                             break;
  718.                         /* Pseudo-elements */
  719.                         case "before":
  720.                         case ":before":
  721.                         case "after":
  722.                         case ":after":
  723.                             $pos = trim($tok, ":");
  724.                             $pseudo_elements[$pos] = true;
  725.                             if (!$first_pass) {
  726.                                 $query .= "/*[@$pos]";
  727.                             }
  729.                             $tok = "";
  730.                             break;
  732.                         case "empty":
  733.                             $query .= "[not(*) and not(normalize-space())]";
  734.                             $tok = "";
  735.                             break;
  737.                         case "disabled":
  738.                         case "checked":
  739.                             $query .= "[@$tok]";
  740.                             $tok = "";
  741.                             break;
  743.                         case "enabled":
  744.                             $query .= "[not(@disabled)]";
  745.                             $tok = "";
  746.                             break;
  748.                         // the selector is not handled, until we support all possible selectors force an empty set (silent failure)
  749.                         default:
  750.                             $query = "/../.."; // go up two levels because generated content starts on the body element
  751.                             $tok = "";
  752.                             break;
  753.                     }
  755.                     break;
  757.                 case "[":
  758.                     // Attribute selectors.  All with an attribute matching the following token(s)
  759.                     // https://www.w3.org/TR/selectors-3/#attribute-selectors
  760.                     $attr_delimiters = ["=", "]", "~", "|", "$", "^", "*"];
  761.                     $tok_len = mb_strlen($tok);
  762.                     $j = 0;
  764.                     $attr = "";
  765.                     $op = "";
  766.                     $value = "";
  768.                     while ($j < $tok_len) {
  769.                         if (in_array($tok[$j], $attr_delimiters)) {
  770.                             break;
  771.                         }
  772.                         $attr .= $tok[$j++];
  773.                     }
  775.                     switch ($tok[$j]) {
  777.                         case "~":
  778.                         case "|":
  779.                         case "$":
  780.                         case "^":
  781.                         case "*":
  782.                             $op .= $tok[$j++];
  784.                             if ($tok[$j] !== "=") {
  785.                                 throw new Exception("Invalid CSS selector syntax: invalid attribute selector: $selector");
  786.                             }
  788.                             $op .= $tok[$j];
  789.                             break;
  791.                         case "=":
  792.                             $op = "=";
  793.                             break;
  795.                     }
  797.                     // Read the attribute value, if required
  798.                     if ($op != "") {
  799.                         $j++;
  800.                         while ($j < $tok_len) {
  801.                             if ($tok[$j] === "]") {
  802.                                 break;
  803.                             }
  804.                             $value .= $tok[$j++];
  805.                         }
  806.                     }
  808.                     if ($attr == "") {
  809.                         throw new Exception("Invalid CSS selector syntax: missing attribute name");
  810.                     }
  812.                     $value = trim($value, "\"'");
  814.                     switch ($op) {
  816.                         case "":
  817.                             $query .= "[@$attr]";
  818.                             break;
  820.                         case "=":
  821.                             $query .= "[@$attr=\"$value\"]";
  822.                             break;
  824.                         case "~=":
  825.                             // FIXME: this will break if $value contains quoted strings
  826.                             // (e.g. [type~="a b c" "d e f"])
  827.                             // FIXME: Don't match anything if value contains
  828.                             // whitespace or is the empty string
  829.                             $query .= "[contains(concat(' ', normalize-space(@$attr), ' '), concat(' ', '$value', ' '))]";
  830.                             break;
  832.                         case "|=":
  833.                             $values = explode("-", $value);
  834.                             $query .= "[";
  836.                             foreach ($values as $val) {
  837.                                 $query .= "starts-with(@$attr, \"$val\") or ";
  838.                             }
  840.                             $query = rtrim($query, " or ") . "]";
  841.                             break;
  843.                         case "$=":
  844.                             $query .= "[substring(@$attr, string-length(@$attr)-" . (strlen($value) - 1) . ")=\"$value\"]";
  845.                             break;
  847.                         case "^=":
  848.                             $query .= "[starts-with(@$attr,\"$value\")]";
  849.                             break;
  851.                         case "*=":
  852.                             $query .= "[contains(@$attr,\"$value\")]";
  853.                             break;
  854.                     }
  856.                     break;
  857.             }
  858.         }
  859.         $i++;
  861. //       case ":":
  862. //         // Pseudo selectors: ignore for now.  Partially handled directly
  863. //         // below.
  865. //         // Skip until the next special character, leaving the token as-is
  866. //         while ( $i < $len ) {
  867. //           if ( in_array($selector[$i], $delimiters) )
  868. //             break;
  869. //           $i++;
  870. //         }
  871. //         break;
  873. //       default:
  874. //         // Add the character to the token
  875. //         $tok .= $selector[$i++];
  876. //         break;
  877. //       }
  879. //    }
  882.         // Trim the trailing '/' from the query
  883.         if (mb_strlen($query) > 2) {
  884.             $query = rtrim($query, "/");
  885.         }
  887.         return ['query' => $query, 'pseudo_elements' => $pseudo_elements];
  888.     }
  890.     /**
  891.      * https://github.com/tenderlove/nokogiri/blob/master/lib/nokogiri/css/xpath_visitor.rb
  892.      *
  893.      * @param string $expr
  894.      * @param bool $last
  895.      *
  896.      * @return string
  897.      */
  898.     protected function _selector_an_plus_b(string $expr, bool $last = false): string
  899.     {
  900.         $expr = preg_replace("/\s/", "", $expr);
  901.         if (!preg_match("/^(?P<a>-?[0-9]*)?n(?P<b>[-+]?[0-9]+)?$/", $expr, $matches)) {
  902.             return "false()";
  903.         }
  905.         $a = (isset($matches["a"]) && $matches["a"] !== "") ? ($matches["a"] !== "-" ? intval($matches["a"]) : -1) : 1;
  906.         $b = (isset($matches["b"]) && $matches["b"] !== "") ? intval($matches["b"]) : 0;
  908.         $position = $last ? "(last()-position()+1)" : "position()";
  910.         if ($b == 0) {
  911.             return "($position mod $a) = 0";
  912.         } else {
  913.             $compare = ($a < 0) ? "<=" : ">=";
  914.             $b2 = -$b;
  915.             if ($b2 >= 0) {
  916.                 $b2 = "+$b2";
  917.             }
  918.             return "($position $compare $b) and ((($position $b2) mod " . abs($a) . ") = 0)";
  919.         }
  920.     }
  922.     /**
  923.      * applies all current styles to a particular document tree
  924.      *
  925.      * apply_styles() applies all currently loaded styles to the provided
  926.      * {@link FrameTree}.  Aside from parsing CSS, this is the main purpose
  927.      * of this class.
  928.      *
  929.      * @param \Dompdf\Frame\FrameTree $tree
  930.      */
  931.     function apply_styles(FrameTree $tree)
  932.     {
  933.         // Use XPath to select nodes.  This would be easier if we could attach
  934.         // Frame objects directly to DOMNodes using the setUserData() method, but
  935.         // we can't do that just yet.  Instead, we set a _node attribute_ in
  936.         // Frame->set_id() and use that as a handle on the Frame object via
  937.         // FrameTree::$_registry.
  939.         // We create a scratch array of styles indexed by frame id.  Once all
  940.         // styles have been assigned, we order the cached styles by specificity
  941.         // and create a final style object to assign to the frame.
  943.         // FIXME: this is not particularly robust...
  945.         $styles = [];
  946.         $xp = new DOMXPath($tree->get_dom());
  947.         $DEBUGCSS = $this->_dompdf->getOptions()->getDebugCss();
  949.         // Add generated content
  950.         foreach ($this->_styles as $selector => $selector_styles) {
  951.             /** @var Style $style */
  952.             foreach ($selector_styles as $style) {
  953.                 if (strpos($selector, ":before") === false && strpos($selector, ":after") === false) {
  954.                     continue;
  955.                 }
  957.                 $query = $this->_css_selector_to_xpath($selector, true);
  959.                 // Retrieve the nodes, limit to body for generated content
  960.                 //TODO: If we use a context node can we remove the leading dot?
  961.                 $nodes = @$xp->query('.' . $query["query"]);
  962.                 if ($nodes === false) {
  963.                     Helpers::record_warnings(E_USER_WARNING, "The CSS selector '$selector' is not valid", __FILE__, __LINE__);
  964.                     continue;
  965.                 }
  967.                 /** @var \DOMElement $node */
  968.                 foreach ($nodes as $node) {
  969.                     // Only DOMElements get styles
  970.                     if ($node->nodeType != XML_ELEMENT_NODE) {
  971.                         continue;
  972.                     }
  974.                     foreach (array_keys($query["pseudo_elements"], true, true) as $pos) {
  975.                         // Do not add a new pseudo element if another one already matched
  976.                         if ($node->hasAttribute("dompdf_{$pos}_frame_id")) {
  977.                             continue;
  978.                         }
  980.                         $content = $style->get_specified("content");
  982.                         // Do not create non-displayed before/after pseudo elements
  983.                         // https://www.w3.org/TR/CSS21/generate.html#content
  984.                         // https://www.w3.org/TR/CSS21/generate.html#undisplayed-counters
  985.                         if ($content === "normal" || $content === "none") {
  986.                             continue;
  987.                         }
  989.                         if (($src = $this->resolve_url($content)) !== "none") {
  990.                             $new_node = $node->ownerDocument->createElement("img_generated");
  991.                             $new_node->setAttribute("src", $src);
  992.                         } else {
  993.                             $new_node = $node->ownerDocument->createElement("dompdf_generated");
  994.                         }
  996.                         $new_node->setAttribute($pos, $pos);
  997.                         $new_frame_id = $tree->insert_node($node, $new_node, $pos);
  998.                         $node->setAttribute("dompdf_{$pos}_frame_id", $new_frame_id);
  999.                     }
  1000.                 }
  1001.             }
  1002.         }
  1004.         // Apply all styles in stylesheet
  1005.         foreach ($this->_styles as $selector => $selector_styles) {
  1006.             /** @var Style $style */
  1007.             foreach ($selector_styles as $style) {
  1008.                 $query = $this->_css_selector_to_xpath($selector);
  1010.                 // Retrieve the nodes
  1011.                 $nodes = @$xp->query($query["query"]);
  1012.                 if ($nodes === false) {
  1013.                     Helpers::record_warnings(E_USER_WARNING, "The CSS selector '$selector' is not valid", __FILE__, __LINE__);
  1014.                     continue;
  1015.                 }
  1017.                 $spec = $this->_specificity($selector, $style->get_origin());
  1019.                 foreach ($nodes as $node) {
  1020.                     // Retrieve the node id
  1021.                     // Only DOMElements get styles
  1022.                     if ($node->nodeType != XML_ELEMENT_NODE) {
  1023.                         continue;
  1024.                     }
  1026.                     $id = $node->getAttribute("frame_id");
  1028.                     // Assign the current style to the scratch array
  1029.                     $styles[$id][$spec][] = $style;
  1030.                 }
  1031.             }
  1032.         }
  1034.         // Set the page width, height, and orientation based on the canvas paper size
  1035.         $canvas = $this->_dompdf->getCanvas();
  1036.         $paper_width = $canvas->get_width();
  1037.         $paper_height = $canvas->get_height();
  1038.         $paper_orientation = ($paper_width > $paper_height ? "landscape" : "portrait");
  1040.         if ($this->_page_styles["base"] && is_array($this->_page_styles["base"]->size)) {
  1041.             $paper_width = $this->_page_styles['base']->size[0];
  1042.             $paper_height = $this->_page_styles['base']->size[1];
  1043.             $paper_orientation = ($paper_width > $paper_height ? "landscape" : "portrait");
  1044.         }
  1046.         // Now create the styles and assign them to the appropriate frames. (We
  1047.         // iterate over the tree using an implicit FrameTree iterator.)
  1048.         $root_flg = false;
  1049.         foreach ($tree as $frame) {
  1050.             // Helpers::pre_r($frame->get_node()->nodeName . ":");
  1051.             if (!$root_flg && $this->_page_styles["base"]) {
  1052.                 $style = $this->_page_styles["base"];
  1053.             } else {
  1054.                 $style = $this->create_style();
  1055.             }
  1057.             // Find nearest DOMElement parent
  1058.             $p = $frame;
  1059.             while ($p = $p->get_parent()) {
  1060.                 if ($p->get_node()->nodeType === XML_ELEMENT_NODE) {
  1061.                     break;
  1062.                 }
  1063.             }
  1065.             // Styles can only be applied directly to DOMElements; anonymous
  1066.             // frames inherit from their parent
  1067.             if ($frame->get_node()->nodeType !== XML_ELEMENT_NODE) {
  1068.                 $style->inherit($p ? $p->get_style() : null);
  1069.                 $frame->set_style($style);
  1070.                 continue;
  1071.             }
  1073.             $id = $frame->get_id();
  1075.             // Handle HTML 4.0 attributes
  1076.             AttributeTranslator::translate_attributes($frame);
  1077.             if (($str = $frame->get_node()->getAttribute(AttributeTranslator::$_style_attr)) !== "") {
  1078.                 $styles[$id][self::SPEC_NON_CSS][] = $this->_parse_properties($str);
  1079.             }
  1081.             // Locate any additional style attributes
  1082.             if (($str = $frame->get_node()->getAttribute("style")) !== "") {
  1083.                 // Destroy CSS comments
  1084.                 $str = preg_replace("'/\*.*?\*/'si", "", $str);
  1086.                 $spec = $this->_specificity("!attr", self::ORIG_AUTHOR);
  1087.                 $styles[$id][$spec][] = $this->_parse_properties($str);
  1088.             }
  1090.             // Grab the applicable styles
  1091.             if (isset($styles[$id])) {
  1093.                 /** @var array[][] $applied_styles */
  1094.                 $applied_styles = $styles[$id];
  1096.                 // Sort by specificity
  1097.                 ksort($applied_styles);
  1099.                 if ($DEBUGCSS) {
  1100.                     $debug_nodename = $frame->get_node()->nodeName;
  1101.                     print "<pre>\n$debug_nodename [\n";
  1102.                     foreach ($applied_styles as $spec => $arr) {
  1103.                         printf("  specificity 0x%08x\n", $spec);
  1104.                         /** @var Style $s */
  1105.                         foreach ($arr as $s) {
  1106.                             print "  [\n";
  1107.                             $s->debug_print();
  1108.                             print "  ]\n";
  1109.                         }
  1110.                     }
  1111.                 }
  1113.                 // Merge the new styles with the inherited styles
  1114.                 $acceptedmedia = self::$ACCEPTED_GENERIC_MEDIA_TYPES;
  1115.                 $acceptedmedia[] = $this->_dompdf->getOptions()->getDefaultMediaType();
  1116.                 foreach ($applied_styles as $arr) {
  1117.                     /** @var Style $s */
  1118.                     foreach ($arr as $s) {
  1119.                         $media_queries = $s->get_media_queries();
  1120.                         foreach ($media_queries as $media_query) {
  1121.                             list($media_query_feature, $media_query_value) = $media_query;
  1122.                             // if any of the Style's media queries fail then do not apply the style
  1123.                             //TODO: When the media query logic is fully developed we should not apply the Style when any of the media queries fail or are bad, per https://www.w3.org/TR/css3-mediaqueries/#error-handling
  1124.                             if (in_array($media_query_feature, self::$VALID_MEDIA_TYPES)) {
  1125.                                 if ((strlen($media_query_feature) === 0 && !in_array($media_query, $acceptedmedia)) || (in_array($media_query, $acceptedmedia) && $media_query_value == "not")) {
  1126.                                     continue (3);
  1127.                                 }
  1128.                             } else {
  1129.                                 switch ($media_query_feature) {
  1130.                                     case "height":
  1131.                                         if ($paper_height !== (float)$style->length_in_pt($media_query_value)) {
  1132.                                             continue (3);
  1133.                                         }
  1134.                                         break;
  1135.                                     case "min-height":
  1136.                                         if ($paper_height < (float)$style->length_in_pt($media_query_value)) {
  1137.                                             continue (3);
  1138.                                         }
  1139.                                         break;
  1140.                                     case "max-height":
  1141.                                         if ($paper_height > (float)$style->length_in_pt($media_query_value)) {
  1142.                                             continue (3);
  1143.                                         }
  1144.                                         break;
  1145.                                     case "width":
  1146.                                         if ($paper_width !== (float)$style->length_in_pt($media_query_value)) {
  1147.                                             continue (3);
  1148.                                         }
  1149.                                         break;
  1150.                                     case "min-width":
  1151.                                         //if (min($paper_width, $media_query_width) === $paper_width) {
  1152.                                         if ($paper_width < (float)$style->length_in_pt($media_query_value)) {
  1153.                                             continue (3);
  1154.                                         }
  1155.                                         break;
  1156.                                     case "max-width":
  1157.                                         //if (max($paper_width, $media_query_width) === $paper_width) {
  1158.                                         if ($paper_width > (float)$style->length_in_pt($media_query_value)) {
  1159.                                             continue (3);
  1160.                                         }
  1161.                                         break;
  1162.                                     case "orientation":
  1163.                                         if ($paper_orientation !== $media_query_value) {
  1164.                                             continue (3);
  1165.                                         }
  1166.                                         break;
  1167.                                     default:
  1168.                                         Helpers::record_warnings(E_USER_WARNING, "Unknown media query: $media_query_feature", __FILE__, __LINE__);
  1169.                                         break;
  1170.                                 }
  1171.                             }
  1172.                         }
  1174.                         $style->merge($s);
  1175.                     }
  1176.                 }
  1177.             }
  1179.             // Handle inheritance
  1180.             if ($p && $DEBUGCSS) {
  1181.                 print "  inherit [\n";
  1182.                 $p->get_style()->debug_print();
  1183.                 print "  ]\n";
  1184.             }
  1186.             $style->inherit($p ? $p->get_style() : null);
  1188.             if ($DEBUGCSS) {
  1189.                 print "  DomElementStyle [\n";
  1190.                 $style->debug_print();
  1191.                 print "  ]\n";
  1192.                 print "]\n</pre>";
  1193.             }
  1195.             $style->clear_important();
  1196.             $frame->set_style($style);
  1198.             if (!$root_flg && $this->_page_styles["base"]) {
  1199.                 $root_flg = true;
  1201.                 // set the page width, height, and orientation based on the parsed page style
  1202.                 if ($style->size !== "auto") {
  1203.                     list($paper_width, $paper_height) = $style->size;
  1204.                 }
  1205.                 $paper_width = $paper_width - (float)$style->length_in_pt($style->margin_left) - (float)$style->length_in_pt($style->margin_right);
  1206.                 $paper_height = $paper_height - (float)$style->length_in_pt($style->margin_top) - (float)$style->length_in_pt($style->margin_bottom);
  1207.                 $paper_orientation = ($paper_width > $paper_height ? "landscape" : "portrait");
  1208.             }
  1209.         }
  1211.         // We're done!  Clean out the registry of all styles since we
  1212.         // won't be needing this later.
  1213.         foreach (array_keys($this->_styles) as $key) {
  1214.             $this->_styles[$key] = null;
  1215.             unset($this->_styles[$key]);
  1216.         }
  1217.     }
  1219.     /**
  1220.      * parse a CSS string using a regex parser
  1221.      * Called by {@link Stylesheet::parse_css()}
  1222.      *
  1223.      * @param string $str
  1224.      *
  1225.      * @throws Exception
  1226.      */
  1227.     private function _parse_css($str)
  1228.     {
  1229.         $str = trim($str);
  1231.         // Destroy comments and remove HTML comments
  1232.         $css = preg_replace([
  1233.             "'/\*.*?\*/'si",
  1234.             "/^<!--/",
  1235.             "/-->$/"
  1236.         ], "", $str);
  1238.         // FIXME: handle '{' within strings, e.g. [attr="string {}"]
  1240.         // Something more legible:
  1241.         $re =
  1242.             "/\s*                                   # Skip leading whitespace                             \n" .
  1243.             "( @([^\s{]+)\s*([^{;]*) (?:;|({)) )?   # Match @rules followed by ';' or '{'                 \n" .
  1244.             "(?(1)                                  # Only parse sub-sections if we're in an @rule...     \n" .
  1245.             "  (?(4)                                # ...and if there was a leading '{'                   \n" .
  1246.             "    \s*( (?:(?>[^{}]+) ({)?            # Parse rulesets and individual @page rules           \n" .
  1247.             "            (?(6) (?>[^}]*) }) \s*)+?                                                        \n" .
  1248.             "       )                                                                                     \n" .
  1249.             "   })                                  # Balancing '}'                                       \n" .
  1250.             "|                                      # Branch to match regular rules (not preceded by '@') \n" .
  1251.             "([^{]*{[^}]*}))                        # Parse normal rulesets                               \n" .
  1252.             "/xs";
  1254.         if (preg_match_all($re, $css, $matches, PREG_SET_ORDER) === false) {
  1255.             // An error occurred
  1256.             throw new Exception("Error parsing css file: preg_match_all() failed.");
  1257.         }
  1259.         // After matching, the array indices are set as follows:
  1260.         //
  1261.         // [0] => complete text of match
  1262.         // [1] => contains '@import ...;' or '@media {' if applicable
  1263.         // [2] => text following @ for cases where [1] is set
  1264.         // [3] => media types or full text following '@import ...;'
  1265.         // [4] => '{', if present
  1266.         // [5] => rulesets within media rules
  1267.         // [6] => '{', within media rules
  1268.         // [7] => individual rules, outside of media rules
  1269.         //
  1271.         $media_query_regex = "/(?:((only|not)?\s*(" . implode("|", self::$VALID_MEDIA_TYPES) . "))|(\s*\(\s*((?:(min|max)-)?([\w\-]+))\s*(?:\:\s*(.*?)\s*)?\)))/isx";
  1273.         //Helpers::pre_r($matches);
  1274.         foreach ($matches as $match) {
  1275.             $match[2] = trim($match[2]);
  1277.             if ($match[2] !== "") {
  1278.                 // Handle @rules
  1279.                 switch ($match[2]) {
  1281.                     case "import":
  1282.                         $this->_parse_import($match[3]);
  1283.                         break;
  1285.                     case "media":
  1286.                         $acceptedmedia = self::$ACCEPTED_GENERIC_MEDIA_TYPES;
  1287.                         $acceptedmedia[] = $this->_dompdf->getOptions()->getDefaultMediaType();
  1289.                         $media_queries = preg_split("/\s*,\s*/", mb_strtolower(trim($match[3])));
  1290.                         foreach ($media_queries as $media_query) {
  1291.                             if (in_array($media_query, $acceptedmedia)) {
  1292.                                 //if we have a media type match go ahead and parse the stylesheet
  1293.                                 $this->_parse_sections($match[5]);
  1294.                                 break;
  1295.                             } elseif (!in_array($media_query, self::$VALID_MEDIA_TYPES)) {
  1296.                                 // otherwise conditionally parse the stylesheet assuming there are parseable media queries
  1297.                                 if (preg_match_all($media_query_regex, $media_query, $media_query_matches, PREG_SET_ORDER) !== false) {
  1298.                                     $mq = [];
  1299.                                     foreach ($media_query_matches as $media_query_match) {
  1300.                                         if (empty($media_query_match[1]) === false) {
  1301.                                             $media_query_feature = strtolower($media_query_match[3]);
  1302.                                             $media_query_value = strtolower($media_query_match[2]);
  1303.                                             $mq[] = [$media_query_feature, $media_query_value];
  1304.                                         } elseif (empty($media_query_match[4]) === false) {
  1305.                                             $media_query_feature = strtolower($media_query_match[5]);
  1306.                                             $media_query_value = (array_key_exists(8, $media_query_match) ? strtolower($media_query_match[8]) : null);
  1307.                                             $mq[] = [$media_query_feature, $media_query_value];
  1308.                                         }
  1309.                                     }
  1310.                                     $this->_parse_sections($match[5], $mq);
  1311.                                     break;
  1312.                                 }
  1313.                             }
  1314.                         }
  1315.                         break;
  1317.                     case "page":
  1318.                         //This handles @page to be applied to page oriented media
  1319.                         //Note: This has a reduced syntax:
  1320.                         //@page { margin:1cm; color:blue; }
  1321.                         //Not a sequence of styles like a full.css, but only the properties
  1322.                         //of a single style, which is applied to the very first "root" frame before
  1323.                         //processing other styles of the frame.
  1324.                         //Working properties:
  1325.                         // margin (for margin around edge of paper)
  1326.                         // font-family (default font of pages)
  1327.                         // color (default text color of pages)
  1328.                         //Non working properties:
  1329.                         // border
  1330.                         // padding
  1331.                         // background-color
  1332.                         //Todo:Reason is unknown
  1333.                         //Other properties (like further font or border attributes) not tested.
  1334.                         //If a border or background color around each paper sheet is desired,
  1335.                         //assign it to the <body> tag, possibly only for the css of the correct media type.
  1337.                         // If the page has a name, skip the style.
  1338.                         $page_selector = trim($match[3]);
  1340.                         $key = null;
  1341.                         switch ($page_selector) {
  1342.                             case "":
  1343.                                 $key = "base";
  1344.                                 break;
  1346.                             case ":left":
  1347.                             case ":right":
  1348.                             case ":odd":
  1349.                             case ":even":
  1350.                             /** @noinspection PhpMissingBreakStatementInspection */
  1351.                             case ":first":
  1352.                                 $key = $page_selector;
  1353.                                 break;
  1355.                             default:
  1356.                                 break 2;
  1357.                         }
  1359.                         // Store the style for later...
  1360.                         if (empty($this->_page_styles[$key])) {
  1361.                             $this->_page_styles[$key] = $this->_parse_properties($match[5]);
  1362.                         } else {
  1363.                             $this->_page_styles[$key]->merge($this->_parse_properties($match[5]));
  1364.                         }
  1365.                         break;
  1367.                     case "font-face":
  1368.                         $this->_parse_font_face($match[5]);
  1369.                         break;
  1371.                     default:
  1372.                         // ignore everything else
  1373.                         break;
  1374.                 }
  1376.                 continue;
  1377.             }
  1379.             if ($match[7] !== "") {
  1380.                 $this->_parse_sections($match[7]);
  1381.             }
  1382.         }
  1383.     }
  1385.     /**
  1386.      * Resolve the given `url()` declaration to an absolute URL.
  1387.      *
  1388.      * @param string|null $val The declaration to resolve in the context of the stylesheet.
  1389.      * @return string The resolved URL, or `none`, if the value is `none`,
  1390.      *         invalid, or points to a non-existent local file.
  1391.      */
  1392.     public function resolve_url($val): string
  1393.     {
  1394.         $DEBUGCSS = $this->_dompdf->getOptions()->getDebugCss();
  1395.         $parsed_url = "none";
  1397.         if (empty($val) || $val === "none") {
  1398.             $path = "none";
  1399.         } elseif (mb_strpos($val, "url") === false) {
  1400.             $path = "none"; //Don't resolve no image -> otherwise would prefix path and no longer recognize as none
  1401.         } else {
  1402.             $val = preg_replace("/url\(\s*['\"]?([^'\")]+)['\"]?\s*\)/", "\\1", trim($val));
  1404.             // Resolve the url now in the context of the current stylesheet
  1405.             $path = Helpers::build_url($this->_protocol,
  1406.                 $this->_base_host,
  1407.                 $this->_base_path,
  1408.                 $val);
  1409.             if ($path === null) {
  1410.                 $path = "none";
  1411.             }
  1412.         }
  1413.         if ($DEBUGCSS) {
  1414.             $parsed_url = Helpers::explode_url($path);
  1415.             print "<pre>[_image\n";
  1416.             print_r($parsed_url);
  1417.             print $this->_protocol . "\n" . $this->_base_path . "\n" . $path . "\n";
  1418.             print "_image]</pre>";
  1419.         }
  1420.         return $path;
  1421.     }
  1423.     /**
  1424.      * parse @import{} sections
  1425.      *
  1426.      * @param string $url the url of the imported CSS file
  1427.      */
  1428.     private function _parse_import($url)
  1429.     {
  1430.         $arr = preg_split("/[\s\n,]/", $url, -1, PREG_SPLIT_NO_EMPTY);
  1431.         $url = array_shift($arr);
  1432.         $accept = false;
  1434.         if (count($arr) > 0) {
  1435.             $acceptedmedia = self::$ACCEPTED_GENERIC_MEDIA_TYPES;
  1436.             $acceptedmedia[] = $this->_dompdf->getOptions()->getDefaultMediaType();
  1438.             // @import url media_type [media_type...]
  1439.             foreach ($arr as $type) {
  1440.                 if (in_array(mb_strtolower(trim($type)), $acceptedmedia)) {
  1441.                     $accept = true;
  1442.                     break;
  1443.                 }
  1444.             }
  1446.         } else {
  1447.             // unconditional import
  1448.             $accept = true;
  1449.         }
  1451.         if ($accept) {
  1452.             // Store our current base url properties in case the new url is elsewhere
  1453.             $protocol = $this->_protocol;
  1454.             $host = $this->_base_host;
  1455.             $path = $this->_base_path;
  1457.             // $url = str_replace(array('"',"url", "(", ")"), "", $url);
  1458.             // If the protocol is php, assume that we will import using file://
  1459.             // $url = Helpers::build_url($protocol === "php://" ? "file://" : $protocol, $host, $path, $url);
  1460.             // Above does not work for subfolders and absolute urls.
  1461.             // Todo: As above, do we need to replace php or file to an empty protocol for local files?
  1463.             if (($url = $this->resolve_url($url)) !== "none") {
  1464.                 $this->load_css_file($url);
  1465.             }
  1467.             // Restore the current base url
  1468.             $this->_protocol = $protocol;
  1469.             $this->_base_host = $host;
  1470.             $this->_base_path = $path;
  1471.         }
  1472.     }
  1474.     /**
  1475.      * parse @font-face{} sections
  1476.      * http://www.w3.org/TR/css3-fonts/#the-font-face-rule
  1477.      *
  1478.      * @param string $str CSS @font-face rules
  1479.      */
  1480.     private function _parse_font_face($str)
  1481.     {
  1482.         $descriptors = $this->_parse_properties($str);
  1484.         preg_match_all("/(url|local)\s*\([\"\']?([^\"\'\)]+)[\"\']?\)\s*(format\s*\([\"\']?([^\"\'\)]+)[\"\']?\))?/i", $descriptors->src, $src);
  1486.         $valid_sources = [];
  1487.         foreach ($src[0] as $i => $value) {
  1488.             $source = [
  1489.                 "local" => strtolower($src[1][$i]) === "local",
  1490.                 "uri" => $src[2][$i],
  1491.                 "format" => strtolower($src[4][$i]),
  1492.                 "path" => Helpers::build_url($this->_protocol, $this->_base_host, $this->_base_path, $src[2][$i]),
  1493.             ];
  1495.             if (!$source["local"] && in_array($source["format"], ["", "truetype"]) && $source["path"] !== null) {
  1496.                 $valid_sources[] = $source;
  1497.             }
  1498.         }
  1500.         // No valid sources
  1501.         if (empty($valid_sources)) {
  1502.             return;
  1503.         }
  1505.         $style = [
  1506.             "family" => $descriptors->get_font_family_raw(),
  1507.             "weight" => $descriptors->font_weight,
  1508.             "style" => $descriptors->font_style,
  1509.         ];
  1511.         $this->getFontMetrics()->registerFont($style, $valid_sources[0]["path"], $this->_dompdf->getHttpContext());
  1512.     }
  1514.     /**
  1515.      * parse regular CSS blocks
  1516.      *
  1517.      * _parse_properties() creates a new Style object based on the provided
  1518.      * CSS rules.
  1519.      *
  1520.      * @param string $str CSS rules
  1521.      * @return Style
  1522.      */
  1523.     private function _parse_properties($str)
  1524.     {
  1525.         $properties = preg_split("/;(?=(?:[^\(]*\([^\)]*\))*(?![^\)]*\)))/", $str);
  1526.         $DEBUGCSS = $this->_dompdf->getOptions()->getDebugCss();
  1528.         if ($DEBUGCSS) {
  1529.             print '[_parse_properties';
  1530.         }
  1532.         // Create the style
  1533.         $style = new Style($this, Stylesheet::ORIG_AUTHOR);
  1535.         foreach ($properties as $prop) {
  1536.             // If the $prop contains an url, the regex may be wrong
  1537.             // @todo: fix the regex so that it works every time
  1538.             /*if (strpos($prop, "url(") === false) {
  1539.               if (preg_match("/([a-z-]+)\s*:\s*[^:]+$/i", $prop, $m))
  1540.                 $prop = $m[0];
  1541.             }*/
  1543.             //A css property can have " ! important" appended (whitespace optional)
  1544.             //strip this off to decode core of the property correctly.
  1546.             /* Instead of short code, prefer the typical case with fast code
  1547.           $important = preg_match("/(.*?)!\s*important/",$prop,$match);
  1548.             if ( $important ) {
  1549.               $prop = $match[1];
  1550.             }
  1551.             $prop = trim($prop);
  1552.             */
  1553.             if ($DEBUGCSS) print '(';
  1555.             $important = false;
  1556.             $prop = trim($prop);
  1558.             if (substr($prop, -9) === 'important') {
  1559.                 $prop_tmp = rtrim(substr($prop, 0, -9));
  1561.                 if (substr($prop_tmp, -1) === '!') {
  1562.                     $prop = rtrim(substr($prop_tmp, 0, -1));
  1563.                     $important = true;
  1564.                 }
  1565.             }
  1567.             if ($prop === "") {
  1568.                 if ($DEBUGCSS) print 'empty)';
  1569.                 continue;
  1570.             }
  1572.             $i = mb_strpos($prop, ":");
  1573.             if ($i === false) {
  1574.                 if ($DEBUGCSS) print 'novalue' . $prop . ')';
  1575.                 continue;
  1576.             }
  1578.             $prop_name = rtrim(mb_strtolower(mb_substr($prop, 0, $i)));
  1579.             $value = ltrim(mb_substr($prop, $i + 1));
  1581.             if ($DEBUGCSS) print $prop_name . ':=' . $value . ($important ? '!IMPORTANT' : '') . ')';
  1583.             $style->set_prop($prop_name, $value, $important, false);
  1584.         }
  1585.         if ($DEBUGCSS) print '_parse_properties]';
  1587.         return $style;
  1588.     }
  1590.     /**
  1591.      * parse selector + rulesets
  1592.      *
  1593.      * @param string $str CSS selectors and rulesets
  1594.      * @param array $media_queries
  1595.      */
  1596.     private function _parse_sections($str, $media_queries = [])
  1597.     {
  1598.         // Pre-process selectors: collapse all whitespace and strip whitespace
  1599.         // around '>', '.', ':', '+', '~', '#'
  1600.         $patterns = ["/\s+/", "/\s+([>.:+~#])\s+/"];
  1601.         $replacements = [" ", "\\1"];
  1602.         $DEBUGCSS = $this->_dompdf->getOptions()->getDebugCss();
  1604.         $sections = explode("}", $str);
  1605.         if ($DEBUGCSS) print '[_parse_sections';
  1606.         foreach ($sections as $sect) {
  1607.             $i = mb_strpos($sect, "{");
  1608.             if ($i === false) { continue; }
  1610.             if ($DEBUGCSS) print '[section';
  1612.             $selector_str = preg_replace($patterns, $replacements, mb_substr($sect, 0, $i));
  1613.             $selectors = preg_split("/,(?![^\(]*\))/", $selector_str, 0, PREG_SPLIT_NO_EMPTY);
  1614.             $style = $this->_parse_properties(trim(mb_substr($sect, $i + 1)));
  1616.             // Assign it to the selected elements
  1617.             foreach ($selectors as $selector) {
  1618.                 $selector = trim($selector);
  1620.                 if ($selector == "") {
  1621.                     if ($DEBUGCSS) print '#empty#';
  1622.                     continue;
  1623.                 }
  1624.                 if ($DEBUGCSS) print '#' . $selector . '#';
  1625.                 //if ($DEBUGCSS) { if (strpos($selector,'p') !== false) print '!!!p!!!#'; }
  1627.                 //FIXME: tag the selector with a hash of the media query to separate it from non-conditional styles (?), xpath comments are probably not what we want to do here
  1628.                 if (count($media_queries) > 0) {
  1629.                     $style->set_media_queries($media_queries);
  1630.                 }
  1631.                 $this->add_style($selector, $style);
  1632.             }
  1634.             if ($DEBUGCSS) {
  1635.                 print 'section]';
  1636.             }
  1637.         }
  1639.         if ($DEBUGCSS) {
  1640.             print "_parse_sections]\n";
  1641.         }
  1642.     }
  1644.     /**
  1645.      * @return string
  1646.      */
  1647.     public function getDefaultStylesheet()
  1648.     {
  1649.         $options = $this->_dompdf->getOptions();
  1650.         $rootDir = realpath($options->getRootDir());
  1651.         return Helpers::build_url("file://", "", $rootDir, $rootDir . self::DEFAULT_STYLESHEET);
  1652.     }
  1654.     /**
  1655.      * @param FontMetrics $fontMetrics
  1656.      * @return $this
  1657.      */
  1658.     public function setFontMetrics(FontMetrics $fontMetrics)
  1659.     {
  1660.         $this->fontMetrics = $fontMetrics;
  1661.         return $this;
  1662.     }
  1664.     /**
  1665.      * @return FontMetrics
  1666.      */
  1667.     public function getFontMetrics()
  1668.     {
  1669.         return $this->fontMetrics;
  1670.     }
  1672.     /**
  1673.      * dumps the entire stylesheet as a string
  1674.      *
  1675.      * Generates a string of each selector and associated style in the
  1676.      * Stylesheet.  Useful for debugging.
  1677.      *
  1678.      * @return string
  1679.      */
  1680.     function __toString()
  1681.     {
  1682.         $str = "";
  1683.         foreach ($this->_styles as $selector => $selector_styles) {
  1684.             /** @var Style $style */
  1685.             foreach ($selector_styles as $style) {
  1686.                 $str .= "$selector => " . $style->__toString() . "\n";
  1687.             }
  1688.         }
  1690.         return $str;
  1691.     }
  1692. }