diff --git a/readme.md b/readme.md index c65389a..d691446 100644 --- a/readme.md +++ b/readme.md @@ -22,6 +22,93 @@ Or directly with css content $pce->setRootDir( '/path/to/files' ); echo $pce->embedString( $css_content ); +Options +------- + +A few behaviour options can be changed before embedding: + + setRootDir( '/path/to/files' ); + $pce->setOptions(\CssEmbed\CssEmbed::URL_ON_ERROR|\CssEmbed\CssEmbed::EMBED_SVG); + echo $pce->embedString( $css_content ); + +Available flags are: + + - `CssEmbed::URL_ON_ERROR`: If there is an error reading an asset, embed the URL + instead of throwing an exception. Default ON when using HTTP assets, + otherwise OFF. + - `CssEmbed::EMBED_FONTS`: embedding fonts will usually break them in most + browsers. Enable this flag to force the embed. Default OFF. + - `CssEmbed::EMBED_SVG`: SVG is often used as a font face; however including + these in a stylesheet will cause it to bloat for browsers that don't use it. + Default OFF when using HTTP assets, otherwise ON. + +Mime Type Detection +------------------- + +By default, the CssEmbed will detect mime types using PHP's built in mime type +detection utilities. However, for more exotic file types, such as fonts, this +can often fail. To enable mime type detection that is more inline with the the +mime types that are typically sent by web servers, use the method +`enableEnhancedMimeTypes()`: + + enableEnhancedMimeTypes(); + echo $pce->embedCss( $css_file ); + +The method accepts two parameters: + + - `$path` (string): the path to the mime.types file. Defaults to + `/tmp/cssembed.mime.types` + - `$create` (bool): if the file does not exist at `$path`, download and use + the [default Apache file](http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types). + The directory for `$path` must be writable for this to work. + +Note that enhanced mime type detection is probably necessary for the +`CssEmbed::EMBED_FONTS` and `CssEmbed::EMBED_SVG` options to work properly. + +Working with HTTP Assets +------------------------ + +To embed online assets, such as images, enable the HTTP functions with +`enableHttp`: + + // in style.css + #my-selector { + background: url('http://example.com/path/to/image.jpeg'); + } + + // in php + $pce = new \CssEmbed\CssEmbed(); + $pce->enableHttp(); + echo $pce->embedCss('/path/to/style.css'); + +This also works for embedding assets in a remote stylesheet: + + enableHttp(); + echo $pce->embedCss('http://example.com/path/to/style.css'); + +`enableHttp` accepts two parameters: + + - `$enable` (bool): whether to enable HTTP assets. Default TRUE. + - `$flags` (integer): options to control how remote assets behave. + +Available flags are: + + - `CssEmbed::HTTP_DEFAULT_HTTPS`: For URLs with no scheme, use https to + instead of http. Default OFF. + - `CssEmbed::HTTP_EMBED_SCHEME`: Include the URL scheme in URLs that are embedded + in the stylesheet (eg, "//example.com" vs "http://example.com"). Omitting the + scheme is better for stylesheets that are maybe served over http or https, + but it will break stylesheets served from a local HTML file. Default OFF. + - `CssEmbed::HTTP_EMBED_URL_ONLY`: Do not convert assets to data URLs, + only the fully qualified URL. Default OFF. + + Unit Tests ---------- diff --git a/src/CssEmbed/CssEmbed.php b/src/CssEmbed/CssEmbed.php index 799bfc9..677d9bf 100644 --- a/src/CssEmbed/CssEmbed.php +++ b/src/CssEmbed/CssEmbed.php @@ -15,13 +15,34 @@ class CssEmbed { - const SEARCH_PATTERN = "%url\\(['\" ]*((?!data:|//)[^'\"#\?: ]+)['\" ]*\\)%U"; - const URI_PATTERN = "url(data:%s;base64,%s)"; + const SEARCH_PATTERN = "%url\\(['\" ]*((?!data:)[^'\" ]+)['\" ]*\\)%U"; + const DATA_URI_PATTERN = "url(data:%s;base64,%s)"; + const URL_URI_PATTERN = "url('%s')"; + const MIME_MAGIC_URL = 'http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types'; + const EMBED_FONTS = 1; + const EMBED_SVG = 2; + const URL_ON_ERROR = 4; + const HTTP_DEFAULT_HTTPS = 1; + const HTTP_EMBED_SCHEME = 2; + const HTTP_EMBED_URL_ONLY = 4; + /** @var string the root directory for finding assets */ protected $root_dir; + /** @var string the path to the local mime.magic database */ + protected $mime_magic_path = null; + + /** @var integer flags that modify behavior, embed SVG by default for BC */ + protected $flags = 2; + + /** @var bool enable HTTP asset fetching */ + protected $http_enabled = false; + + /** @var integer flags that modify behavior in HTTP only */ + protected $http_flags = 0; + /** - * @param $root_dir + * @param string $root_dir */ public function setRootDir($root_dir) { @@ -29,24 +50,94 @@ public function setRootDir($root_dir) } /** - * @param $css_file + * Set embedding options. Flags: + * + * - CssEmbed::EMBED_FONTS: embedding fonts will usually break them + * in most browsers. Enable this flag to force the embed. WARNING: + * this flag is currently not unit tested, but seems to work. + * - CssEmbed::EMBED_SVG: SVG is often used as a font face; however + * including these in a stylesheet will cause it to bloat for browsers + * that don't use it. SVGs will be embedded by default. + * - CssEmbed::URL_ON_ERROR: if there is an error fetching an asset, + * embed a URL (or best guess at URL) instead of throwing an exception + * + * @param integer $flags + * + * @return void + */ + public function setOptions($flags) + { + $this->flags = $flags; + } + + /** + * Enable embedding assets over HTTP, or processing stylesheets from HTTP + * locations. Available flags: + * + * - CssEmbed::HTTP_DEFAULT_HTTPS: when HTTP assets are enabled, use + * HTTPS for URLs with no scheme + * - CssEmbed::HTTP_EMBED_SCHEME: By default, assets that are converted + * to URLs instead of data urls have no scheme (eg, "//example.com"). + * This is better for stylesheets that are maybe served over http or + * https, but it will break stylesheets served from a local HTML file. + * Set this option to force the schema (eg, "http://example.com"). + * - CssEmbed::HTTP_EMBED_URL_ONLY: do not convert assets to data URLs, + * only the fully qualified URL. + * + * @note this method will turn the options URL_ON_ERROR on and EMBED_SVG + * off. You will need to use setOptions() after this method to change that. + * + * @param bool $enable + * @param int $flags flags that modify HTTP behaviour + * @return void + */ + public function enableHttp($enable = true, $flags = 0) + { + $this->http_enabled = (bool) $enable; + $this->flags = $this->flags|self::URL_ON_ERROR; + $this->flags = $this->flags & (~ self::EMBED_SVG); + $this->http_flags = (int) $flags; + } + + /** + * Enable the functionality to compare mimes against a custom mime.types file. + * + * @param string $path the path to the mime types file + * @param bool $create download and save the Apache mime types file if the + * specified path does not exist + * @throws \InvalidArgumentException if the mime file does not exist and + * cannot be created. + * @return void + */ + public function enableEnhancedMimeTypes( + $path = '/tmp/cssembed.mime.types', + $create = true + ) { + if (!file_exists($path) && $create) { + $this->createMimesFile($path); + } + if (!file_exists($path)) { + $this->error('mime.types does not exist and cannot be created: "%s"', $path); + } + if (!is_readable($path) || !is_file($path)) { + $this->error('Invalid mime.types file: "%s"', $path); + } + $this->mime_magic_path = $path; + } + + /** + * @param string $css_file * @return null|string * @throws \InvalidArgumentException */ public function embedCss($css_file) { $this->setRootDir(dirname($css_file)); - $return = null; - $handle = fopen($css_file, "r"); - if ($handle === false) { + $content = @file_get_contents($css_file); + if ($content === false) { throw new \InvalidArgumentException(sprintf('Cannot read file %s', $css_file)); } - while (($line = fgets($handle)) !== false) { - $return .= $this->embedString($line); - } - fclose($handle); - - return $return; + return $this->embedString($content); } /** @@ -55,55 +146,391 @@ public function embedCss($css_file) */ public function embedString($content) { - return preg_replace_callback(self::SEARCH_PATTERN, array($this, 'replace'), $content); + return preg_replace_callback( + self::SEARCH_PATTERN, + array($this, 'replace'), + $content + ); } /** - * @param $matches + * preg_replace_callback callback for embedString. + * + * @param array $matches * @return string */ protected function replace($matches) { - return $this->embedFile($this->root_dir . DIRECTORY_SEPARATOR . $matches[1]); + if ($asset = $this->fetchAsset($matches[1])) { + if ($this->assetIsEmbeddable($asset)) { + return sprintf( + self::DATA_URI_PATTERN, + $asset['mime'], + base64_encode($asset['content']) + ); + } + } + if ($url = $this->fetchAssetUrl($matches[1])) { + return sprintf(self::URL_URI_PATTERN, $url); + } + return $matches[0]; } /** - * @param $file - * @return string + * Fetch an asset + * + * @param string $path the asset path + * @return array|false an array with keys 'content' for the file content + * and 'mime' for the mime type, or FALSE on error + */ + protected function fetchAsset($path) + { + $asset = false; + if ($this->isHttpAsset($path)) { + if ($url = $this->resolveAssetUrl($path)) { + $asset = $this->fetchHttpAsset($url); + } + } else { + if ($absolute_path = $this->resolveAssetPath($path)) { + $asset = $this->fetchLocalAsset($absolute_path); + } + } + return $asset; + } + + /** + * Get the URL to an asset as it would be embedded in a stylesheet + * + * @param string $path the path to the asset as it appears in the stylesheet + * @return string $url the URL to the asset + */ + protected function fetchAssetUrl($path) + { + if (!$this->isHttpAsset($path)) { + return $path; + } + $url = $this->resolveAssetUrl($path); + if (!($this->http_flags & self::HTTP_EMBED_SCHEME)) { + $url = preg_replace('/^https?:/', '', $url); + } + return $url; + } + + /** + * Fetch an asset stored locally in the filesystem + * + * @param string $absolute_path the absolute path to the asset + * @return array same as fetchAsset */ - protected function embedFile($file) + protected function fetchLocalAsset($absolute_path) { - return sprintf(self::URI_PATTERN, $this->mimeType($file), $this->base64($file)); + if (!is_file($absolute_path) || !is_readable($absolute_path)) { + $this->error('Cannot read file %s', $absolute_path); + return false; + } + $content = file_get_contents($absolute_path); + + $mime = $this->getLocalAssetMime($absolute_path); + + return compact('content', 'mime'); } /** - * @param $file - * @return string + * Find the mime for a file on the local file system + * + * @param string $absolute_path + * @return false|string the mime type, or false if not found */ - protected function mimeType($file) + protected function getLocalAssetMime($absolute_path) { - if (function_exists('mime_content_type')) { - return mime_content_type($file); + if ($mime = $this->detectMime($absolute_path)) { + return $mime; + } + + if ($mime = @mime_content_type($absolute_path)) { + return $mime; } - if ($info = @getimagesize($file)) { - return($info['mime']); + if ($info = @getimagesize($absolute_path)) { + return $info['mime']; } return 'application/octet-stream'; } /** - * @param $file + * Fetch an asset stored remotely over HTTP + * + * @param string $url the url to the asset + * @return array same as fetchAsset + */ + protected function fetchHttpAsset($url) + { + if ($this->http_flags & self::HTTP_EMBED_URL_ONLY) { + return false; + } + if (false === ($content = @file_get_contents($url))) { + $this->error('Cannot read url %s', $url); + return false; + } + if (!($mime = $this->getHttpAssetMime($http_response_header))) { + $this->error('No mime type sent with "%s"', $url); + return false; + } + return compact('content', 'mime'); + } + + /** + * Extract the content type header from the headers returned with the + * file_get_contents http call + * + * @param array $headers the `$http_response_headers` created by `file_get_contents` + * @return false|string the mime type, or false if not found + */ + protected function getHttpAssetMime($headers) + { + foreach ($headers as $header) { + $header = strtolower($header); + if (strpos($header, 'content-type:') === 0) { + return trim(substr($header, strlen('content-type:'))); + } + } + return false; + } + + /** + * Check if a successfully fetched an asset is of a type that can be + * embedded given the current options. + * + * @param array $asset the return value of fetchAsset + * @return boolean + */ + protected function assetIsEmbeddable(array $asset) + { + $embed_fonts = ($this->flags & self::EMBED_FONTS); + $is_font = strpos($asset['mime'], 'font') !== false; + if ($is_font && !$embed_fonts) { + return false; + } + + $embed_svg = ($this->flags & self::EMBED_SVG); + $is_svg = strpos($asset['mime'], 'svg') !== false; + if ($is_svg && !($embed_svg || $embed_fonts)) { + return false; + } + + return true; + } + + /** + * Check if an asset is remote or local + * + * @param string $path the path specified in the CSS file + * + * @return bool + */ + protected function isHttpAsset($path) + { + if (!$this->http_enabled) { + return false; + } + // if the root directory is remote, all assets are remote + $schemes = array('http://', 'https://', '//'); + foreach ($schemes as $scheme) { + if (strpos($this->root_dir, $scheme) === 0) { + return true; + } + } + // check for remote embedded assets + $schemes[] = '/'; // absolutes should be remote + foreach ($schemes as $scheme) { + if (strpos($path, $scheme) === 0) { + return true; + } + } + // otherwise, it's a local asset + return false; + } + + /** + * Resolve the absolute path to a local asset + * + * @param string $path the path to the asset, relative to root_dir + * @return false|string the absolute path, or false if not found + */ + protected function resolveAssetPath($path) + { + if (preg_match('/[:\?#]/', $path)) { + return false; + } + return realpath($this->root_dir . DIRECTORY_SEPARATOR . $path); + } + + /** + * Resolve the URL to an http asset + * + * @param string $path + * @return false|string the url, or false if not resolvable + */ + protected function resolveAssetUrl($path) + { + $url = $this->buildAssetUrl($path); + if (filter_var($url, FILTER_VALIDATE_URL)) { + return $url; + } + $this->error('Invalid asset url "%s"', $url); + return false; + } + + + /** + * Resolve the URL to an http asset + * + * @param string $path + * @return false|string the url, or false if not resolvable + */ + protected function buildAssetUrl($path) + { + $default_scheme = ($this->http_flags & self::HTTP_DEFAULT_HTTPS) + ? 'https:' + : 'http:' + ; + + // case 1: path is already fully qualified url + if (strpos($path, '//') === 0) { + $path = $default_scheme . $path; + } + if (preg_match('/^https?:\/\//', $path)) { + return $path; + } + + $root_url = $this->root_dir; + if (strpos($root_url, '//') === 0) { + $root_url = $default_scheme . $root_url; + } + $root_domain = preg_replace('#^(https?://[^/]+).*#', '$1', $root_url); + $root_path = substr($root_url, strlen($root_domain)); + + // case 2: asset is absolute path + if (strpos($path, '/') === 0) { + return $root_domain . $path; + } + + // case 3: asset is relative path + $path = $this->removePathTraversals($root_path . '/' . $path); + $url = $root_domain . '/' . $path; + return $url; + } + + /** + * Remove directory traversals from a path. Exists because file_get_contents + * seems to choke on http://example.com/path/to/dir/../other-dir/file.txt + * + * @param string $path * @return string - * @throws \InvalidArgumentException */ - protected function base64($file) + protected function removePathTraversals($path) + { + $path = explode('/', $path); + $return = array(); + foreach ($path as $part) { + if ($part == '..') { + array_pop($return); + } elseif ($part && $part !== '.') { + $return[] = $part; + } + } + return implode('/', $return); + } + + /** + * Check the file mime type against the mime.types file + * + * @param string $path the path to the file + * @return string the mime, or false if it could not be identified + */ + protected function detectMime($path) { - if (is_file($file) === false || is_readable($file) === false) { - throw new \InvalidArgumentException(sprintf('Cannot read file %s', $file)); + if (!$this->mime_magic_path) { + return false; + } + $ext = strtolower((string) pathinfo($path, PATHINFO_EXTENSION)); + if (!$ext) { + return false; + } + $mime_types = file($this->mime_magic_path); + foreach ($mime_types as $line) { + if ($mime = $this->compareMime($ext, $line)) { + return $mime; + } } + return false; + } - return base64_encode(file_get_contents($file)); + /** + * Compare an extention against the a line in the mime.types + * + * @param string $ext the file extension + * @param string $line the line from the mime.types file + * @return string|bool the mime type if there is a match, false if not + */ + protected function compareMime($ext, $line) + { + if (strpos($line, '#') === 0) { + return false; + } + $line = preg_replace('/\s+/', ' ', $line); + $line = array_filter(explode(' ', $line)); + $mime = array_shift($line); + return in_array($ext, $line) ? $mime : false; + } + + /** + * Download the Apache mimes.types file and save it locally + * + * @param string $path the path to save the file to + * @return void + */ + protected function createMimesFile($path) + { + $mime_types = @file_get_contents(self::MIME_MAGIC_URL); + if ($mime_types === false) { + return; + } + // special case: woff2 is too new + if (strpos($mime_types, 'woff2') === false) { + $mime_types .= "\napplication/font-woff2 woff2"; + } + file_put_contents($path, $mime_types); + clearstatcache(); + } + + /** + * Throw an exception if URL_ON_ERROR is not set + * + * This method accepts an unlimited number of arguments. They will be passed + * to sprintf to generate the error message in the exception. For example: + * + * $this->error('My exception about %d %s', 4, 'cats'); + * + * would throw an exception with with the message "My error about 4 cats". + * + * @throws \InvalidArgmumentException + * @return void + */ + protected function error() + { + if ($this->flags & self::URL_ON_ERROR) { + return; + } + $args = func_get_args(); + if (empty($args)) { + $args[] = 'Unknown Error'; + } + $msg = count($args) > 1 + ? call_user_func_array('sprintf', $args) + : array_shift($args) + ; + throw new \InvalidArgumentException($msg); } } diff --git a/tests/Tests/CssEmbed/CssEmbedTest.php b/tests/Tests/CssEmbed/CssEmbedTest.php index 7d9c310..1c8bfd8 100644 --- a/tests/Tests/CssEmbed/CssEmbedTest.php +++ b/tests/Tests/CssEmbed/CssEmbedTest.php @@ -36,29 +36,75 @@ public function testEmbedString() $this->assertEquals($expected, $tested); } - public function mimeTypeProvider() + public function testMimeTypes() { - return array( - array('application/octet-stream', 'binary.file'), - array('image/gif', 'php.gif') - ); + $origin = file_get_contents(__DIR__.'/rsc/test-mime.css'); + $expected = file_get_contents(__DIR__.'/rsc/expected-mime.css'); + + $cssEmbed = new CssEmbed(); + $cssEmbed->setRootDir(__DIR__.'/rsc'); + $cssEmbed->enableEnhancedMimeTypes(); + $tested = $cssEmbed->embedString($origin); + + $this->assertEquals($expected, $tested); } - /** - * @dataProvider mimeTypeProvider - */ - public function testMimeType($expected, $file) + public function testSetOptions() { - $cssEmbed = new CssEmbedTestable(); - $file = __DIR__.'/rsc/'.$file; - $this->assertEquals($expected, $cssEmbed->mimeType($file)); + $origin = file_get_contents(__DIR__.'/rsc/test-options.css'); + $expected = file_get_contents(__DIR__.'/rsc/expected-options.css'); + + $cssEmbed = new CssEmbed(); + $cssEmbed->enableEnhancedMimeTypes(); + $cssEmbed->setOptions(CssEmbed::URL_ON_ERROR|CssEmbed::EMBED_FONTS|CssEmbed::EMBED_SVG); + + $cssEmbed->setRootDir(__DIR__.'/rsc'); + $tested = $cssEmbed->embedString($origin); + + $this->assertEquals($expected, $tested); } -} -class CssEmbedTestable extends CssEmbed -{ - public function mimeType($file) + public function testHttpEnabledEmbedCss() + { + $origin = __DIR__.'/rsc/test-http-enabled.css'; + $expected = file_get_contents(__DIR__.'/rsc/expected-http-enabled.css'); + + $cssEmbed = new CssEmbed(); + $cssEmbed->enableHttp(); + $tested = $cssEmbed->embedCss($origin); + + $this->assertEquals($expected, $tested); + } + + public function testHttpEnabledEmbedString() { - return parent::mimeType($file); + $origin = file_get_contents(__DIR__.'/rsc/test-http-remote.css'); + $expected = file_get_contents(__DIR__.'/rsc/expected-http-remote.css'); + + $cssEmbed = new CssEmbed(); + $cssEmbed->enableHttp(); + $cssEmbed->setRootDir('//httpbin.org/media/hypothetical-css-dir'); + $tested = $cssEmbed->embedString($origin); + $this->assertEquals($expected, $tested); + } + + public function testHttpEnabledEnableOptions() + { + $origin = file_get_contents(__DIR__.'/rsc/test-http-options.css'); + $expected = file_get_contents(__DIR__.'/rsc/expected-http-options.css'); + + $cssEmbed = new CssEmbed(); + + $cssEmbed->enableHttp( + true, + CssEmbed::HTTP_DEFAULT_HTTPS|CssEmbed::HTTP_EMBED_SCHEME|CssEmbed::HTTP_EMBED_URL_ONLY + ); + $cssEmbed->setRootDir('//httpbin.org/media/hypothetical-css-dir'); + $tested = $cssEmbed->embedString($origin); + + $this->assertEquals($expected, $tested); + } } + + diff --git a/tests/Tests/CssEmbed/rsc/expected-http-enabled.css b/tests/Tests/CssEmbed/rsc/expected-http-enabled.css new file mode 100644 index 0000000..57de8c9 --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/expected-http-enabled.css @@ -0,0 +1,7 @@ +/* Css file to test phpCssEmbed in HTTP mode **/ + +.this-is a#css-selector { + background: url('test.gif?http_param=1'); + background: url(data:image/png;base64,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); + background: url(data:image/gif;base64,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); +} diff --git a/tests/Tests/CssEmbed/rsc/expected-http-options.css b/tests/Tests/CssEmbed/rsc/expected-http-options.css new file mode 100644 index 0000000..b794280 --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/expected-http-options.css @@ -0,0 +1,9 @@ +/* Css file to test phpCssEmbed in HTTP mode **/ + +.this-is a#css-selector { + background: url('https://httpbin.org/image/png'); + background: url('http://httpbin.org/image/jpeg'); + background: url('https://httpbin.org/image/png'); + background: url('https://httpbin.org/image/svg'); + background: url('https://httpbin.org/image/should-be-a-404'); +} diff --git a/tests/Tests/CssEmbed/rsc/expected-http-remote.css b/tests/Tests/CssEmbed/rsc/expected-http-remote.css new file mode 100644 index 0000000..887bbdc --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/expected-http-remote.css @@ -0,0 +1,9 @@ +/* Css file to test phpCssEmbed in HTTP mode **/ + +.this-is a#css-selector { + background: url(data:image/png;base64,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); + background: url(data:image/jpeg;base64,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); + background: url(data:image/png;base64,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); + background: url('//httpbin.org/image/svg'); + background: url('//httpbin.org/image/should-be-a-404'); +} diff --git a/tests/Tests/CssEmbed/rsc/expected-mime.css b/tests/Tests/CssEmbed/rsc/expected-mime.css new file mode 100644 index 0000000..3f81f00 --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/expected-mime.css @@ -0,0 +1,6 @@ +/* Css file to test phpCssEmbed **/ + +.this-is a#css-selector { + background: url(data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="100%" height="100%" viewBox="0 0 100 100">

  <title>SVG Logo</title>

  <a xlink:href="http://www.w3.org/Graphics/SVG/" target="_parent"
     xlink:title="W3C SVG Working Group home page">

    <rect
        id="background"
        fill="#FF9900"
        width="100"
        height="100"
        rx="4"
        ry="4"/>

    <rect
        id="top-left"
        fill="#FFB13B"
        width="50"
        height="50"
        rx="4"
        ry="4"/>

    <rect
        id="bottom-right"
        x="50"
        y="50"
        fill="#DE8500"
        width="50"
        height="50"
        rx="4"
        ry="4"/>

    <g id="circles" fill="#FF9900">
        <circle
            id="n"
            cx="50"
            cy="18.4"
            r="18.4"/>

        <circle
            id="ne"
            cx="72.4"
            cy="27.6"
            r="18.4"/>

        <circle
            id="e"
            cx="81.6"
            cy="50"
            r="18.4"/>

        <circle
            id="se"
            cx="72.4"
            cy="72.4"
            r="18.4"/>

        <circle
            id="s"
            cx="50"
            cy="81.6"
            r="18.4"/>

        <circle
            id="sw"
            cx="27.6"
            cy="72.4"
            r="18.4"/>

        <circle
            id="w"
            cx="18.4"
            cy="50"
            r="18.4"/>

        <circle
            id="nw"
            cx="27.6"
            cy="27.6"
            r="18.4"/>
    </g>

    <g id="stars">
        <path
            id="black-star"
            d="M  63.086, 18.385
               c  0.000, -7.227  -5.859,-13.086 -13.100,-13.086
               c -7.235,  0.000 -13.096,  5.859 -13.096, 13.086
               c -5.100, -5.110 -13.395, -5.110 -18.497,  0.000
               c -5.119,  5.120  -5.119, 13.408   0.000, 18.524
               c -7.234,  0.000 -13.103,  5.859 -13.103, 13.085
               c  0.000,  7.230   5.870, 13.098  13.103, 13.098
               c -5.119,  5.110  -5.119, 13.395   0.000, 18.515
               c  5.102,  5.104  13.397,  5.104  18.497,  0.000
               c  0.000,  7.228   5.860, 13.083  13.096, 13.083
               c  7.240,  0.000  13.100, -5.855  13.100,-13.083
               c  5.118,  5.104  13.416,  5.104  18.513,  0.000
               c  5.101, -5.120   5.101,-13.410   0.000,-18.515
               c  7.216,  0.000  13.081, -5.869  13.081,-13.098
               c  0.000, -7.227  -5.865,-13.085 -13.081,-13.085
               c  5.101, -5.119   5.101,-13.406   0.000,-18.524
               C 76.502, 13.275  68.206, 13.275  63.086, 18.385 z"/>

        <path
            id="white-star"
            fill="#FFFFFF"
            d="M 55.003, 23.405
               v 14.488
               L 65.260, 27.640
               c  0.000, -1.812  0.691,-3.618   2.066, -5.005
               c  2.780, -2.771  7.275,-2.771  10.024,  0.000
               c  2.771,  2.766  2.771, 7.255   0.000, 10.027
               c -1.377,  1.375 -3.195, 2.072  -5.015,  2.072
               L 62.101, 44.982
               H 76.590
               c  1.290, -1.280  3.054,-2.076   5.011, -2.076
               c  3.900,  0.000  7.078, 3.179   7.078,  7.087
               c  0.000,  3.906 -3.178, 7.088  -7.078,  7.088
               c -1.957,  0.000 -3.721,-0.798  -5.011, -2.072
               H 62.100
               l 10.229, 10.244
               c  1.824,  0.000  3.642, 0.694   5.015,  2.086
               c  2.774,  2.759  2.774, 7.250   0.000, 10.010
               c -2.750,  2.774 -7.239, 2.774 -10.025,  0.000
               c -1.372, -1.372 -2.064,-3.192  -2.064, -5.003
               L 55.000, 62.094
               v 14.499
               c  1.271,  1.276  2.084, 3.054   2.084,  5.013
               c  0.000,  3.906 -3.177, 7.077  -7.098,  7.077
               c -3.919,  0.000 -7.094,-3.167  -7.094, -7.077
               c  0.000, -1.959  0.811,-3.732   2.081, -5.013
               V 62.094
               L 34.738, 72.346
               c  0.000,  1.812 -0.705, 3.627  -2.084,  5.003
               c -2.769,  2.772 -7.251, 2.772 -10.024,  0.000
               c -2.775, -2.764 -2.775,-7.253   0.000,-10.012
               c  1.377, -1.390  3.214,-2.086   5.012, -2.086
               l 10.257,-10.242
               H 23.414
               c -1.289,  1.276 -3.072, 2.072  -5.015,  2.072
               c -3.917,  0.000 -7.096,-3.180  -7.096, -7.088
               s  3.177, -7.087  7.096,-7.087
               c  1.940,  0.000  3.725, 0.796   5.015,  2.076
               h 14.488
               L 27.646, 34.736
               c -1.797,  0.000 -3.632,-0.697  -5.012, -2.071
               c -2.775, -2.772 -2.775,-7.260   0.000,-10.027
               c  2.773, -2.771  7.256,-2.771  10.027,  0.000
               c  1.375,  1.386  2.083, 3.195   2.083,  5.005
               l 10.235, 10.252
               V 23.407
               c -1.270, -1.287 -2.082,-3.053  -2.082, -5.023
               c  0.000, -3.908  3.175,-7.079   7.096, -7.079
               c  3.919,  0.000  7.097, 3.168   7.097,  7.079
               C 57.088, 20.356 56.274,22.119  55.003, 23.405 z"/>
    </g>

    <g id="svg-textbox">
        <path
            id="text-backdrop"
            fill="black"
            d="M  5.30,50.00
               H 94.68
               V 90.00
               Q 94.68,95.00 89.68,95.00
               H 10.30
               Q  5.30,95.00  5.30,90.00 Z"/>

        <path 
            id="shine"
            fill="#3F3F3F"
            d="M  14.657,54.211
               h  71.394
               c   2.908, 0.000   5.312, 2.385   5.312, 5.315
               v  17.910
               c -27.584,-3.403 -54.926,-8.125 -82.011,-7.683
               V  59.526
               C   9.353,56.596  11.743,54.211  14.657,54.211
               L  14.657,54.211 z"/>

        <g id="svg-text">
            <title>SVG</title>
            <path
                id="S"
                fill="#FFFFFF"
                stroke="#000000"
                stroke-width="0.5035"
                d="M 18.312,72.927
                   c -2.103,-2.107  -3.407, -5.028  -3.407, -8.253
                   c  0.000,-6.445   5.223,-11.672  11.666,-11.672
                   c  6.446, 0.000  11.667,  5.225  11.667, 11.672
                   h -6.832
                   c  0.000,-2.674  -2.168, -4.837  -4.835, -4.837
                   c -2.663, 0.000  -4.838,  2.163  -4.838,  4.837
                   c  0.000, 1.338   0.549,  2.536   1.415,  3.420
                   l  0.000, 0.000
                   c  0.883, 0.874   2.101,  1.405   3.423,  1.405
                   v  0.012
                   c  3.232, 0.000   6.145,  1.309   8.243,  3.416
                   l  0.000, 0.000
                   c  2.118, 2.111   3.424,  5.034   3.424,  8.248
                   c  0.000, 6.454  -5.221, 11.680 -11.667, 11.680
                   c -6.442, 0.000 -11.666, -5.222 -11.666,-11.680
                   h  6.828
                   c  0.000, 2.679   2.175,  4.835   4.838,  4.835
                   c  2.667, 0.000   4.835, -2.156   4.835, -4.835
                   c  0.000,-1.329  -0.545, -2.527  -1.429, -3.407
                   l  0.000, 0.000
                   c -0.864,-0.880  -2.082, -1.418  -3.406, -1.418
                   l  0.000, 0.000
                   C 23.341,76.350  20.429, 75.036  18.312, 72.927
                   L 18.312,72.927
                   L 18.312,72.927 z"/>
            <polygon
                id="V"
                fill="#FFFFFF"
                stroke="#000000"
                stroke-width="0.5035"
                points="61.588,53.005
                        53.344,92.854
                        46.494,92.854
                        38.236,53.005
                        45.082,53.005
                        49.920,76.342
                        54.755,53.005"/>

         <path 
            id="G"
            fill="#FFFFFF"
            stroke="#000000"
            stroke-width="0.5035"
            d="M 73.255,69.513
               h 11.683
               v 11.664
               l  0.000, 0.000
               c  0.000, 6.452  -5.226,11.678 -11.669, 11.678
               c -6.441, 0.000 -11.666,-5.226 -11.666,-11.678
               l  0.000, 0.000
               V 64.676
               h -0.017
               C 61.586,58.229  66.827,53.000  73.253, 53.000
               c  6.459, 0.000  11.683, 5.225  11.683, 11.676
               h -6.849
               c  0.000,-2.674  -2.152,-4.837  -4.834, -4.837
               c -2.647, 0.000  -4.820, 2.163  -4.820,  4.837
               v 16.501
               l  0.000, 0.000
               c  0.000, 2.675   2.173, 4.837   4.820,  4.837
               c  2.682, 0.000   4.834,-2.162   4.834, -4.827
               v -0.012
               v -4.827
               h -4.834
               L 73.255,69.513
               L 73.255,69.513 z"/>
        </g>
    </g>
  </a>
</svg>
); + background: url('open-sans.woff2'); +} diff --git a/tests/Tests/CssEmbed/rsc/expected-options.css b/tests/Tests/CssEmbed/rsc/expected-options.css new file mode 100644 index 0000000..74067d4 --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/expected-options.css @@ -0,0 +1,8 @@ +/* Css file to test phpCssEmbed **/ + +.this-is a#css-selector { + background: url(data:image/gif;base64,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); + background: url(data:application/vnd.ms-fontobject;base64,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); + background: url(data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="100%" height="100%" viewBox="0 0 100 100">

  <title>SVG Logo</title>

  <a xlink:href="http://www.w3.org/Graphics/SVG/" target="_parent"
     xlink:title="W3C SVG Working Group home page">

    <rect
        id="background"
        fill="#FF9900"
        width="100"
        height="100"
        rx="4"
        ry="4"/>

    <rect
        id="top-left"
        fill="#FFB13B"
        width="50"
        height="50"
        rx="4"
        ry="4"/>

    <rect
        id="bottom-right"
        x="50"
        y="50"
        fill="#DE8500"
        width="50"
        height="50"
        rx="4"
        ry="4"/>

    <g id="circles" fill="#FF9900">
        <circle
            id="n"
            cx="50"
            cy="18.4"
            r="18.4"/>

        <circle
            id="ne"
            cx="72.4"
            cy="27.6"
            r="18.4"/>

        <circle
            id="e"
            cx="81.6"
            cy="50"
            r="18.4"/>

        <circle
            id="se"
            cx="72.4"
            cy="72.4"
            r="18.4"/>

        <circle
            id="s"
            cx="50"
            cy="81.6"
            r="18.4"/>

        <circle
            id="sw"
            cx="27.6"
            cy="72.4"
            r="18.4"/>

        <circle
            id="w"
            cx="18.4"
            cy="50"
            r="18.4"/>

        <circle
            id="nw"
            cx="27.6"
            cy="27.6"
            r="18.4"/>
    </g>

    <g id="stars">
        <path
            id="black-star"
            d="M  63.086, 18.385
               c  0.000, -7.227  -5.859,-13.086 -13.100,-13.086
               c -7.235,  0.000 -13.096,  5.859 -13.096, 13.086
               c -5.100, -5.110 -13.395, -5.110 -18.497,  0.000
               c -5.119,  5.120  -5.119, 13.408   0.000, 18.524
               c -7.234,  0.000 -13.103,  5.859 -13.103, 13.085
               c  0.000,  7.230   5.870, 13.098  13.103, 13.098
               c -5.119,  5.110  -5.119, 13.395   0.000, 18.515
               c  5.102,  5.104  13.397,  5.104  18.497,  0.000
               c  0.000,  7.228   5.860, 13.083  13.096, 13.083
               c  7.240,  0.000  13.100, -5.855  13.100,-13.083
               c  5.118,  5.104  13.416,  5.104  18.513,  0.000
               c  5.101, -5.120   5.101,-13.410   0.000,-18.515
               c  7.216,  0.000  13.081, -5.869  13.081,-13.098
               c  0.000, -7.227  -5.865,-13.085 -13.081,-13.085
               c  5.101, -5.119   5.101,-13.406   0.000,-18.524
               C 76.502, 13.275  68.206, 13.275  63.086, 18.385 z"/>

        <path
            id="white-star"
            fill="#FFFFFF"
            d="M 55.003, 23.405
               v 14.488
               L 65.260, 27.640
               c  0.000, -1.812  0.691,-3.618   2.066, -5.005
               c  2.780, -2.771  7.275,-2.771  10.024,  0.000
               c  2.771,  2.766  2.771, 7.255   0.000, 10.027
               c -1.377,  1.375 -3.195, 2.072  -5.015,  2.072
               L 62.101, 44.982
               H 76.590
               c  1.290, -1.280  3.054,-2.076   5.011, -2.076
               c  3.900,  0.000  7.078, 3.179   7.078,  7.087
               c  0.000,  3.906 -3.178, 7.088  -7.078,  7.088
               c -1.957,  0.000 -3.721,-0.798  -5.011, -2.072
               H 62.100
               l 10.229, 10.244
               c  1.824,  0.000  3.642, 0.694   5.015,  2.086
               c  2.774,  2.759  2.774, 7.250   0.000, 10.010
               c -2.750,  2.774 -7.239, 2.774 -10.025,  0.000
               c -1.372, -1.372 -2.064,-3.192  -2.064, -5.003
               L 55.000, 62.094
               v 14.499
               c  1.271,  1.276  2.084, 3.054   2.084,  5.013
               c  0.000,  3.906 -3.177, 7.077  -7.098,  7.077
               c -3.919,  0.000 -7.094,-3.167  -7.094, -7.077
               c  0.000, -1.959  0.811,-3.732   2.081, -5.013
               V 62.094
               L 34.738, 72.346
               c  0.000,  1.812 -0.705, 3.627  -2.084,  5.003
               c -2.769,  2.772 -7.251, 2.772 -10.024,  0.000
               c -2.775, -2.764 -2.775,-7.253   0.000,-10.012
               c  1.377, -1.390  3.214,-2.086   5.012, -2.086
               l 10.257,-10.242
               H 23.414
               c -1.289,  1.276 -3.072, 2.072  -5.015,  2.072
               c -3.917,  0.000 -7.096,-3.180  -7.096, -7.088
               s  3.177, -7.087  7.096,-7.087
               c  1.940,  0.000  3.725, 0.796   5.015,  2.076
               h 14.488
               L 27.646, 34.736
               c -1.797,  0.000 -3.632,-0.697  -5.012, -2.071
               c -2.775, -2.772 -2.775,-7.260   0.000,-10.027
               c  2.773, -2.771  7.256,-2.771  10.027,  0.000
               c  1.375,  1.386  2.083, 3.195   2.083,  5.005
               l 10.235, 10.252
               V 23.407
               c -1.270, -1.287 -2.082,-3.053  -2.082, -5.023
               c  0.000, -3.908  3.175,-7.079   7.096, -7.079
               c  3.919,  0.000  7.097, 3.168   7.097,  7.079
               C 57.088, 20.356 56.274,22.119  55.003, 23.405 z"/>
    </g>

    <g id="svg-textbox">
        <path
            id="text-backdrop"
            fill="black"
            d="M  5.30,50.00
               H 94.68
               V 90.00
               Q 94.68,95.00 89.68,95.00
               H 10.30
               Q  5.30,95.00  5.30,90.00 Z"/>

        <path 
            id="shine"
            fill="#3F3F3F"
            d="M  14.657,54.211
               h  71.394
               c   2.908, 0.000   5.312, 2.385   5.312, 5.315
               v  17.910
               c -27.584,-3.403 -54.926,-8.125 -82.011,-7.683
               V  59.526
               C   9.353,56.596  11.743,54.211  14.657,54.211
               L  14.657,54.211 z"/>

        <g id="svg-text">
            <title>SVG</title>
            <path
                id="S"
                fill="#FFFFFF"
                stroke="#000000"
                stroke-width="0.5035"
                d="M 18.312,72.927
                   c -2.103,-2.107  -3.407, -5.028  -3.407, -8.253
                   c  0.000,-6.445   5.223,-11.672  11.666,-11.672
                   c  6.446, 0.000  11.667,  5.225  11.667, 11.672
                   h -6.832
                   c  0.000,-2.674  -2.168, -4.837  -4.835, -4.837
                   c -2.663, 0.000  -4.838,  2.163  -4.838,  4.837
                   c  0.000, 1.338   0.549,  2.536   1.415,  3.420
                   l  0.000, 0.000
                   c  0.883, 0.874   2.101,  1.405   3.423,  1.405
                   v  0.012
                   c  3.232, 0.000   6.145,  1.309   8.243,  3.416
                   l  0.000, 0.000
                   c  2.118, 2.111   3.424,  5.034   3.424,  8.248
                   c  0.000, 6.454  -5.221, 11.680 -11.667, 11.680
                   c -6.442, 0.000 -11.666, -5.222 -11.666,-11.680
                   h  6.828
                   c  0.000, 2.679   2.175,  4.835   4.838,  4.835
                   c  2.667, 0.000   4.835, -2.156   4.835, -4.835
                   c  0.000,-1.329  -0.545, -2.527  -1.429, -3.407
                   l  0.000, 0.000
                   c -0.864,-0.880  -2.082, -1.418  -3.406, -1.418
                   l  0.000, 0.000
                   C 23.341,76.350  20.429, 75.036  18.312, 72.927
                   L 18.312,72.927
                   L 18.312,72.927 z"/>
            <polygon
                id="V"
                fill="#FFFFFF"
                stroke="#000000"
                stroke-width="0.5035"
                points="61.588,53.005
                        53.344,92.854
                        46.494,92.854
                        38.236,53.005
                        45.082,53.005
                        49.920,76.342
                        54.755,53.005"/>

         <path 
            id="G"
            fill="#FFFFFF"
            stroke="#000000"
            stroke-width="0.5035"
            d="M 73.255,69.513
               h 11.683
               v 11.664
               l  0.000, 0.000
               c  0.000, 6.452  -5.226,11.678 -11.669, 11.678
               c -6.441, 0.000 -11.666,-5.226 -11.666,-11.678
               l  0.000, 0.000
               V 64.676
               h -0.017
               C 61.586,58.229  66.827,53.000  73.253, 53.000
               c  6.459, 0.000  11.683, 5.225  11.683, 11.676
               h -6.849
               c  0.000,-2.674  -2.152,-4.837  -4.834, -4.837
               c -2.647, 0.000  -4.820, 2.163  -4.820,  4.837
               v 16.501
               l  0.000, 0.000
               c  0.000, 2.675   2.173, 4.837   4.820,  4.837
               c  2.682, 0.000   4.834,-2.162   4.834, -4.827
               v -0.012
               v -4.827
               h -4.834
               L 73.255,69.513
               L 73.255,69.513 z"/>
        </g>
    </g>
  </a>
</svg>
); + background: url('file-not-found.gif'); +} diff --git a/tests/Tests/CssEmbed/rsc/expected.css b/tests/Tests/CssEmbed/rsc/expected.css index ad7e8d0..133ae5e 100644 --- a/tests/Tests/CssEmbed/rsc/expected.css +++ b/tests/Tests/CssEmbed/rsc/expected.css @@ -13,4 +13,5 @@ background: url(data:image/gif;base64,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);background: url(data:image/gif;base64,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);background: url(data:image/gif;base64,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); background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAXRSTlMAQObYZgAAAApJREFUCNdjYAAAAAIAAeIhvDMAAAAASUVORK5CYII=); x-foo: url(data:application/octet-stream;base64,AAX/Aw==); + font-family: url('open-sans.eot'); } diff --git a/tests/Tests/CssEmbed/rsc/open-sans.eot b/tests/Tests/CssEmbed/rsc/open-sans.eot new file mode 100644 index 0000000..7ac1753 Binary files /dev/null and b/tests/Tests/CssEmbed/rsc/open-sans.eot differ diff --git a/tests/Tests/CssEmbed/rsc/open-sans.woff2 b/tests/Tests/CssEmbed/rsc/open-sans.woff2 new file mode 100644 index 0000000..0f1eeae Binary files /dev/null and b/tests/Tests/CssEmbed/rsc/open-sans.woff2 differ diff --git a/tests/Tests/CssEmbed/rsc/pig.svg b/tests/Tests/CssEmbed/rsc/pig.svg new file mode 100644 index 0000000..e4b7e58 --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/pig.svg @@ -0,0 +1,259 @@ + + + SVG Logo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + SVG + + + + + + + + diff --git a/tests/Tests/CssEmbed/rsc/test-http-enabled.css b/tests/Tests/CssEmbed/rsc/test-http-enabled.css new file mode 100644 index 0000000..71f825d --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/test-http-enabled.css @@ -0,0 +1,7 @@ +/* Css file to test phpCssEmbed in HTTP mode **/ + +.this-is a#css-selector { + background: url('test.gif?http_param=1'); + background: url('//httpbin.org/image/png'); + background: url(php.gif); +} diff --git a/tests/Tests/CssEmbed/rsc/test-http-options.css b/tests/Tests/CssEmbed/rsc/test-http-options.css new file mode 100644 index 0000000..6001c2a --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/test-http-options.css @@ -0,0 +1,9 @@ +/* Css file to test phpCssEmbed in HTTP mode **/ + +.this-is a#css-selector { + background: url('//httpbin.org/image/png'); + background: url('http://httpbin.org/image/jpeg'); + background: url('../../image/png'); + background: url('/image/svg'); + background: url('/image/should-be-a-404'); +} diff --git a/tests/Tests/CssEmbed/rsc/test-http-remote.css b/tests/Tests/CssEmbed/rsc/test-http-remote.css new file mode 100644 index 0000000..6001c2a --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/test-http-remote.css @@ -0,0 +1,9 @@ +/* Css file to test phpCssEmbed in HTTP mode **/ + +.this-is a#css-selector { + background: url('//httpbin.org/image/png'); + background: url('http://httpbin.org/image/jpeg'); + background: url('../../image/png'); + background: url('/image/svg'); + background: url('/image/should-be-a-404'); +} diff --git a/tests/Tests/CssEmbed/rsc/test-mime.css b/tests/Tests/CssEmbed/rsc/test-mime.css new file mode 100644 index 0000000..b501a1d --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/test-mime.css @@ -0,0 +1,6 @@ +/* Css file to test phpCssEmbed **/ + +.this-is a#css-selector { + background: url('pig.svg'); + background: url('open-sans.woff2'); +} diff --git a/tests/Tests/CssEmbed/rsc/test-options.css b/tests/Tests/CssEmbed/rsc/test-options.css new file mode 100644 index 0000000..057daff --- /dev/null +++ b/tests/Tests/CssEmbed/rsc/test-options.css @@ -0,0 +1,8 @@ +/* Css file to test phpCssEmbed **/ + +.this-is a#css-selector { + background: url('php.gif'); + background: url('open-sans.eot'); + background: url('pig.svg'); + background: url('file-not-found.gif'); +} diff --git a/tests/Tests/CssEmbed/rsc/test.css b/tests/Tests/CssEmbed/rsc/test.css index a56cb63..ccf354a 100644 --- a/tests/Tests/CssEmbed/rsc/test.css +++ b/tests/Tests/CssEmbed/rsc/test.css @@ -13,4 +13,5 @@ background: url(php.gif);background: url(php.gif);background: url(php.gif); background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAXRSTlMAQObYZgAAAApJREFUCNdjYAAAAAIAAeIhvDMAAAAASUVORK5CYII=); x-foo: url(binary.file); + font-family: url('open-sans.eot'); }