/var/www/html/demo/megastore.7uptheme.net/wp-admin/user/credits.php

GIF89; /var/www/html/demo/megastore.7uptheme.net/wp-admin/user/credits.php

CMS: WordPress Server IP: 176.31.116.194 Root: /var/www/html/demo/megastore.7uptheme.net Directory: var/www/html/demo/goodshop.7uptheme.net/wp-content/plugins/woocommerce/includes/libraries/Emogrifier
File: /var/www/html/demo/goodshop.7uptheme.net/wp-content/plugins/woocommerce/includes/libraries/Emogrifier/CssInliner.php <?php namespace Pelago\Emogrifier; use Symfony\Component\CssSelector\CssSelectorConverter; use Symfony\Component\CssSelector\Exception\SyntaxErrorException; /** * This class provides functions for converting CSS styles into inline style attributes in your HTML code. * * For Emogrifier 3.0.0, this will be the successor to the \Pelago\Emogrifier class (which then will be deprecated). * * For more information, please see the README.md file. * * @internal This class currently is a new technology preview, and its API is still in flux. Don't use it in production. * * @author Cameron Brooks * @author Jaime Prado * @author Oliver Klee <github@oliverklee.de> * @author Roman Ožana <ozana@omdesign.cz> * @author Sander Kruger <s.kruger@invessel.com> * @author Zoli Szabó <zoli.szabo+github@gmail.com> / class CssInliner { /* * @var int / const CACHE_KEY_CSS = 0; /* * @var int / const CACHE_KEY_SELECTOR = 1; /* * @var int / const CACHE_KEY_CSS_DECLARATIONS_BLOCK = 2; /* * @var int / const CACHE_KEY_COMBINED_STYLES = 3; /* * Regular expression component matching a static pseudo class in a selector, without the preceding ":", * for which the applicable elements can be determined (by converting the selector to an XPath expression). * (Contains alternation without a group and is intended to be placed within a capturing, non-capturing or lookahead * group, as appropriate for the usage context.) * * @var string / const PSEUDO_CLASS_MATCHER = '\\S+\\-(?:child\|type\$)\|not\\([[:ascii:]]\$'; /** * @var string / const CONTENT_TYPE_META_TAG = '<meta http-equiv="Content-Type" content="text/html; charset=utf-8">'; /* * @var string / const DEFAULT_DOCUMENT_TYPE = '<!DOCTYPE html>'; /* * @var \DOMDocument / protected $domDocument = null; /* * @var string / private $css = ''; /* * @var bool[] / private $excludedSelectors = []; /* * @var string[] / private $unprocessableHtmlTags = ['wbr']; /* * @var bool[] / private $allowedMediaTypes = ['all' => true, 'screen' => true, 'print' => true]; /* * @var mixed[] / private $caches = [ self::CACHE_KEY_CSS => [], self::CACHE_KEY_SELECTOR => [], self::CACHE_KEY_CSS_DECLARATIONS_BLOCK => [], self::CACHE_KEY_COMBINED_STYLES => [], ]; /* * @var CssSelectorConverter / private $cssSelectorConverter = null; /* * the visited nodes with the XPath paths as array keys * * @var \DOMElement[] / private $visitedNodes = []; /* * the styles to apply to the nodes with the XPath paths as array keys for the outer array * and the attribute names/values as key/value pairs for the inner array * * @var string[][] / private $styleAttributesForNodes = []; /* * Determines whether the "style" attributes of tags in the the HTML passed to this class should be preserved. * If set to false, the value of the style attributes will be discarded. * * @var bool / private $isInlineStyleAttributesParsingEnabled = true; /* * Determines whether the <style> blocks in the HTML passed to this class should be parsed. * * If set to true, the <style> blocks will be removed from the HTML and their contents will be applied to the HTML * via inline styles. * * If set to false, the <style> blocks will be left as they are in the HTML. * * @var bool / private $isStyleBlocksParsingEnabled = true; /* * Determines whether elements with the `display: none` property are * removed from the DOM. * * @var bool / private $shouldRemoveInvisibleNodes = true; /* * For calculating selector precedence order. * Keys are a regular expression part to match before a CSS name. * Values are a multiplier factor per match to weight specificity. * * @var int[] / private $selectorPrecedenceMatchers = [ // IDs: worth 10000 '\\#' => 10000, // classes, attributes, pseudo-classes (not pseudo-elements) except `:not`: worth 100 '(?:\\.\|\\[\|(?<!:):(?!not\\())' => 100, // elements (not attribute values or `:not`), pseudo-elements: worth 1 '(?:(?<![="\':\\w\\-])\|::)' => 1, ]; /* * Emogrifier will throw Exceptions when it encounters an error instead of silently ignoring them. * * @var bool / private $debug = false; /* * @param string $unprocessedHtml raw HTML, must be UTF-encoded, must not be empty * * @throws \InvalidArgumentException if $unprocessedHtml is anything other than a non-empty string / public function __construct($unprocessedHtml) { if (!\is_string($unprocessedHtml)) { throw new \InvalidArgumentException('The provided HTML must be a string.', 1540403176); } if ($unprocessedHtml === '') { throw new \InvalidArgumentException('The provided HTML must not be empty.', 1540403181); } $this->cssSelectorConverter = new CssSelectorConverter(); $this->setHtml($unprocessedHtml); } /* * Sets the HTML to process. * * @param string $html the HTML to process, must be UTF-8-encoded * * @return void / private function setHtml($html) { $this->createUnifiedDomDocument($html); } /* * Provides access to the internal DOMDocument representation of the HTML in its current state. * * @return \DOMDocument / public function getDomDocument() { return $this->domDocument; } /* * Sets the CSS to merge with the HTML. * * @param string $css the CSS to merge, must be UTF-8-encoded * * @return void / public function setCss($css) { $this->css = $css; } /* * Renders the normalized and processed HTML. * * @return string / public function render() { return $this->domDocument->saveHTML(); } /* * Renders the content of the BODY element of the normalized and processed HTML. * * @return string / public function renderBodyContent() { $bodyNodeHtml = $this->domDocument->saveHTML($this->getBodyElement()); return \str_replace(['<body>', '</body>'], '', $bodyNodeHtml); } /* * Returns the BODY element. * * This method assumes that there always is a BODY element. * * @return \DOMElement / private function getBodyElement() { return $this->domDocument->getElementsByTagName('body')->item(0); } /* * Returns the HEAD element. * * This method assumes that there always is a HEAD element. * * @return \DOMElement / private function getHeadElement() { return $this->domDocument->getElementsByTagName('head')->item(0); } /* * Applies $this->css to the given HTML and returns the HTML with the CSS * applied. * * This method places the CSS inline. * * @return string * * @throws SyntaxErrorException / public function emogrify() { $this->process(); return $this->render(); } /* * Applies $this->css to the given HTML and returns only the HTML content * within the <body> tag. * * This method places the CSS inline. * * @return string * * @throws SyntaxErrorException / public function emogrifyBodyContent() { $this->process(); return $this->renderBodyContent(); } /* * Creates a DOM document from the given HTML and stores it in $this->domDocument. * * The DOM document will always have a BODY element and a document type. * * @param string $html * * @return void / private function createUnifiedDomDocument($html) { $this->createRawDomDocument($html); $this->ensureExistenceOfBodyElement(); } /* * Creates a DOMDocument instance from the given HTML and stores it in $this->domDocument. * * @param string $html * * @return void / private function createRawDomDocument($html) { $domDocument = new \DOMDocument(); $domDocument->encoding = 'UTF-8'; $domDocument->strictErrorChecking = false; $domDocument->formatOutput = true; $libXmlState = \libxml_use_internal_errors(true); $domDocument->loadHTML($this->prepareHtmlForDomConversion($html)); \libxml_clear_errors(); \libxml_use_internal_errors($libXmlState); $domDocument->normalizeDocument(); $this->domDocument = $domDocument; } /* * Returns the HTML with added document type and Content-Type meta tag if needed, * ensuring that the HTML will be good for creating a DOM document from it. * * @param string $html * * @return string the unified HTML / private function prepareHtmlForDomConversion($html) { $htmlWithDocumentType = $this->ensureDocumentType($html); return $this->addContentTypeMetaTag($htmlWithDocumentType); } /* * Applies $this->css to $this->domDocument. * * This method places the CSS inline. * * @return void * * @throws SyntaxErrorException / protected function process() { $this->clearAllCaches(); $this->purgeVisitedNodes(); $xPath = new \DOMXPath($this->domDocument); $this->removeUnprocessableTags(); $this->normalizeStyleAttributesOfAllNodes($xPath); // grab any existing style blocks from the html and append them to the existing CSS // (these blocks should be appended so as to have precedence over conflicting styles in the existing CSS) $allCss = $this->css; if ($this->isStyleBlocksParsingEnabled) { $allCss .= $this->getCssFromAllStyleNodes($xPath); } $excludedNodes = $this->getNodesToExclude($xPath); $cssRules = $this->parseCssRules($allCss); foreach ($cssRules['inlineable'] as $cssRule) { try { $nodesMatchingCssSelectors = $xPath->query($this->cssSelectorConverter->toXPath($cssRule['selector'])); } catch (SyntaxErrorException $e) { if ($this->debug) { throw $e; } continue; } /* @var \DOMElement $node / foreach ($nodesMatchingCssSelectors as $node) { if (\in_array($node, $excludedNodes, true)) { continue; } $this->copyInlineableCssToStyleAttribute($node, $cssRule); } } if ($this->isInlineStyleAttributesParsingEnabled) { $this->fillStyleAttributesWithMergedStyles(); } $this->postProcess($xPath); $this->removeImportantAnnotationFromAllInlineStyles($xPath); $this->copyUninlineableCssToStyleNode($xPath, $cssRules['uninlineable']); } /* * Applies some optional post-processing to the HTML in the DOM document. * * @param \DOMXPath $xPath * * @return void / private function postProcess(\DOMXPath $xPath) { if ($this->shouldRemoveInvisibleNodes) { $this->removeInvisibleNodes($xPath); } } /* * Searches for all nodes with a style attribute and removes the "!important" annotations out of * the inline style declarations, eventually by rearranging declarations. * * @param \DOMXPath $xPath * * @return void / private function removeImportantAnnotationFromAllInlineStyles(\DOMXPath $xPath) { foreach ($this->getAllNodesWithStyleAttribute($xPath) as $node) { $this->removeImportantAnnotationFromNodeInlineStyle($node); } } /* * Removes the "!important" annotations out of the inline style declarations, * eventually by rearranging declarations. * Rearranging needed when !important shorthand properties are followed by some of their * not !important expanded-version properties. * For example "font: 12px serif !important; font-size: 13px;" must be reordered * to "font-size: 13px; font: 12px serif;" in order to remain correct. * * @param \DOMElement $node * * @return void / private function removeImportantAnnotationFromNodeInlineStyle(\DOMElement $node) { $inlineStyleDeclarations = $this->parseCssDeclarationsBlock($node->getAttribute('style')); $regularStyleDeclarations = []; $importantStyleDeclarations = []; foreach ($inlineStyleDeclarations as $property => $value) { if ($this->attributeValueIsImportant($value)) { $importantStyleDeclarations[$property] = \trim(\str_replace('!important', '', $value)); } else { $regularStyleDeclarations[$property] = $value; } } $inlineStyleDeclarationsInNewOrder = \array_merge( $regularStyleDeclarations, $importantStyleDeclarations ); $node->setAttribute( 'style', $this->generateStyleStringFromSingleDeclarationsArray($inlineStyleDeclarationsInNewOrder) ); } /* * Returns a list with all DOM nodes that have a style attribute. * * @param \DOMXPath $xPath * * @return \DOMNodeList / private function getAllNodesWithStyleAttribute(\DOMXPath $xPath) { return $xPath->query('//[@style]'); } /** * Extracts and parses the individual rules from a CSS string. * * @param string $css a string of raw CSS code * * @return string[][][] A 2-entry array with the key "inlineable" containing rules which can be inlined as `style` * attributes and the key "uninlineable" containing rules which cannot. Each value is an array of string * sub-arrays with the keys * "media" (the media query string, e.g. "@media screen and (max-width: 480px)", * or an empty string if not from a `@media` rule), * "selector" (the CSS selector, e.g., "" or "header h1"), "hasUnmatchablePseudo" (true if that selector contains psuedo-elements or dynamic pseudo-classes * such that the declarations cannot be applied inline), * "declarationsBlock" (the semicolon-separated CSS declarations for that selector, * e.g., "color: red; height: 4px;"), * and "line" (the line number e.g. 42) / private function parseCssRules($css) { $cssKey = \md5($css); if (!isset($this->caches[static::CACHE_KEY_CSS][$cssKey])) { $matches = $this->getCssRuleMatches($css); $cssRules = [ 'inlineable' => [], 'uninlineable' => [], ]; /* @var string[][] $matches / /* @var string[] $cssRule / foreach ($matches as $key => $cssRule) { $cssDeclaration = \trim($cssRule['declarations']); if ($cssDeclaration === '') { continue; } $selectors = \explode(',', $cssRule['selectors']); foreach ($selectors as $selector) { // don't process pseudo-elements and behavioral (dynamic) pseudo-classes; // only allow structural pseudo-classes $hasPseudoElement = \strpos($selector, '::') !== false; $hasUnsupportedPseudoClass = (bool)\preg_match( '/:(?!' . static::PSEUDO_CLASS_MATCHER . ')[\\w\\-]/i', $selector ); $hasUnmatchablePseudo = $hasPseudoElement \|\| $hasUnsupportedPseudoClass; $parsedCssRule = [ 'media' => $cssRule['media'], 'selector' => \trim($selector), 'hasUnmatchablePseudo' => $hasUnmatchablePseudo, 'declarationsBlock' => $cssDeclaration, // keep track of where it appears in the file, since order is important 'line' => $key, ]; $ruleType = ($cssRule['media'] === '' && !$hasUnmatchablePseudo) ? 'inlineable' : 'uninlineable'; $cssRules[$ruleType][] = $parsedCssRule; } } \usort($cssRules['inlineable'], [$this, 'sortBySelectorPrecedence']); $this->caches[static::CACHE_KEY_CSS][$cssKey] = $cssRules; } return $this->caches[static::CACHE_KEY_CSS][$cssKey]; } /* * Parses a string of CSS into the media query, selectors and declarations for each ruleset in order. * * @param string $css * * @return string[][] Array of string sub-arrays with the keys * "media" (the media query string, e.g. "@media screen and (max-width: 480px)", * or an empty string if not from an `@media` rule), * "selectors" (the CSS selector(s), e.g., "" or "h1, h2"), "declarations" (the semicolon-separated CSS declarations for that/those selector(s), * e.g., "color: red; height: 4px;"), / private function getCssRuleMatches($css) { $ruleMatches = []; $splitCss = $this->splitCssAndMediaQuery($css); foreach ($splitCss as $cssPart) { // process each part for selectors and definitions \preg_match_all('/(?:^\|[\\s^{}])([^{]+){([^}])}/mi', $cssPart['css'], $matches, PREG_SET_ORDER); /* @var string[][] $matches / foreach ($matches as $cssRule) { $ruleMatches[] = [ 'media' => $cssPart['media'], 'selectors' => $cssRule[1], 'declarations' => $cssRule[2], ]; } } return $ruleMatches; } /* * Disables the parsing of inline styles. * * @return void / public function disableInlineStyleAttributesParsing() { $this->isInlineStyleAttributesParsingEnabled = false; } /* * Disables the parsing of <style> blocks. * * @return void / public function disableStyleBlocksParsing() { $this->isStyleBlocksParsingEnabled = false; } /* * Disables the removal of elements with `display: none` properties. * * @deprecated will be removed in Emogrifier 3.0 * * @return void / public function disableInvisibleNodeRemoval() { $this->shouldRemoveInvisibleNodes = false; } /* * Clears all caches. * * @return void / private function clearAllCaches() { $this->caches = [ static::CACHE_KEY_CSS => [], static::CACHE_KEY_SELECTOR => [], static::CACHE_KEY_CSS_DECLARATIONS_BLOCK => [], static::CACHE_KEY_COMBINED_STYLES => [], ]; } /* * Purges the visited nodes. * * @return void / private function purgeVisitedNodes() { $this->visitedNodes = []; $this->styleAttributesForNodes = []; } /* * Marks a tag for removal. * * There are some HTML tags that DOMDocument cannot process, and it will throw an error if it encounters them. * In particular, DOMDocument will complain if you try to use HTML5 tags in an XHTML document. * * Note: The tags will not be removed if they have any content. * * @param string $tagName the tag name, e.g., "p" * * @return void / public function addUnprocessableHtmlTag($tagName) { $this->unprocessableHtmlTags[] = $tagName; } /* * Drops a tag from the removal list. * * @param string $tagName the tag name, e.g., "p" * * @return void / public function removeUnprocessableHtmlTag($tagName) { $key = \array_search($tagName, $this->unprocessableHtmlTags, true); if ($key !== false) { unset($this->unprocessableHtmlTags[$key]); } } /* * Marks a media query type to keep. * * @param string $mediaName the media type name, e.g., "braille" * * @return void / public function addAllowedMediaType($mediaName) { $this->allowedMediaTypes[$mediaName] = true; } /* * Drops a media query type from the allowed list. * * @param string $mediaName the tag name, e.g., "braille" * * @return void / public function removeAllowedMediaType($mediaName) { if (isset($this->allowedMediaTypes[$mediaName])) { unset($this->allowedMediaTypes[$mediaName]); } } /* * Adds a selector to exclude nodes from emogrification. * * Any nodes that match the selector will not have their style altered. * * @param string $selector the selector to exclude, e.g., ".editor" * * @return void / public function addExcludedSelector($selector) { $this->excludedSelectors[$selector] = true; } /* * No longer excludes the nodes matching this selector from emogrification. * * @param string $selector the selector to no longer exclude, e.g., ".editor" * * @return void / public function removeExcludedSelector($selector) { if (isset($this->excludedSelectors[$selector])) { unset($this->excludedSelectors[$selector]); } } /* * This removes styles from your email that contain display:none. * We need to look for display:none, but we need to do a case-insensitive search. Since DOMDocument only * supports XPath 1.0, lower-case() isn't available to us. We've thus far only set attributes to lowercase, * not attribute values. Consequently, we need to translate() the letters that would be in 'NONE' ("NOE") * to lowercase. * * @param \DOMXPath $xPath * * @return void / private function removeInvisibleNodes(\DOMXPath $xPath) { $nodesWithStyleDisplayNone = $xPath->query( '//[contains(translate(translate(@style," ",""),"NOE","noe"),"display:none")]' ); if ($nodesWithStyleDisplayNone->length === 0) { return; } // The checks on parentNode and is_callable below ensure that if we've deleted the parent node, // we don't try to call removeChild on a nonexistent child node /** @var \DOMNode $node / foreach ($nodesWithStyleDisplayNone as $node) { if ($node->parentNode && \is_callable([$node->parentNode, 'removeChild'])) { $node->parentNode->removeChild($node); } } } /* * Parses the document and normalizes all existing CSS attributes. * This changes 'DISPLAY: none' to 'display: none'. * We wouldn't have to do this if DOMXPath supported XPath 2.0. * Also stores a reference of nodes with existing inline styles so we don't overwrite them. * * @param \DOMXPath $xPath * * @return void / private function normalizeStyleAttributesOfAllNodes(\DOMXPath $xPath) { /* @var \DOMElement $node / foreach ($this->getAllNodesWithStyleAttribute($xPath) as $node) { if ($this->isInlineStyleAttributesParsingEnabled) { $this->normalizeStyleAttributes($node); } // Remove style attribute in every case, so we can add them back (if inline style attributes // parsing is enabled) to the end of the style list, thus keeping the right priority of CSS rules; // else original inline style rules may remain at the beginning of the final inline style definition // of a node, which may give not the desired results $node->removeAttribute('style'); } } /* * Normalizes the value of the "style" attribute and saves it. * * @param \DOMElement $node * * @return void / private function normalizeStyleAttributes(\DOMElement $node) { $normalizedOriginalStyle = \preg_replace_callback( '/[A-z\\-]+(?=\\:)/S', function (array $m) { return \strtolower($m[0]); }, $node->getAttribute('style') ); // in order to not overwrite existing style attributes in the HTML, we // have to save the original HTML styles $nodePath = $node->getNodePath(); if (!isset($this->styleAttributesForNodes[$nodePath])) { $this->styleAttributesForNodes[$nodePath] = $this->parseCssDeclarationsBlock($normalizedOriginalStyle); $this->visitedNodes[$nodePath] = $node; } $node->setAttribute('style', $normalizedOriginalStyle); } /* * Merges styles from styles attributes and style nodes and applies them to the attribute nodes * * @return void / private function fillStyleAttributesWithMergedStyles() { foreach ($this->styleAttributesForNodes as $nodePath => $styleAttributesForNode) { $node = $this->visitedNodes[$nodePath]; $currentStyleAttributes = $this->parseCssDeclarationsBlock($node->getAttribute('style')); $node->setAttribute( 'style', $this->generateStyleStringFromDeclarationsArrays( $currentStyleAttributes, $styleAttributesForNode ) ); } } /* * This method merges old or existing name/value array with new name/value array * and then generates a string of the combined style suitable for placing inline. * This becomes the single point for CSS string generation allowing for consistent * CSS output no matter where the CSS originally came from. * * @param string[] $oldStyles * @param string[] $newStyles * * @return string / private function generateStyleStringFromDeclarationsArrays(array $oldStyles, array $newStyles) { $cacheKey = \serialize([$oldStyles, $newStyles]); if (isset($this->caches[static::CACHE_KEY_COMBINED_STYLES][$cacheKey])) { return $this->caches[static::CACHE_KEY_COMBINED_STYLES][$cacheKey]; } // Unset the overridden styles to preserve order, important if shorthand and individual properties are mixed foreach ($oldStyles as $attributeName => $attributeValue) { if (!isset($newStyles[$attributeName])) { continue; } $newAttributeValue = $newStyles[$attributeName]; if ($this->attributeValueIsImportant($attributeValue) && !$this->attributeValueIsImportant($newAttributeValue) ) { unset($newStyles[$attributeName]); } else { unset($oldStyles[$attributeName]); } } $combinedStyles = \array_merge($oldStyles, $newStyles); $style = ''; foreach ($combinedStyles as $attributeName => $attributeValue) { $style .= \strtolower(\trim($attributeName)) . ': ' . \trim($attributeValue) . '; '; } $trimmedStyle = \rtrim($style); $this->caches[static::CACHE_KEY_COMBINED_STYLES][$cacheKey] = $trimmedStyle; return $trimmedStyle; } /* * Generates a CSS style string suitable to be used inline from the $styleDeclarations property => value array. * * @param string[] $styleDeclarations * * @return string / private function generateStyleStringFromSingleDeclarationsArray(array $styleDeclarations) { return $this->generateStyleStringFromDeclarationsArrays([], $styleDeclarations); } /* * Checks whether $attributeValue is marked as !important. * * @param string $attributeValue * * @return bool / private function attributeValueIsImportant($attributeValue) { return \strtolower(\substr(\trim($attributeValue), -10)) === '!important'; } /* * Applies $cssRules to $this->domDocument, limited to the rules that actually apply to the document. * * @param \DOMXPath $xPath * @param string[][] $cssRules The "uninlineable" array of CSS rules returned by `parseCssRules` * * @return void / private function copyUninlineableCssToStyleNode(\DOMXPath $xPath, array $cssRules) { $cssRulesRelevantForDocument = \array_filter( $cssRules, function (array $cssRule) use ($xPath) { $selector = $cssRule['selector']; if ($cssRule['hasUnmatchablePseudo']) { $selector = $this->removeUnmatchablePseudoComponents($selector); } return $this->existsMatchForCssSelector($xPath, $selector); } ); if ($cssRulesRelevantForDocument === []) { // avoid adding empty style element (or including unneeded class dependency) return; } $cssConcatenator = new CssConcatenator(); foreach ($cssRulesRelevantForDocument as $cssRule) { $cssConcatenator->append([$cssRule['selector']], $cssRule['declarationsBlock'], $cssRule['media']); } $this->addStyleElementToDocument($cssConcatenator->getCss()); } /* * Removes pseudo-elements and dynamic pseudo-classes from a CSS selector, replacing them with "" if necessary. * @param string $selector * * @return string Selector which will match the relevant DOM elements if the pseudo-classes are assumed to apply, * or in the case of pseudo-elements will match their originating element. / private function removeUnmatchablePseudoComponents($selector) { $pseudoComponentMatcher = ':(?!' . static::PSEUDO_CLASS_MATCHER . '):?+[\\w\\-]++(?:\$[^\$]+\\))?+'; return \preg_replace( ['/(\\s\|^)' . $pseudoComponentMatcher . '/i', '/' . $pseudoComponentMatcher . '/i'], ['$1', ''], $selector ); } /* * Copies $cssRule into the style attribute of $node. * * Note: This method does not check whether $cssRule matches $node. * * @param \DOMElement $node * @param string[][] $cssRule * * @return void / private function copyInlineableCssToStyleAttribute(\DOMElement $node, array $cssRule) { // if it has a style attribute, get it, process it, and append (overwrite) new stuff if ($node->hasAttribute('style')) { // break it up into an associative array $oldStyleDeclarations = $this->parseCssDeclarationsBlock($node->getAttribute('style')); } else { $oldStyleDeclarations = []; } $newStyleDeclarations = $this->parseCssDeclarationsBlock($cssRule['declarationsBlock']); $node->setAttribute( 'style', $this->generateStyleStringFromDeclarationsArrays($oldStyleDeclarations, $newStyleDeclarations) ); } /* * Checks whether there is at least one matching element for $cssSelector. * When not in debug mode, it returns true also for invalid selectors (because they may be valid, * just not implemented/recognized yet by Emogrifier). * * @param \DOMXPath $xPath * @param string $cssSelector * * @return bool * * @throws SyntaxErrorException / private function existsMatchForCssSelector(\DOMXPath $xPath, $cssSelector) { try { $nodesMatchingSelector = $xPath->query($this->cssSelectorConverter->toXPath($cssSelector)); } catch (SyntaxErrorException $e) { if ($this->debug) { throw $e; } return true; } return $nodesMatchingSelector !== false && $nodesMatchingSelector->length !== 0; } /* * Returns CSS content. * * @param \DOMXPath $xPath * * @return string / private function getCssFromAllStyleNodes(\DOMXPath $xPath) { $styleNodes = $xPath->query('//style'); if ($styleNodes === false) { return ''; } $css = ''; /* @var \DOMNode $styleNode / foreach ($styleNodes as $styleNode) { $css .= "\n\n" . $styleNode->nodeValue; $styleNode->parentNode->removeChild($styleNode); } return $css; } /* * Adds a style element with $css to $this->domDocument. * * This method is protected to allow overriding. * * @see https://github.com/jjriv/emogrifier/issues/103 * * @param string $css * * @return void / protected function addStyleElementToDocument($css) { $styleElement = $this->domDocument->createElement('style', $css); $styleAttribute = $this->domDocument->createAttribute('type'); $styleAttribute->value = 'text/css'; $styleElement->appendChild($styleAttribute); $headElement = $this->getHeadElement(); $headElement->appendChild($styleElement); } /* * Checks that $this->domDocument has a BODY element and adds it if it is missing. * * @return void / private function ensureExistenceOfBodyElement() { if ($this->domDocument->getElementsByTagName('body')->item(0) !== null) { return; } $htmlElement = $this->domDocument->getElementsByTagName('html')->item(0); $htmlElement->appendChild($this->domDocument->createElement('body')); } /* * Splits input CSS code into an array of parts for different media querues, in order. * Each part is an array where: * * - key "css" will contain clean CSS code (for @media rules this will be the group rule body within "{...}") * - key "media" will contain "@media " followed by the media query list, for all allowed media queries, * or an empty string for CSS not within a media query * * Example: * * The CSS code * * "@import "file.css"; h1 { color:red; } @media { h1 {}} @media tv { h1 {}}" * * will be parsed into the following array: * * 0 => [ * "css" => "h1 { color:red; }", * "media" => "" * ], * 1 => [ * "css" => " h1 {}", * "media" => "@media " * ] * * @param string $css * * @return string[][] / private function splitCssAndMediaQuery($css) { $cssWithoutComments = \preg_replace('/\\/\\.\\\\//sU', '', $css); $mediaTypesExpression = ''; if (!empty($this->allowedMediaTypes)) { $mediaTypesExpression = '\|' . \implode('\|', \array_keys($this->allowedMediaTypes)); } $mediaRuleBodyMatcher = '[^{]+{(?:[^{}]+{.})?\\s+}\\s+'; $cssSplitForAllowedMediaTypes = \preg_split( '#(@media\\s++(?:only\\s++)?+(?:(?=[{\\(])' . $mediaTypesExpression . ')' . $mediaRuleBodyMatcher . ')#misU', $cssWithoutComments, -1, PREG_SPLIT_DELIM_CAPTURE ); // filter the CSS outside/between allowed @media rules $cssCleaningMatchers = [ 'import/charset directives' => '/\\s+@(?:import\|charset)\\s[^;]++;/i', 'remaining media enclosures' => '/\\s+@media\\s' . $mediaRuleBodyMatcher . '/isU', ]; $splitCss = []; foreach ($cssSplitForAllowedMediaTypes as $index => $cssPart) { $isMediaRule = $index % 2 !== 0; if ($isMediaRule) { \preg_match('/^([^{]+){(.)}[^}]+$/s', $cssPart, $matches); $splitCss[] = [ 'css' => $matches[2], 'media' => $matches[1], ]; } else { $cleanedCss = \trim(\preg_replace($cssCleaningMatchers, '', $cssPart)); if ($cleanedCss !== '') { $splitCss[] = [ 'css' => $cleanedCss, 'media' => '', ]; } } } return $splitCss; } /** * Removes empty unprocessable tags from the DOM document. * * @return void / private function removeUnprocessableTags() { foreach ($this->unprocessableHtmlTags as $tagName) { $nodes = $this->domDocument->getElementsByTagName($tagName); /* @var \DOMNode $node / foreach ($nodes as $node) { $hasContent = $node->hasChildNodes() \|\| $node->hasChildNodes(); if (!$hasContent) { $node->parentNode->removeChild($node); } } } } /* * Makes sure that the passed HTML has a document type. * * @param string $html * * @return string HTML with document type / private function ensureDocumentType($html) { $hasDocumentType = \stripos($html, '<!DOCTYPE') !== false; if ($hasDocumentType) { return $html; } return static::DEFAULT_DOCUMENT_TYPE . $html; } /* * Adds a Content-Type meta tag for the charset. * * This method also ensures that there is a HEAD element. * * @param string $html * * @return string the HTML with the meta tag added / private function addContentTypeMetaTag($html) { $hasContentTypeMetaTag = \stripos($html, 'Content-Type') !== false; if ($hasContentTypeMetaTag) { return $html; } // We are trying to insert the meta tag to the right spot in the DOM. // If we just prepended it to the HTML, we would lose attributes set to the HTML tag. $hasHeadTag = \stripos($html, '<head') !== false; $hasHtmlTag = \stripos($html, '<html') !== false; if ($hasHeadTag) { $reworkedHtml = \preg_replace('/<head(.?)>/i', '<head$1>' . static::CONTENT_TYPE_META_TAG, $html); } elseif ($hasHtmlTag) { $reworkedHtml = \preg_replace( '/<html(.?)>/i', '<html$1><head>' . static::CONTENT_TYPE_META_TAG . '</head>', $html ); } else { $reworkedHtml = static::CONTENT_TYPE_META_TAG . $html; } return $reworkedHtml; } /* * @param string[] $a * @param string[] $b * * @return int / private function sortBySelectorPrecedence(array $a, array $b) { $precedenceA = $this->getCssSelectorPrecedence($a['selector']); $precedenceB = $this->getCssSelectorPrecedence($b['selector']); // We want these sorted in ascending order so selectors with lesser precedence get processed first and // selectors with greater precedence get sorted last. $precedenceForEquals = ($a['line'] < $b['line'] ? -1 : 1); $precedenceForNotEquals = ($precedenceA < $precedenceB ? -1 : 1); return ($precedenceA === $precedenceB) ? $precedenceForEquals : $precedenceForNotEquals; } /* * @param string $selector * * @return int / private function getCssSelectorPrecedence($selector) { $selectorKey = \md5($selector); if (!isset($this->caches[static::CACHE_KEY_SELECTOR][$selectorKey])) { $precedence = 0; foreach ($this->selectorPrecedenceMatchers as $matcher => $value) { if (\trim($selector) === '') { break; } $number = 0; $selector = \preg_replace('/' . $matcher . '\\w+/', '', $selector, -1, $number); $precedence += ($value $number); } $this->caches[static::CACHE_KEY_SELECTOR][$selectorKey] = $precedence; } return $this->caches[static::CACHE_KEY_SELECTOR][$selectorKey]; } /** * Parses a CSS declaration block into property name/value pairs. * * Example: * * The declaration block * * "color: #000; font-weight: bold;" * * will be parsed into the following array: * * "color" => "#000" * "font-weight" => "bold" * * @param string $cssDeclarationsBlock the CSS declarations block without the curly braces, may be empty * * @return string[] * the CSS declarations with the property names as array keys and the property values as array values / private function parseCssDeclarationsBlock($cssDeclarationsBlock) { if (isset($this->caches[static::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock])) { return $this->caches[static::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock]; } $properties = []; $declarations = \preg_split('/;(?!base64\|charset)/', $cssDeclarationsBlock); foreach ($declarations as $declaration) { $matches = []; if (!\preg_match('/^([A-Za-z\\-]+)\\s:\\s(.+)$/s', \trim($declaration), $matches)) { continue; } $propertyName = \strtolower($matches[1]); $propertyValue = $matches[2]; $properties[$propertyName] = $propertyValue; } $this->caches[static::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock] = $properties; return $properties; } /* * Find the nodes that are not to be emogrified. * * @param \DOMXPath $xPath * * @return \DOMElement[] * * @throws SyntaxErrorException / private function getNodesToExclude(\DOMXPath $xPath) { $excludedNodes = []; foreach (\array_keys($this->excludedSelectors) as $selectorToExclude) { try { $matchingNodes = $xPath->query($this->cssSelectorConverter->toXPath($selectorToExclude)); } catch (SyntaxErrorException $e) { if ($this->debug) { throw $e; } continue; } foreach ($matchingNodes as $node) { $excludedNodes[] = $node; } } return $excludedNodes; } /* * Sets the debug mode. * * @param bool $debug set to true to enable debug mode * * @return void */ public function setDebug($debug) { $this->debug = $debug; } }

Name	Size	Modify	Permissions	Actions
HtmlProcessor	dir	2019-07-06 06:39:08	755	U
CssConcatenator.php	5.8 kb	2019-07-06 06:39:08	644	U E O D
CssInliner.php	42.3 kb	2019-07-06 06:39:08	644	U E O D