|
|
|
@ -7,14 +7,14 @@ |
|
|
|
* </code> |
|
|
|
* |
|
|
|
* This is a modified port of jsmin.c. Improvements: |
|
|
|
* |
|
|
|
* |
|
|
|
* Does not choke on some regexp literals containing quote characters. E.g. /'/ |
|
|
|
* |
|
|
|
* Spaces are preserved after some add/sub operators, so they are not mistakenly |
|
|
|
* |
|
|
|
* Spaces are preserved after some add/sub operators, so they are not mistakenly |
|
|
|
* converted to post-inc/dec. E.g. a + ++b -> a+ ++b |
|
|
|
* |
|
|
|
* Preserves multi-line comments that begin with /*! |
|
|
|
* |
|
|
|
* |
|
|
|
* PHP 5 or higher is required. |
|
|
|
* |
|
|
|
* Permission is hereby granted to use this version of the library under the |
|
|
|
@ -69,6 +69,7 @@ class JSMin { |
|
|
|
protected $lookAhead = null; |
|
|
|
protected $output = ''; |
|
|
|
protected $lastByteOut = ''; |
|
|
|
protected $keptComment = ''; |
|
|
|
|
|
|
|
/** |
|
|
|
* Minify Javascript. |
|
|
|
@ -116,8 +117,8 @@ class JSMin { |
|
|
|
// determine next command |
|
|
|
$command = self::ACTION_KEEP_A; // default |
|
|
|
if ($this->a === ' ') { |
|
|
|
if (($this->lastByteOut === '+' || $this->lastByteOut === '-') |
|
|
|
&& ($this->b === $this->lastByteOut)) { |
|
|
|
if (($this->lastByteOut === '+' || $this->lastByteOut === '-') |
|
|
|
&& ($this->b === $this->lastByteOut)) { |
|
|
|
// Don't delete this space. If we do, the addition/subtraction |
|
|
|
// could be parsed as a post-increment |
|
|
|
} elseif (! $this->isAlphaNum($this->b)) { |
|
|
|
@ -126,16 +127,17 @@ class JSMin { |
|
|
|
} elseif ($this->a === "\n") { |
|
|
|
if ($this->b === ' ') { |
|
|
|
$command = self::ACTION_DELETE_A_B; |
|
|
|
// in case of mbstring.func_overload & 2, must check for null b, |
|
|
|
// otherwise mb_strpos will give WARNING |
|
|
|
|
|
|
|
// in case of mbstring.func_overload & 2, must check for null b, |
|
|
|
// otherwise mb_strpos will give WARNING |
|
|
|
} elseif ($this->b === null |
|
|
|
|| (false === strpos('{[(+-', $this->b) |
|
|
|
|| (false === strpos('{[(+-!~', $this->b) |
|
|
|
&& ! $this->isAlphaNum($this->b))) { |
|
|
|
$command = self::ACTION_DELETE_A; |
|
|
|
} |
|
|
|
} elseif (! $this->isAlphaNum($this->a)) { |
|
|
|
if ($this->b === ' ' |
|
|
|
|| ($this->b === "\n" |
|
|
|
|| ($this->b === "\n" |
|
|
|
&& (false === strpos('}])+-"\'', $this->a)))) { |
|
|
|
$command = self::ACTION_DELETE_A_B; |
|
|
|
} |
|
|
|
@ -160,7 +162,8 @@ class JSMin { |
|
|
|
*/ |
|
|
|
protected function action($command) |
|
|
|
{ |
|
|
|
if ($command === self::ACTION_DELETE_A_B |
|
|
|
// make sure we don't compress "a + ++b" to "a+++b", etc. |
|
|
|
if ($command === self::ACTION_DELETE_A_B |
|
|
|
&& $this->b === ' ' |
|
|
|
&& ($this->a === '+' || $this->a === '-')) { |
|
|
|
// Note: we're at an addition/substraction operator; the inputIndex |
|
|
|
@ -170,58 +173,88 @@ class JSMin { |
|
|
|
$command = self::ACTION_KEEP_A; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
switch ($command) { |
|
|
|
case self::ACTION_KEEP_A: |
|
|
|
case self::ACTION_KEEP_A: // 1 |
|
|
|
$this->output .= $this->a; |
|
|
|
|
|
|
|
if ($this->keptComment) { |
|
|
|
$this->output = rtrim($this->output, "\n"); |
|
|
|
$this->output .= $this->keptComment; |
|
|
|
$this->keptComment = ''; |
|
|
|
} |
|
|
|
|
|
|
|
$this->lastByteOut = $this->a; |
|
|
|
|
|
|
|
// fallthrough |
|
|
|
case self::ACTION_DELETE_A: |
|
|
|
|
|
|
|
// fallthrough intentional |
|
|
|
case self::ACTION_DELETE_A: // 2 |
|
|
|
$this->a = $this->b; |
|
|
|
if ($this->a === "'" || $this->a === '"') { // string literal |
|
|
|
$str = $this->a; // in case needed for exception |
|
|
|
while (true) { |
|
|
|
for(;;) { |
|
|
|
$this->output .= $this->a; |
|
|
|
$this->lastByteOut = $this->a; |
|
|
|
|
|
|
|
$this->a = $this->get(); |
|
|
|
|
|
|
|
$this->a = $this->get(); |
|
|
|
if ($this->a === $this->b) { // end quote |
|
|
|
break; |
|
|
|
} |
|
|
|
if (ord($this->a) <= self::ORD_LF) { |
|
|
|
if ($this->isEOF($this->a)) { |
|
|
|
$byte = $this->inputIndex - 1; |
|
|
|
throw new JSMin_UnterminatedStringException( |
|
|
|
"JSMin: Unterminated String at byte " |
|
|
|
. $this->inputIndex . ": {$str}"); |
|
|
|
"JSMin: Unterminated String at byte {$byte}: {$str}"); |
|
|
|
} |
|
|
|
$str .= $this->a; |
|
|
|
if ($this->a === '\\') { |
|
|
|
$this->output .= $this->a; |
|
|
|
$this->lastByteOut = $this->a; |
|
|
|
|
|
|
|
|
|
|
|
$this->a = $this->get(); |
|
|
|
$str .= $this->a; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
// fallthrough |
|
|
|
case self::ACTION_DELETE_A_B: |
|
|
|
|
|
|
|
// fallthrough intentional |
|
|
|
case self::ACTION_DELETE_A_B: // 3 |
|
|
|
$this->b = $this->next(); |
|
|
|
if ($this->b === '/' && $this->isRegexpLiteral()) { // RegExp literal |
|
|
|
if ($this->b === '/' && $this->isRegexpLiteral()) { |
|
|
|
$this->output .= $this->a . $this->b; |
|
|
|
$pattern = '/'; // in case needed for exception |
|
|
|
while (true) { |
|
|
|
$pattern = '/'; // keep entire pattern in case we need to report it in the exception |
|
|
|
for(;;) { |
|
|
|
$this->a = $this->get(); |
|
|
|
$pattern .= $this->a; |
|
|
|
if ($this->a === '[') { |
|
|
|
for(;;) { |
|
|
|
$this->output .= $this->a; |
|
|
|
$this->a = $this->get(); |
|
|
|
$pattern .= $this->a; |
|
|
|
if ($this->a === ']') { |
|
|
|
break; |
|
|
|
} |
|
|
|
if ($this->a === '\\') { |
|
|
|
$this->output .= $this->a; |
|
|
|
$this->a = $this->get(); |
|
|
|
$pattern .= $this->a; |
|
|
|
} |
|
|
|
if ($this->isEOF($this->a)) { |
|
|
|
throw new JSMin_UnterminatedRegExpException( |
|
|
|
"JSMin: Unterminated set in RegExp at byte " |
|
|
|
. $this->inputIndex .": {$pattern}"); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
if ($this->a === '/') { // end pattern |
|
|
|
break; // while (true) |
|
|
|
} elseif ($this->a === '\\') { |
|
|
|
$this->output .= $this->a; |
|
|
|
$this->a = $this->get(); |
|
|
|
$pattern .= $this->a; |
|
|
|
} elseif (ord($this->a) <= self::ORD_LF) { |
|
|
|
$this->a = $this->get(); |
|
|
|
$pattern .= $this->a; |
|
|
|
} elseif ($this->isEOF($this->a)) { |
|
|
|
$byte = $this->inputIndex - 1; |
|
|
|
throw new JSMin_UnterminatedRegExpException( |
|
|
|
"JSMin: Unterminated RegExp at byte " |
|
|
|
. $this->inputIndex .": {$pattern}"); |
|
|
|
"JSMin: Unterminated RegExp at byte {$byte}: {$pattern}"); |
|
|
|
} |
|
|
|
$this->output .= $this->a; |
|
|
|
$this->lastByteOut = $this->a; |
|
|
|
@ -237,31 +270,43 @@ class JSMin { |
|
|
|
*/ |
|
|
|
protected function isRegexpLiteral() |
|
|
|
{ |
|
|
|
if (false !== strpos("\n{;(,=:[!&|?", $this->a)) { // we aren't dividing |
|
|
|
if (false !== strpos("(,=:[!&|?+-~*{;", $this->a)) { |
|
|
|
// we obviously aren't dividing |
|
|
|
return true; |
|
|
|
} |
|
|
|
if (' ' === $this->a) { |
|
|
|
$length = strlen($this->output); |
|
|
|
if ($length < 2) { // weird edge case |
|
|
|
return true; |
|
|
|
|
|
|
|
// we have to check for a preceding keyword, and we don't need to pattern |
|
|
|
// match over the whole output. |
|
|
|
$recentOutput = substr($this->output, -10); |
|
|
|
|
|
|
|
// check if return/typeof directly precede a pattern without a space |
|
|
|
foreach (array('return', 'typeof') as $keyword) { |
|
|
|
if ($this->a !== substr($keyword, -1)) { |
|
|
|
// certainly wasn't keyword |
|
|
|
continue; |
|
|
|
} |
|
|
|
// you can't divide a keyword |
|
|
|
if (preg_match('/(?:case|else|in|return|typeof)$/', $this->output, $m)) { |
|
|
|
if ($this->output === $m[0]) { // odd but could happen |
|
|
|
return true; |
|
|
|
} |
|
|
|
// make sure it's a keyword, not end of an identifier |
|
|
|
$charBeforeKeyword = substr($this->output, $length - strlen($m[0]) - 1, 1); |
|
|
|
if (! $this->isAlphaNum($charBeforeKeyword)) { |
|
|
|
if (preg_match("~(^|[\\s\\S])" . substr($keyword, 0, -1) . "$~", $recentOutput, $m)) { |
|
|
|
if ($m[1] === '' || !$this->isAlphaNum($m[1])) { |
|
|
|
return true; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
// check all keywords |
|
|
|
if ($this->a === ' ' || $this->a === "\n") { |
|
|
|
if (preg_match('~(^|[\\s\\S])(?:case|else|in|return|typeof)$~', $recentOutput, $m)) { |
|
|
|
if ($m[1] === '' || !$this->isAlphaNum($m[1])) { |
|
|
|
return true; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return false; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get next char. Convert ctrl char to space. |
|
|
|
* Return the next character from stdin. Watch out for lookahead. If the character is a control character, |
|
|
|
* translate it to a space or linefeed. |
|
|
|
* |
|
|
|
* @return string |
|
|
|
*/ |
|
|
|
@ -270,24 +315,36 @@ class JSMin { |
|
|
|
$c = $this->lookAhead; |
|
|
|
$this->lookAhead = null; |
|
|
|
if ($c === null) { |
|
|
|
// getc(stdin) |
|
|
|
if ($this->inputIndex < $this->inputLength) { |
|
|
|
$c = $this->input[$this->inputIndex]; |
|
|
|
$this->inputIndex += 1; |
|
|
|
} else { |
|
|
|
return null; |
|
|
|
$c = null; |
|
|
|
} |
|
|
|
} |
|
|
|
if ($c === "\r" || $c === "\n") { |
|
|
|
return "\n"; |
|
|
|
if (ord($c) >= self::ORD_SPACE || $c === "\n" || $c === null) { |
|
|
|
return $c; |
|
|
|
} |
|
|
|
if (ord($c) < self::ORD_SPACE) { // control char |
|
|
|
return ' '; |
|
|
|
if ($c === "\r") { |
|
|
|
return "\n"; |
|
|
|
} |
|
|
|
return $c; |
|
|
|
return ' '; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Does $a indicate end of input? |
|
|
|
* |
|
|
|
* @param string $a |
|
|
|
* @return bool |
|
|
|
*/ |
|
|
|
protected function isEOF($a) |
|
|
|
{ |
|
|
|
return ord($a) <= self::ORD_LF; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get next char. If is ctrl character, translate to a space or newline. |
|
|
|
* Get next char (without getting it). If is ctrl character, translate to a space or newline. |
|
|
|
* |
|
|
|
* @return string |
|
|
|
*/ |
|
|
|
@ -298,7 +355,7 @@ class JSMin { |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Is $c a letter, digit, underscore, dollar sign, escape, or non-ASCII? |
|
|
|
* Return true if the character is a letter, digit, underscore, dollar sign, or non-ASCII character. |
|
|
|
* |
|
|
|
* @param string $c |
|
|
|
* |
|
|
|
@ -306,77 +363,84 @@ class JSMin { |
|
|
|
*/ |
|
|
|
protected function isAlphaNum($c) |
|
|
|
{ |
|
|
|
return (preg_match('/^[0-9a-zA-Z_\\$\\\\]$/', $c) || ord($c) > 126); |
|
|
|
return (preg_match('/^[a-z0-9A-Z_\\$\\\\]$/', $c) || ord($c) > 126); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* @return string |
|
|
|
* Consume a single line comment from input (possibly retaining it) |
|
|
|
*/ |
|
|
|
protected function singleLineComment() |
|
|
|
protected function consumeSingleLineComment() |
|
|
|
{ |
|
|
|
$comment = ''; |
|
|
|
while (true) { |
|
|
|
$get = $this->get(); |
|
|
|
$comment .= $get; |
|
|
|
if (ord($get) <= self::ORD_LF) { // EOL reached |
|
|
|
if (ord($get) <= self::ORD_LF) { // end of line reached |
|
|
|
// if IE conditional comment |
|
|
|
if (preg_match('/^\\/@(?:cc_on|if|elif|else|end)\\b/', $comment)) { |
|
|
|
return "/{$comment}"; |
|
|
|
$this->keptComment .= "/{$comment}"; |
|
|
|
} |
|
|
|
return $get; |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* @return string |
|
|
|
* Consume a multiple line comment from input (possibly retaining it) |
|
|
|
* |
|
|
|
* @throws JSMin_UnterminatedCommentException |
|
|
|
*/ |
|
|
|
protected function multipleLineComment() |
|
|
|
protected function consumeMultipleLineComment() |
|
|
|
{ |
|
|
|
$this->get(); |
|
|
|
$comment = ''; |
|
|
|
while (true) { |
|
|
|
for(;;) { |
|
|
|
$get = $this->get(); |
|
|
|
if ($get === '*') { |
|
|
|
if ($this->peek() === '/') { // end of comment reached |
|
|
|
$this->get(); |
|
|
|
// if comment preserved by YUI Compressor |
|
|
|
if (0 === strpos($comment, '!')) { |
|
|
|
return "\n/*!" . substr($comment, 1) . "*/\n"; |
|
|
|
} |
|
|
|
// if IE conditional comment |
|
|
|
if (preg_match('/^@(?:cc_on|if|elif|else|end)\\b/', $comment)) { |
|
|
|
return "/*{$comment}*/"; |
|
|
|
// preserved by YUI Compressor |
|
|
|
if (!$this->keptComment) { |
|
|
|
// don't prepend a newline if two comments right after one another |
|
|
|
$this->keptComment = "\n"; |
|
|
|
} |
|
|
|
$this->keptComment .= "/*!" . substr($comment, 1) . "*/\n"; |
|
|
|
} else if (preg_match('/^@(?:cc_on|if|elif|else|end)\\b/', $comment)) { |
|
|
|
// IE conditional |
|
|
|
$this->keptComment .= "/*{$comment}*/"; |
|
|
|
} |
|
|
|
return ' '; |
|
|
|
return; |
|
|
|
} |
|
|
|
} elseif ($get === null) { |
|
|
|
throw new JSMin_UnterminatedCommentException( |
|
|
|
"JSMin: Unterminated comment at byte " |
|
|
|
. $this->inputIndex . ": /*{$comment}"); |
|
|
|
"JSMin: Unterminated comment at byte {$this->inputIndex}: /*{$comment}"); |
|
|
|
} |
|
|
|
$comment .= $get; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get the next character, skipping over comments. |
|
|
|
* Some comments may be preserved. |
|
|
|
* Get the next character, skipping over comments. Some comments may be preserved. |
|
|
|
* |
|
|
|
* @return string |
|
|
|
*/ |
|
|
|
protected function next() |
|
|
|
{ |
|
|
|
$get = $this->get(); |
|
|
|
if ($get !== '/') { |
|
|
|
return $get; |
|
|
|
} |
|
|
|
switch ($this->peek()) { |
|
|
|
case '/': return $this->singleLineComment(); |
|
|
|
case '*': return $this->multipleLineComment(); |
|
|
|
default: return $get; |
|
|
|
if ($get === '/') { |
|
|
|
switch ($this->peek()) { |
|
|
|
case '/': |
|
|
|
$this->consumeSingleLineComment(); |
|
|
|
$get = "\n"; |
|
|
|
break; |
|
|
|
case '*': |
|
|
|
$this->consumeMultipleLineComment(); |
|
|
|
$get = ' '; |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
return $get; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
Jano Slota
10 years ago
czaks