From c9c31d6edb91e22c56ffab3772ce8a29b1480537 Mon Sep 17 00:00:00 2001 From: wei <> Date: Sun, 25 Mar 2007 07:04:08 +0000 Subject: Update TinyMCE to 2.1, Js prototype to 1.5.1rc, effects to 1.7 --- buildscripts/jsbuilder/build.php | 44 +--- buildscripts/jsbuilder/jsmin.php | 537 +++++++++++++++++++++++++++++---------- 2 files changed, 406 insertions(+), 175 deletions(-) (limited to 'buildscripts') diff --git a/buildscripts/jsbuilder/build.php b/buildscripts/jsbuilder/build.php index 391899e6..19824932 100644 --- a/buildscripts/jsbuilder/build.php +++ b/buildscripts/jsbuilder/build.php @@ -40,6 +40,8 @@ define('DOC_OUTPUT_DIR', realpath(dirname(__FILE__).'/../../docs/Javascript')); */ define('BUILD_DOC', sprintf('perl "%s" --no-sources -d "%s" ', JS_DOC, DOC_OUTPUT_DIR).'%s'); +define('JSMIN_AS_LIB',true); + include(dirname(__FILE__).'/jsmin.php'); if(SOURCE_DIR===false || TARGET_DIR===false) @@ -55,33 +57,14 @@ $libraries = array( //base javascript functions 'prototype/prototype.js', - 'prototype/base.js', + 'effects/builder.js', + 'extended/base.js', - 'prototype/string.js', 'extended/string.js', - 'prototype/enumerable.js', - 'prototype/array.js', - 'prototype/hash.js', - 'prototype/range.js', - - //dom functions - 'prototype/dom.js', - 'prototype/form.js', - 'prototype/event.js', 'extended/event.js', - 'prototype/position.js', - - //element selectors - 'prototype/selector.js', - - //build dom elements with DIV, A, UL, etc functions - 'effects/builder.js', + 'extended/date.js', 'extended/builder.js', -// 'extra/getElementsBySelector.js', -// 'extra/behaviour.js', - - 'extended/date.js', //prado core 'prado/prado.js', @@ -97,27 +80,12 @@ $libraries = array( 'effects.js' => array( 'effects/effects.js' ), - //active controls - 'ajax.js' => array( - 'prototype/ajax.js', -// 'prado/ajax.js', -// 'extra/json.js', - 'effects/controls.js', - 'effects/dragdrop.js', - 'effects/slider.js', -// 'prado/activecontrols.js' - ), + //logging 'logger.js' => array( 'extra/logger.js', ), - //rico - 'rico.js' => array( - 'rico/rico.js', - 'rico/extension.js' - ), - //validator 'validator.js' => array( 'prado/validation3.js' diff --git a/buildscripts/jsbuilder/jsmin.php b/buildscripts/jsbuilder/jsmin.php index 4abf1b34..bc63dd4e 100644 --- a/buildscripts/jsbuilder/jsmin.php +++ b/buildscripts/jsbuilder/jsmin.php @@ -1,7 +1,6 @@ of CFD Labs, France -* @version 0.1 (PHP translation) 2006-04-11 +* @author Gaetano Giunta +* @version $Id: $ * * Please note, this is a brutal and simple conversion : it could undoubtedly be * improved, as a PHP implementation, by applying more PHP-specific programming * features. * -* PHP 5 is required because OO style of programming is used, as well as classes -* from the Standard PHP Library (SPL). +* Exceptions and all PHP 5 - only features ahve been removed for compat with PHP 4 * * Note : whereas jsmin.c works specifically with the standard input and output * streams, this implementation only falls back on them if file pathnames are @@ -66,13 +65,24 @@ * (etc...) * * See JSMin.php -h (or --help) for command-line documentation. +* +* NEW AND IMPROVED in version 0.2: +* to take advantage of this file in your own code, you can do the following: +* +* define('JSMIN_AS_LIB', true); // prevents auto-run on include +* include('jsmin.php'); +* // the JSMin class now works on php strings, too +* $jsMin = new JSMin(file_get_contents('e:/htdocs/awstats_misc_tracker.js'), false); +* // in that case, the modifies string is returned by minify(): +* $out = $jsMin->minify(); +* */ /** * Version of this PHP translation. */ -define('VERSION', '0.1'); +define('JSMIN_VERSION', '0.2'); /** * How fgetc() reports an End Of File. @@ -98,9 +108,12 @@ define('ORD_9', ord('9')); /** * Generic exception class related to JSMin. */ - +/* class JSMinException extends Exception { } +*/ +class JSMinException { +} /** * A JSMin exception indicating that a file provided for input or output could not be properly opened. @@ -130,64 +143,67 @@ class UnterminatedStringLiteralJSMinException extends JSMinException { class UnterminatedRegExpLiteralJSMinException extends JSMinException { } +/** + * Constant describing an {@link action()} : Output A. Copy B to A. Get the next B. + */ + +define ('JSMIN_ACT_FULL', 1); + +/** + * Constant describing an {@link action()} : Copy B to A. Get the next B. (Delete A). + */ + +define ('JSMIN_ACT_BUF', 2); + +/** + * Constant describing an {@link action()} : Get the next B. (Delete B). + */ + +define ('JSMIN_ACT_IMM', 3); + /** * Main JSMin application class. * * Example of use : * * $jsMin = new JSMin(...input..., ...output...); -* $jsMin -> minify(); +* $jsMin->minify(); * * Do not specify input and/or output (or default to '-') to use stdin and/or stdout. */ class JSMin { - /** - * Constant describing an {@link action()} : Output A. Copy B to A. Get the next B. - */ - - const ACT_FULL = 1; - - /** - * Constant describing an {@link action()} : Copy B to A. Get the next B. (Delete A). - */ - - const ACT_BUF = 2; - - /** - * Constant describing an {@link action()} : Get the next B. (Delete B). - */ - - const ACT_IMM = 3; - /** * The input stream, from which to read a JS file to minimize. Obtained by fopen(). - * @var SplFileObject + * NB: might be a string instead of a stream + * @var SplFileObject | string */ - - private $in; + var $in; /** * The output stream, in which to write the minimized JS file. Obtained by fopen(). - * @var SplFileObject + * NB: might be a string instead of a stream + * @var SplFileObject | string */ - - private $out; + var $out; /** * Temporary I/O character (A). * @var string */ - - private $theA; + var $theA; /** * Temporary I/O character (B). * @var string */ + var $theB; - private $theB; + /** variables used for string-based parsing **/ + var $inLength = 0; + var $inPos = 0; + var $isString = false; /** * Indicates whether a character is alphanumeric or _, $, \ or non-ASCII. @@ -195,8 +211,7 @@ class JSMin { * @param string $c The single character to test. * @return boolean Whether the char is a letter, digit, underscore, dollar, backslash, or non-ASCII. */ - - private static function isAlphaNum($c) { + function isAlphaNum($c) { // Get ASCII value of character for C-like comparisons @@ -222,12 +237,21 @@ class JSMin { * @see $in * @see peek() */ - - private function get() { + function get() { // Get next input character and advance position in file - - $c = $this -> in -> fgetc(); +//var_dump($this); + if ($this->isString) { + if ($this->inPos < $this->inLength) { + $c = $this->in[$this->inPos]; + ++$this->inPos; + } + else { + return EOF; + } + } + else + $c = $this->in->fgetc(); // Test for non-problematic characters @@ -256,22 +280,45 @@ class JSMin { * @see $in * @see get() */ + function peek() { - private function peek() { + if ($this->isString) { + if ($this->inPos < $this->inLength) { + $c = $this->in[$this->inPos]; + } + else { + return EOF; + } + } + else { + // Get next input character - // Get next input character + $c = $this->in->fgetc(); - $c = $this -> in -> fgetc(); + // Regress position in file - // Regress position in file + $this->in->fseek(-1, SEEK_CUR); - $this -> in -> fseek(-1, SEEK_CUR); - - // Return character obtained + // Return character obtained + } return $c; } + /** + * Adds a char to the output steram / string + * @see $out + */ + function put($c) + { + if ($this->isString) { + $this->out .= $c; + } + else { + $this->out->fwrite($c); + } + } + /** * Get the next character from the input stream, excluding comments. * @@ -281,12 +328,11 @@ class JSMin { * @return string The next character from the specified input stream, skipping comments. * @see $in */ - - private function next() { + function next() { // Get next char from input, translated if necessary - $c = $this -> get(); + $c = $this->get(); // Check comment possibility @@ -294,16 +340,16 @@ class JSMin { // Look ahead : a comment is two slashes or slashes followed by asterisk (to be closed) - switch ($this -> peek()) { + switch ($this->peek()) { case '/' : // Comment is up to the end of the line - // TOTEST : simple $this -> in -> fgets() + // TOTEST : simple $this->in->fgets() while (true) { - $c = $this -> get(); + $c = $this->get(); if (ord($c) <= ORD_NL) { return $c; @@ -319,17 +365,17 @@ class JSMin { // N.B. not using switch() because of having to test EOF with === - $c = $this -> get(); + $c = $this->get(); if ($c == '*') { // Comment termination if the char ahead is a slash - if ($this -> peek() == '/') { + if ($this->peek() == '/') { // Advance again and make into a single space - $this -> get(); + $this->get(); return ' '; } } @@ -337,7 +383,8 @@ class JSMin { // Whoopsie - throw new UnterminatedCommentJSMinException(); + //throw new UnterminatedCommentJSMinException(); + trigger_error('UnterminatedComment', E_USER_ERROR); } } @@ -359,34 +406,33 @@ class JSMin { * * The action to perform is determined by the argument : * - * JSMin :: ACT_FULL : Output A. Copy B to A. Get the next B. - * JSMin :: ACT_BUF : Copy B to A. Get the next B. (Delete A). - * JSMin :: ACT_IMM : Get the next B. (Delete B). + * JSMin::ACT_FULL : Output A. Copy B to A. Get the next B. + * JSMin::ACT_BUF : Copy B to A. Get the next B. (Delete A). + * JSMin::ACT_IMM : Get the next B. (Delete B). * * A string is treated as a single character. Also, regular expressions are recognized if preceded * by '(', ',' or '='. * - * @param int $action The action to perform : one of the JSMin :: ACT_* constants. + * @param int $action The action to perform : one of the JSMin::ACT_* constants. */ - - private function action($action) { + function action($action) { // Choice of possible actions // Note the frequent fallthroughs : the actions are decrementally "long" switch ($action) { - case self :: ACT_FULL : + case JSMIN_ACT_FULL : // Write A to output, then fall through - $this -> out -> fwrite($this -> theA); + $this->put($this->theA); - case self :: ACT_BUF : // N.B. possible fallthrough from above + case JSMIN_ACT_BUF : // N.B. possible fallthrough from above // Copy B to A - $tmpA = $this -> theA = $this -> theB; + $tmpA = $this->theA = $this->theB; // Treating a string as a single char : outputting it whole // Note that the string-opening char (" or ') is memorized in B @@ -397,15 +443,15 @@ class JSMin { // Output string contents - $this -> out -> fwrite($tmpA); + $this->put($tmpA); // Get next character, watching out for termination of the current string, // new line & co (then the string is not terminated !), or a backslash // (upon which the following char is directly output to serve the escape mechanism) - $tmpA = $this -> theA = $this -> get(); + $tmpA = $this->theA = $this->get(); - if ($tmpA == $this -> theB) { + if ($tmpA == $this->theB) { // String terminated @@ -418,7 +464,8 @@ class JSMin { // Whoopsie - throw new UnterminatedStringLiteralJSMinException(); + //throw new UnterminatedStringLiteralJSMinException(); + trigger_error('UnterminatedStringLiteral', E_USER_ERROR); } // else @@ -427,36 +474,36 @@ class JSMin { // Escape next char immediately - $this -> out -> fwrite($tmpA); - $tmpA = $this -> theA = $this -> get(); + $this->put($tmpA); + $tmpA = $this->theA = $this->get(); } } } - case self :: ACT_IMM : // N.B. possible fallthrough from above + case JSMIN_ACT_IMM : // N.B. possible fallthrough from above // Get the next B - $this -> theB = $this -> next(); + $this->theB = $this->next(); // Special case of recognising regular expressions (beginning with /) that are // preceded by '(', ',' or '=' - $tmpA = $this -> theA; + $tmpA = $this->theA; - if ($this -> theB == '/' && ($tmpA == '(' || $tmpA == ',' || $tmpA == '=')) { + if ($this->theB == '/' && ($tmpA == '(' || $tmpA == ',' || $tmpA == '=')) { // Output the two successive chars - $this -> out -> fwrite($tmpA); - $this -> out -> fwrite($this -> theB); + $this->put($tmpA); + $this->put($this->theB); // Look for the end of the RE literal, watching out for escaped chars or a control / // end of line char (the RE literal then being unterminated !) while (true) { - $tmpA = $this -> theA = $this -> get(); + $tmpA = $this->theA = $this->get(); if ($tmpA == '/') { @@ -471,28 +518,31 @@ class JSMin { // Escape next char immediately - $this -> out -> fwrite($tmpA); - $tmpA = $this -> theA = $this -> get(); + $this->put($tmpA); + $tmpA = $this->theA = $this->get(); } else if (ord($tmpA) <= ORD_NL) { // Whoopsie - throw new UnterminatedRegExpLiteralJSMinException(); + //throw new UnterminatedRegExpLiteralJSMinException(); + trigger_error('UnterminatedRegExpLiteral', E_USER_ERROR); } // Output RE characters - $this -> out -> fwrite($tmpA); + $this->put($tmpA); } // Move forward after the RE literal - $this -> theB = $this -> next(); + $this->theB = $this->next(); } break; - default : throw new JSMinException('Expected a JSMin :: ACT_* constant in action().'); + default : + //throw new JSMinException('Expected a JSMin::ACT_* constant in action().'); + trigger_error('Expected a JSMin::ACT_* constant in action()', E_USER_ERROR); } } @@ -500,6 +550,7 @@ class JSMin { * Run the JSMin application : minify some JS code. * * The code is read from the input stream, and its minified version is written to the output one. + * In case input is a string, minified vesrions is also returned by this function as string. * That is : characters which are insignificant to JavaScript are removed, as well as comments ; * tabs are replaced with spaces ; carriage returns are replaced with linefeeds, and finally most * spaces and linefeeds are deleted. @@ -507,54 +558,54 @@ class JSMin { * Note : name was changed from jsmin() because PHP identifiers are case-insensitive, and it is already * the name of this class. * - * @see __construct() + * @see JSMin() + * @return null | string */ - - public function minify() { + function minify() { // Initialize A and run the first (minimal) action - $this -> theA = "\n"; - $this -> action(self :: ACT_IMM); + $this->theA = "\n"; + $this->action(JSMIN_ACT_IMM); // Proceed all the way to the end of the input file - while ($this -> theA !== EOF) { + while ($this->theA !== EOF) { - switch ($this -> theA) { + switch ($this->theA) { case ' ' : - if (self :: isAlphaNum($this -> theB)) { - $this -> action(self :: ACT_FULL); + if (JSMin::isAlphaNum($this->theB)) { + $this->action(JSMIN_ACT_FULL); } else { - $this -> action(self :: ACT_BUF); + $this->action(JSMIN_ACT_BUF); } break; case "\n" : - switch ($this -> theB) { + switch ($this->theB) { case '{' : case '[' : case '(' : case '+' : case '-' : - $this -> action(self :: ACT_FULL); + $this->action(JSMIN_ACT_FULL); break; case ' ' : - $this -> action(self :: ACT_IMM); + $this->action(JSMIN_ACT_IMM); break; default : - if (self :: isAlphaNum($this -> theB)) { - $this -> action(self :: ACT_FULL); + if (JSMin::isAlphaNum($this->theB)) { + $this->action(JSMIN_ACT_FULL); } else { - $this -> action(self :: ACT_BUF); + $this->action(JSMIN_ACT_BUF); } break; @@ -563,38 +614,38 @@ class JSMin { break; default : - switch ($this -> theB) { + switch ($this->theB) { case ' ' : - if (self :: isAlphaNum($this -> theA)) { + if (JSMin::isAlphaNum($this->theA)) { - $this -> action(self :: ACT_FULL); + $this->action(JSMIN_ACT_FULL); break; } // else - $this -> action(self :: ACT_IMM); + $this->action(JSMIN_ACT_IMM); break; case "\n" : - switch ($this -> theA) { + switch ($this->theA) { case '}' : case ']' : case ')' : case '+' : case '-' : case '"' : case '\'' : - $this -> action(self :: ACT_FULL); + $this->action(JSMIN_ACT_FULL); break; default : - if (self :: isAlphaNum($this -> theA)) { - $this -> action(self :: ACT_FULL); + if (JSMin::isAlphaNum($this->theA)) { + $this->action(JSMIN_ACT_FULL); } else { - $this -> action(self :: ACT_IMM); + $this->action(JSMIN_ACT_IMM); } break; @@ -603,7 +654,7 @@ class JSMin { break; default : - $this -> action(self :: ACT_FULL); + $this->action(JSMIN_ACT_FULL); break; } @@ -611,6 +662,11 @@ class JSMin { break; } } + + if ($this->isString) { + return $this->out; + + } } /** @@ -620,49 +676,256 @@ class JSMin { * * @param string $inFileName The pathname of the input (unminified JS) file. STDIN if '-' or absent. * @param string $outFileName The pathname of the output (minified JS) file. STDOUT if '-' or absent. + * If outFileName === FALSE, we assume that inFileName is in fact the string to be minified!!! * @param array $comments Optional lines to present as comments at the beginning of the output. - * @throws FileOpenFailedJSMinException If the input and/or output file pathname is not provided, and - * respectively STDIN and/or STDOUT are not available (ie, script is not being used in CLI). */ + function JSMin($inFileName = '-', $outFileName = '-', $comments = NULL) { + if ($outFileName === FALSE) { + $this->JSMin_String($inFileName, $comments); + } + else { + $this->JSMin_File($inFileName, $outFileName, $comments); + } + } - public function __construct($inFileName = '-', $outFileName = '-', $comments = NULL) { + function JSMin_File($inFileName = '-', $outFileName = '-', $comments = NULL) { // Recuperate input and output streams. // Use STDIN and STDOUT by default, if they are defined (CLI mode) and no file names are provided - if ($inFileName == '-') $inFileName = 'php://stdin'; - if ($outFileName == '-') $outFileName = 'php://stdout'; + if ($inFileName == '-') $inFileName = 'php://stdin'; + if ($outFileName == '-') $outFileName = 'php://stdout'; - try { + try { - $this -> in = new SplFileObject($inFileName, 'rb', TRUE); - } - catch (Exception $e) { + $this->in = new SplFileObject($inFileName, 'rb', TRUE); + } + catch (Exception $e) { - throw new FileOpenFailedJSMinException( - 'Failed to open "'.$inFileName.'" for reading only.' - ); - } + throw new FileOpenFailedJSMinException( + 'Failed to open "'.$inFileName.'" for reading only.' + ); + } - try { + try { - $this -> out = new SplFileObject($outFileName, 'wb', TRUE); - } - catch (Exception $e) { + $this->out = new SplFileObject($outFileName, 'wb', TRUE); + } + catch (Exception $e) { - throw new FileOpenFailedJSMinException( - 'Failed to open "'.$outFileName.'" for writing only.' - ); - } + throw new FileOpenFailedJSMinException( + 'Failed to open "'.$outFileName.'" for writing only.' + ); + } - // Present possible initial comments + /*$this->in = fopen($inFileName, 'rb'); + if (!$this->in) { + trigger_error('Failed to open "'.$inFileName, E_USER_ERROR); + } + $this->out = fopen($outFileName, 'wb'); + if (!$this->out) { + trigger_error('Failed to open "'.$outFileName, E_USER_ERROR); + }*/ + + // Present possible initial comments + + if ($comments !== NULL) { + foreach ($comments as $comm) { + $this->out->fwrite('// '.str_replace("\n", " ", $comm)."\n"); + } + } + + } + + function JSMin_String($inString, $comments = NULL) { + $this->in = $inString; + $this->out = ''; + $this->inLength = strlen($inString); + $this->inPos = 0; + $this->isString = true; if ($comments !== NULL) { foreach ($comments as $comm) { - $this -> out -> fwrite('// '.$comm."\n"); + $this->out .= '// '.str_replace("\n", " ", $comm)."\n"; } - } + } + } +} + +// +// OTHER FUNCTIONS +// + +/** +* Displays inline help for the application. +*/ + +function printHelp() { + + // All the inline help + + echo "\n"; + echo "Usage : JSMin.php [inputFile] [outputFile] [[-c] comm1 comm2 ...]\n"; + echo " JSMin.php [-v|-h]\n"; + echo "\n"; + echo "Minify JavaScript code using JSMin, the JavaScript Minifier.\n"; + echo "\n"; + echo "JSMin is a filter which removes comments and unnecessary whitespace\n"; + echo "from a script read in the inputFile (stdin by default), as well as\n"; + echo "omitting or modifying some characters, before writing the results to\n"; + echo "the outputFile (stdout by default).\n"; + echo "It does not change the behaviour of the program that is minifies.\n"; + echo "The result may be harder to debug. It will definitely be harder to\n"; + echo "read. It typically reduces filesize by half, resulting in faster\n"; + echo "downloads. It also encourages a more expressive programming style\n"; + echo "because it eliminates the download cost of clean, literate self-\n"; + echo "documentation.\n"; + echo "\n"; + echo "The '-' character can be used to explicitely specify a standard\n"; + echo "stream for input or output.\n"; + echo "\n"; + echo "With the optional -c (--comm) option, all following parameters will\n"; + echo "be listed at the beginning of the output as comments. This is a\n"; + echo "convenient way of replacing copyright messages and other info. The\n"; + echo "option is unnecessary if an input and output file are specified :\n"; + echo "following parameters will then automatically be treated thus.\n"; + echo "\n"; + echo "Options :\n"; + echo "\n"; + echo " -c, --comm Present following parameters as initial comments.\n"; + echo " -h, --help Display this information.\n"; + echo " -v, --version Display short version information.\n"; + echo "\n"; + echo "The JavaScript Minifier is copyright (c) 2002 by Douglas Crockford\n"; + echo "and available online at http://javascript.crockford.com/jsmin.html.\n"; + echo "This PHP translation is by David Holmes of CFD Labs, France, 2006.\n"; + echo "\n"; +} + +/** +* Displays version information for the application. +*/ + +function printVersion() { + + // Minimum info + + echo "JSMin, the JavaScript Minifier, copyright (c) 2002 by Douglas Crockford.\n"; + echo "PHP translation version ".JSMIN_VERSION." by David Holmes, CFD Labs.\n"; +} + +// +// ENTRY POINT +// + +// Allow user to include this file without having it run atomatically, ie. as if it was a lib +if (!defined('JSMIN_AS_LIB')) { + +define('EXIT_SUCCESS', 0); +define('EXIT_FAILURE', 1); + +// Examine command-line parameters +// First shift off the first parameter, the executable's name + +if (!isset($argv)) { + die("Please run this utility from a command line, or set php.ini setting 'register_argc_argv' to true.\nTo use this file in your own code, define 'JSMIN_AS_LIB' before inclusion."); +} + +array_shift($argv); + +$inFileName = NULL; +$outFileName = NULL; + +$haveCommentParams = FALSE; +$comments = array(); + +foreach ($argv as $arg) { + + // Bypass the rest if we are now considering initial comments + + if ($haveCommentParams) { + + $comments[] = $arg; + continue; + } + + // else + // Look for an option (length > 1 because of '-' for indicating stdin or + // stdout) + + if ($arg[0] == '-' && strlen($arg) > 1) { + + switch ($arg) { + + case '-c' : case '--comm' : + + // Following parameters will be initial comments + + $haveCommentParams = TRUE; + + break; + case '-h' : case '--help' : + + // Display inline help and exit normally + + printHelp(); + exit(EXIT_SUCCESS); + + case '-v' : case '--version' : + + // Display short version information and exit normally + + printVersion(); + exit(EXIT_SUCCESS); + + default : + + // Reject any other (unknown) option + + echo "\n"; + echo "ERROR : unknown option \"$arg\", sorry.\n"; + + printHelp(); + exit(EXIT_FAILURE); + } + + continue; + } + + // else + // At this point, parameter is neither to be considered as an initial + // comment, nor is it an option. It is an input or output file. + + if ($inFileName === NULL) { + + // No input file yet, this is it + + $inFileName = $arg; } + else if ($outFileName === NULL) { + + // An input file but no output file yet, this is it + + $outFileName = $arg; + } + else { + + // Already have input and output file, this is a first initial comment + + $haveCommentParams = TRUE; + $comments[] = $arg; + } +} + +if ($inFileName === NULL) $inFileName = '-'; +if ($outFileName === NULL) $outFileName = '-'; + +// Prepare and run the JSMin application +// If pathnames are not provided or '-', standard input/output streams are used + +$jsMin = new JSMin($inFileName, $outFileName, $comments); +$jsMin->minify(); + } ?> \ No newline at end of file -- cgit v1.2.3