2 files changed, 633 insertions, 0 deletions

diff --git a/admin/survey/minify/lib/Minify/CSS/Compressor.php b/admin/survey/minify/lib/Minify/CSS/Compressor.php
new file mode 100644
index 0000000..e0ccabb
--- /dev/null
+++ b/admin/survey/minify/lib/Minify/CSS/Compressor.php
@@ -0,0 +1,275 @@
+<?php

+/**

+ * Class Minify_CSS_Compressor

+ * @package Minify

+ */

+

+/**

+ * Compress CSS

+ *

+ * This is a heavy regex-based removal of whitespace, unnecessary

+ * comments and tokens, and some CSS value minimization, where practical.

+ * Many steps have been taken to avoid breaking comment-based hacks,

+ * including the ie5/mac filter (and its inversion), but expect tricky

+ * hacks involving comment tokens in 'content' value strings to break

+ * minimization badly. A test suite is available.

+ *

+ * Note: This replaces a lot of spaces with line breaks. It's rumored

+ * (https://github.com/yui/yuicompressor/blob/master/README.md#global-options)

+ * that some source control tools and old browsers don't like very long lines.

+ * Compressed files with shorter lines are also easier to diff. If this is

+ * unacceptable please use CSSmin instead.

+ *

+ * @package Minify

+ * @author Stephen Clay <steve@mrclay.org>

+ * @author http://code.google.com/u/1stvamp/ (Issue 64 patch)

+ *

+ * @deprecated Use CSSmin (tubalmartin/cssmin)

+ */

+class Minify_CSS_Compressor

+{

+

+    /**

+     * Minify a CSS string

+     *

+     * @param string $css

+     *

+     * @param array $options (currently ignored)

+     *

+     * @return string

+     */

+    public static function process($css, $options = array())

+    {

+        $obj = new Minify_CSS_Compressor($options);

+

+        return $obj->_process($css);

+    }

+

+    /**

+     * @var array

+     */

+    protected $_options = null;

+

+    /**

+     * Are we "in" a hack? I.e. are some browsers targetted until the next comment?

+     *

+     * @var bool

+     */

+    protected $_inHack = false;

+

+    /**

+     * Constructor

+     *

+     * @param array $options (currently ignored)

+     */

+    private function __construct($options)

+    {

+        $this->_options = $options;

+    }

+

+    /**

+     * Minify a CSS string

+     *

+     * @param string $css

+     *

+     * @return string

+     */

+    protected function _process($css)

+    {

+        $css = str_replace("\r\n", "\n", $css);

+

+        // preserve empty comment after '>'

+        // http://www.webdevout.net/css-hacks#in_css-selectors

+        $css = preg_replace('@>/\\*\\s*\\*/@', '>/*keep*/', $css);

+

+        // preserve empty comment between property and value

+        // http://css-discuss.incutio.com/?page=BoxModelHack

+        $css = preg_replace('@/\\*\\s*\\*/\\s*:@', '/*keep*/:', $css);

+        $css = preg_replace('@:\\s*/\\*\\s*\\*/@', ':/*keep*/', $css);

+

+        // apply callback to all valid comments (and strip out surrounding ws

+        $pattern = '@\\s*/\\*([\\s\\S]*?)\\*/\\s*@';

+        $css = preg_replace_callback($pattern, array($this, '_commentCB'), $css);

+

+        // remove ws around { } and last semicolon in declaration block

+        $css = preg_replace('/\\s*{\\s*/', '{', $css);

+        $css = preg_replace('/;?\\s*}\\s*/', '}', $css);

+

+        // remove ws surrounding semicolons

+        $css = preg_replace('/\\s*;\\s*/', ';', $css);

+

+        // remove ws around urls

+        $pattern = '/

+                url\\(      # url(

+                \\s*

+                ([^\\)]+?)  # 1 = the URL (really just a bunch of non right parenthesis)

+                \\s*

+                \\)         # )

+            /x';

+        $css = preg_replace($pattern, 'url($1)', $css);

+

+        // remove ws between rules and colons

+        $pattern = '/

+                \\s*

+                ([{;])              # 1 = beginning of block or rule separator

+                \\s*

+                ([\\*_]?[\\w\\-]+)  # 2 = property (and maybe IE filter)

+                \\s*

+                :

+                \\s*

+                (\\b|[#\'"-])        # 3 = first character of a value

+            /x';

+        $css = preg_replace($pattern, '$1$2:$3', $css);

+

+        // remove ws in selectors

+        $pattern = '/

+                (?:              # non-capture

+                    \\s*

+                    [^~>+,\\s]+  # selector part

+                    \\s*

+                    [,>+~]       # combinators

+                )+

+                \\s*

+                [^~>+,\\s]+      # selector part

+                {                # open declaration block

+            /x';

+        $css = preg_replace_callback($pattern, array($this, '_selectorsCB'), $css);

+

+        // minimize hex colors

+        $pattern = '/([^=])#([a-f\\d])\\2([a-f\\d])\\3([a-f\\d])\\4([\\s;\\}])/i';

+        $css = preg_replace($pattern, '$1#$2$3$4$5', $css);

+

+        // remove spaces between font families

+        $pattern = '/font-family:([^;}]+)([;}])/';

+        $css = preg_replace_callback($pattern, array($this, '_fontFamilyCB'), $css);

+

+        $css = preg_replace('/@import\\s+url/', '@import url', $css);

+

+        // replace any ws involving newlines with a single newline

+        $css = preg_replace('/[ \\t]*\\n+\\s*/', "\n", $css);

+

+        // separate common descendent selectors w/ newlines (to limit line lengths)

+        $pattern = '/([\\w#\\.\\*]+)\\s+([\\w#\\.\\*]+){/';

+        $css = preg_replace($pattern, "$1\n$2{", $css);

+

+        // Use newline after 1st numeric value (to limit line lengths).

+        $pattern = '/

+            ((?:padding|margin|border|outline):\\d+(?:px|em)?) # 1 = prop : 1st numeric value

+            \\s+

+            /x';

+        $css = preg_replace($pattern, "$1\n", $css);

+

+        // prevent triggering IE6 bug: http://www.crankygeek.com/ie6pebug/

+        $css = preg_replace('/:first-l(etter|ine)\\{/', ':first-l$1 {', $css);

+

+        return trim($css);

+    }

+

+    /**

+     * Replace what looks like a set of selectors

+     *

+     * @param array $m regex matches

+     *

+     * @return string

+     */

+    protected function _selectorsCB($m)

+    {

+        // remove ws around the combinators

+        return preg_replace('/\\s*([,>+~])\\s*/', '$1', $m[0]);

+    }

+

+    /**

+     * Process a comment and return a replacement

+     *

+     * @param array $m regex matches

+     *

+     * @return string

+     */

+    protected function _commentCB($m)

+    {

+        $hasSurroundingWs = (trim($m[0]) !== $m[1]);

+        $m = $m[1];

+        // $m is the comment content w/o the surrounding tokens,

+        // but the return value will replace the entire comment.

+        if ($m === 'keep') {

+            return '/**/';

+        }

+

+        if ($m === '" "') {

+            // component of http://tantek.com/CSS/Examples/midpass.html

+            return '/*" "*/';

+        }

+

+        if (preg_match('@";\\}\\s*\\}/\\*\\s+@', $m)) {

+            // component of http://tantek.com/CSS/Examples/midpass.html

+            return '/*";}}/* */';

+        }

+

+        if ($this->_inHack) {

+            // inversion: feeding only to one browser

+            $pattern = '@

+                    ^/               # comment started like /*/

+                    \\s*

+                    (\\S[\\s\\S]+?)  # has at least some non-ws content

+                    \\s*

+                    /\\*             # ends like /*/ or /**/

+                @x';

+            if (preg_match($pattern, $m, $n)) {

+                // end hack mode after this comment, but preserve the hack and comment content

+                $this->_inHack = false;

+

+                return "/*/{$n[1]}/**/";

+            }

+        }

+

+        if (substr($m, -1) === '\\') { // comment ends like \*/

+            // begin hack mode and preserve hack

+            $this->_inHack = true;

+

+            return '/*\\*/';

+        }

+

+        if ($m !== '' && $m[0] === '/') { // comment looks like /*/ foo */

+            // begin hack mode and preserve hack

+            $this->_inHack = true;

+

+            return '/*/*/';

+        }

+

+        if ($this->_inHack) {

+            // a regular comment ends hack mode but should be preserved

+            $this->_inHack = false;

+

+            return '/**/';

+        }

+

+        // Issue 107: if there's any surrounding whitespace, it may be important, so

+        // replace the comment with a single space

+        return $hasSurroundingWs ? ' ' : ''; // remove all other comments

+    }

+

+    /**

+     * Process a font-family listing and return a replacement

+     *

+     * @param array $m regex matches

+     *

+     * @return string

+     */

+    protected function _fontFamilyCB($m)

+    {

+        // Issue 210: must not eliminate WS between words in unquoted families

+        $flags = PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY;

+        $pieces = preg_split('/(\'[^\']+\'|"[^"]+")/', $m[1], null, $flags);

+        $out = 'font-family:';

+

+        while (null !== ($piece = array_shift($pieces))) {

+            if ($piece[0] !== '"' && $piece[0] !== "'") {

+                $piece = preg_replace('/\\s+/', ' ', $piece);

+                $piece = preg_replace('/\\s?,\\s?/', ',', $piece);

+            }

+            $out .= $piece;

+        }

+

+        return $out . $m[2];

+    }

+}

diff --git a/admin/survey/minify/lib/Minify/CSS/UriRewriter.php b/admin/survey/minify/lib/Minify/CSS/UriRewriter.php
new file mode 100644
index 0000000..6f69908
--- /dev/null
+++ b/admin/survey/minify/lib/Minify/CSS/UriRewriter.php
@@ -0,0 +1,358 @@
+<?php

+/**

+ * Class Minify_CSS_UriRewriter

+ * @package Minify

+ */

+

+/**

+ * Rewrite file-relative URIs as root-relative in CSS files

+ *

+ * @package Minify

+ * @author Stephen Clay <steve@mrclay.org>

+ */

+class Minify_CSS_UriRewriter

+{

+

+    /**

+     * rewrite() and rewriteRelative() append debugging information here

+     *

+     * @var string

+     */

+    public static $debugText = '';

+

+    /**

+     * In CSS content, rewrite file relative URIs as root relative

+     *

+     * @param string $css

+     *

+     * @param string $currentDir The directory of the current CSS file.

+     *

+     * @param string $docRoot The document root of the web site in which

+     * the CSS file resides (default = $_SERVER['DOCUMENT_ROOT']).

+     *

+     * @param array $symlinks (default = array()) If the CSS file is stored in

+     * a symlink-ed directory, provide an array of link paths to

+     * target paths, where the link paths are within the document root. Because

+     * paths need to be normalized for this to work, use "//" to substitute

+     * the doc root in the link paths (the array keys). E.g.:

+     * <code>

+     * array('//symlink' => '/real/target/path') // unix

+     * array('//static' => 'D:\\staticStorage')  // Windows

+     * </code>

+     *

+     * @return string

+     */

+    public static function rewrite($css, $currentDir, $docRoot = null, $symlinks = array())

+    {

+        self::$_docRoot = self::_realpath(

+            $docRoot ? $docRoot : $_SERVER['DOCUMENT_ROOT']

+        );

+        self::$_currentDir = self::_realpath($currentDir);

+        self::$_symlinks = array();

+

+        // normalize symlinks in order to map to link

+        foreach ($symlinks as $link => $target) {

+            $link = ($link === '//') ? self::$_docRoot : str_replace('//', self::$_docRoot . '/', $link);

+            $link = strtr($link, '/', DIRECTORY_SEPARATOR);

+

+            self::$_symlinks[$link] = self::_realpath($target);

+        }

+

+        self::$debugText .= "docRoot    : " . self::$_docRoot . "\n"

+                          . "currentDir : " . self::$_currentDir . "\n";

+        if (self::$_symlinks) {

+            self::$debugText .= "symlinks : " . var_export(self::$_symlinks, 1) . "\n";

+        }

+        self::$debugText .= "\n";

+

+        $css = self::_trimUrls($css);

+

+        $css = self::_owlifySvgPaths($css);

+

+        // rewrite

+        $pattern = '/@import\\s+([\'"])(.*?)[\'"]/';

+        $css = preg_replace_callback($pattern, array(self::$className, '_processUriCB'), $css);

+

+        $pattern = '/url\\(\\s*([\'"](.*?)[\'"]|[^\\)\\s]+)\\s*\\)/';

+        $css = preg_replace_callback($pattern, array(self::$className, '_processUriCB'), $css);

+

+        $css = self::_unOwlify($css);

+

+        return $css;

+    }

+

+    /**

+     * In CSS content, prepend a path to relative URIs

+     *

+     * @param string $css

+     *

+     * @param string $path The path to prepend.

+     *

+     * @return string

+     */

+    public static function prepend($css, $path)

+    {

+        self::$_prependPath = $path;

+

+        $css = self::_trimUrls($css);

+

+        $css = self::_owlifySvgPaths($css);

+        

+        // append

+        $pattern = '/@import\\s+([\'"])(.*?)[\'"]/';

+        $css = preg_replace_callback($pattern, array(self::$className, '_processUriCB'), $css);

+

+        $pattern = '/url\\(\\s*([\'"](.*?)[\'"]|[^\\)\\s]+)\\s*\\)/';

+        $css = preg_replace_callback($pattern, array(self::$className, '_processUriCB'), $css);

+

+        $css = self::_unOwlify($css);

+

+        self::$_prependPath = null;

+

+        return $css;

+    }

+

+    /**

+     * Get a root relative URI from a file relative URI

+     *

+     * <code>

+     * Minify_CSS_UriRewriter::rewriteRelative(

+     *       '../img/hello.gif'

+     *     , '/home/user/www/css'  // path of CSS file

+     *     , '/home/user/www'      // doc root

+     * );

+     * // returns '/img/hello.gif'

+     *

+     * // example where static files are stored in a symlinked directory

+     * Minify_CSS_UriRewriter::rewriteRelative(

+     *       'hello.gif'

+     *     , '/var/staticFiles/theme'

+     *     , '/home/user/www'

+     *     , array('/home/user/www/static' => '/var/staticFiles')

+     * );

+     * // returns '/static/theme/hello.gif'

+     * </code>

+     *

+     * @param string $uri file relative URI

+     *

+     * @param string $realCurrentDir realpath of the current file's directory.

+     *

+     * @param string $realDocRoot realpath of the site document root.

+     *

+     * @param array $symlinks (default = array()) If the file is stored in

+     * a symlink-ed directory, provide an array of link paths to

+     * real target paths, where the link paths "appear" to be within the document

+     * root. E.g.:

+     * <code>

+     * array('/home/foo/www/not/real/path' => '/real/target/path') // unix

+     * array('C:\\htdocs\\not\\real' => 'D:\\real\\target\\path')  // Windows

+     * </code>

+     *

+     * @return string

+     */

+    public static function rewriteRelative($uri, $realCurrentDir, $realDocRoot, $symlinks = array())

+    {

+        // prepend path with current dir separator (OS-independent)

+        $path = strtr($realCurrentDir, '/', DIRECTORY_SEPARATOR);

+        $path .= DIRECTORY_SEPARATOR . strtr($uri, '/', DIRECTORY_SEPARATOR);

+

+        self::$debugText .= "file-relative URI  : {$uri}\n"

+                          . "path prepended     : {$path}\n";

+

+        // "unresolve" a symlink back to doc root

+        foreach ($symlinks as $link => $target) {

+            if (0 === strpos($path, $target)) {

+                // replace $target with $link

+                $path = $link . substr($path, strlen($target));

+

+                self::$debugText .= "symlink unresolved : {$path}\n";

+

+                break;

+            }

+        }

+        // strip doc root

+        $path = substr($path, strlen($realDocRoot));

+

+        self::$debugText .= "docroot stripped   : {$path}\n";

+

+        // fix to root-relative URI

+        $uri = strtr($path, '/\\', '//');

+        $uri = self::removeDots($uri);

+

+        self::$debugText .= "traversals removed : {$uri}\n\n";

+

+        return $uri;

+    }

+

+    /**

+     * Remove instances of "./" and "../" where possible from a root-relative URI

+     *

+     * @param string $uri

+     *

+     * @return string

+     */

+    public static function removeDots($uri)

+    {

+        $uri = str_replace('/./', '/', $uri);

+        // inspired by patch from Oleg Cherniy

+        do {

+            $uri = preg_replace('@/[^/]+/\\.\\./@', '/', $uri, 1, $changed);

+        } while ($changed);

+

+        return $uri;

+    }

+

+    /**

+     * Defines which class to call as part of callbacks, change this

+     * if you extend Minify_CSS_UriRewriter

+     *

+     * @var string

+     */

+    protected static $className = 'Minify_CSS_UriRewriter';

+

+    /**

+     * Get realpath with any trailing slash removed. If realpath() fails,

+     * just remove the trailing slash.

+     *

+     * @param string $path

+     *

+     * @return mixed path with no trailing slash

+     */

+    protected static function _realpath($path)

+    {

+        $realPath = realpath($path);

+        if ($realPath !== false) {

+            $path = $realPath;

+        }

+

+        return rtrim($path, '/\\');

+    }

+

+    /**

+     * Directory of this stylesheet

+     *

+     * @var string

+     */

+    private static $_currentDir = '';

+

+    /**

+     * DOC_ROOT

+     *

+     * @var string

+     */

+    private static $_docRoot = '';

+

+    /**

+     * directory replacements to map symlink targets back to their

+     * source (within the document root) E.g. '/var/www/symlink' => '/var/realpath'

+     *

+     * @var array

+     */

+    private static $_symlinks = array();

+

+    /**

+     * Path to prepend

+     *

+     * @var string

+     */

+    private static $_prependPath = null;

+

+    /**

+     * @param string $css

+     *

+     * @return string

+     */

+    private static function _trimUrls($css)

+    {

+        $pattern = '/

+            url\\(      # url(

+            \\s*

+            ([^\\)]+?)  # 1 = URI (assuming does not contain ")")

+            \\s*

+            \\)         # )

+        /x';

+

+        return preg_replace($pattern, 'url($1)', $css);

+    }

+

+    /**

+     * @param array $m

+     *

+     * @return string

+     */

+    private static function _processUriCB($m)

+    {

+        // $m matched either '/@import\\s+([\'"])(.*?)[\'"]/' or '/url\\(\\s*([^\\)\\s]+)\\s*\\)/'

+        $isImport = ($m[0][0] === '@');

+        // determine URI and the quote character (if any)

+        if ($isImport) {

+            $quoteChar = $m[1];

+            $uri = $m[2];

+        } else {

+            // $m[1] is either quoted or not

+            $quoteChar = ($m[1][0] === "'" || $m[1][0] === '"') ? $m[1][0] : '';

+

+            $uri = ($quoteChar === '') ? $m[1] : substr($m[1], 1, strlen($m[1]) - 2);

+        }

+

+        if ($uri === '') {

+            return $m[0];

+        }

+

+        // if not root/scheme relative and not starts with scheme

+        if (!preg_match('~^(/|[a-z]+\:)~', $uri)) {

+            // URI is file-relative: rewrite depending on options

+            if (self::$_prependPath === null) {

+                $uri = self::rewriteRelative($uri, self::$_currentDir, self::$_docRoot, self::$_symlinks);

+            } else {

+                $uri = self::$_prependPath . $uri;

+                if ($uri[0] === '/') {

+                    $root = '';

+                    $rootRelative = $uri;

+                    $uri = $root . self::removeDots($rootRelative);

+                } elseif (preg_match('@^((https?\:)?//([^/]+))/@', $uri, $m) && (false !== strpos($m[3], '.'))) {

+                    $root = $m[1];

+                    $rootRelative = substr($uri, strlen($root));

+                    $uri = $root . self::removeDots($rootRelative);

+                }

+            }

+        }

+

+        if ($isImport) {

+            return "@import {$quoteChar}{$uri}{$quoteChar}";

+        } else {

+            return "url({$quoteChar}{$uri}{$quoteChar})";

+        }

+    }

+

+    /**

+     * Mungs some inline SVG URL declarations so they won't be touched

+     *

+     * @link https://github.com/mrclay/minify/issues/517

+     * @see _unOwlify

+     *

+     * @param string $css

+     * @return string

+     */

+    private static function _owlifySvgPaths($css)

+    {

+        $pattern = '~\b((?:clip-path|mask|-webkit-mask)\s*\:\s*)url(\(\s*#\w+\s*\))~';

+

+        return preg_replace($pattern, '$1owl$2', $css);

+    }

+

+    /**

+     * Undo work of _owlify

+     *

+     * @see _owlifySvgPaths

+     *

+     * @param string $css

+     * @return string

+     */

+    private static function _unOwlify($css)

+    {

+        $pattern = '~\b((?:clip-path|mask|-webkit-mask)\s*\:\s*)owl~';

+

+        return preg_replace($pattern, '$1url', $css);

+    }

+}