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);
+    }
+}