bixbite 0.1.0

data/template/src/html/min/lib/JSMin.php

@@ -0,0 +1,314 @@
+<?php
+/**
+ * jsmin.php - PHP implementation of Douglas Crockford's JSMin.
+ *
+ * This is a direct port of jsmin.c to PHP with a few PHP performance tweaks and
+ * modifications to preserve some comments (see below). Also, rather than using
+ * stdin/stdout, JSMin::minify() accepts a string as input and returns another
+ * string as output.
+ * 
+ * Comments containing IE conditional compilation are preserved, as are multi-line
+ * comments that begin with "/*!" (for documentation purposes). In the latter case
+ * newlines are inserted around the comment to enhance readability.
+ *
+ * PHP 5 or higher is required.
+ *
+ * Permission is hereby granted to use this version of the library under the
+ * same terms as jsmin.c, which has the following license:
+ *
+ * --
+ * Copyright (c) 2002 Douglas Crockford  (www.crockford.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * The Software shall be used for Good, not Evil.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * --
+ *
+ * @package JSMin
+ * @author Ryan Grove <ryan@wonko.com> (PHP port)
+ * @author Steve Clay <steve@mrclay.org> (modifications + cleanup)
+ * @author Andrea Giammarchi <http://www.3site.eu> (spaceBeforeRegExp)
+ * @copyright 2002 Douglas Crockford <douglas@crockford.com> (jsmin.c)
+ * @copyright 2008 Ryan Grove <ryan@wonko.com> (PHP port)
+ * @license http://opensource.org/licenses/mit-license.php MIT License
+ * @link http://code.google.com/p/jsmin-php/
+ */
+
+class JSMin {
+    const ORD_LF            = 10;
+    const ORD_SPACE         = 32;
+    const ACTION_KEEP_A     = 1;
+    const ACTION_DELETE_A   = 2;
+    const ACTION_DELETE_A_B = 3;
+    
+    protected $a           = "\n";
+    protected $b           = '';
+    protected $input       = '';
+    protected $inputIndex  = 0;
+    protected $inputLength = 0;
+    protected $lookAhead   = null;
+    protected $output      = '';
+    
+    /**
+     * Minify Javascript
+     *
+     * @param string $js Javascript to be minified
+     * @return string
+     */
+    public static function minify($js)
+    {
+        $jsmin = new JSMin($js);
+        return $jsmin->min();
+    }
+    
+    /**
+     * Setup process
+     */
+    public function __construct($input)
+    {
+        $this->input       = str_replace("\r\n", "\n", $input);
+        $this->inputLength = strlen($this->input);
+    }
+    
+    /**
+     * Perform minification, return result
+     */
+    public function min()
+    {
+        if ($this->output !== '') { // min already run
+            return $this->output;
+        }
+        $this->action(self::ACTION_DELETE_A_B);
+        
+        while ($this->a !== null) {
+            // determine next command
+            $command = self::ACTION_KEEP_A; // default
+            if ($this->a === ' ') {
+                if (! $this->isAlphaNum($this->b)) {
+                    $command = self::ACTION_DELETE_A;
+                }
+            } elseif ($this->a === "\n") {
+                if ($this->b === ' ') {
+                    $command = self::ACTION_DELETE_A_B;
+                } elseif (false === strpos('{[(+-', $this->b) 
+                          && ! $this->isAlphaNum($this->b)) {
+                    $command = self::ACTION_DELETE_A;
+                }
+            } elseif (! $this->isAlphaNum($this->a)) {
+                if ($this->b === ' '
+                    || ($this->b === "\n" 
+                        && (false === strpos('}])+-"\'', $this->a)))) {
+                    $command = self::ACTION_DELETE_A_B;
+                }
+            }
+            $this->action($command);
+        }
+        $this->output = trim($this->output);
+        return $this->output;
+    }
+    
+    /**
+     * ACTION_KEEP_A = Output A. Copy B to A. Get the next B.
+     * ACTION_DELETE_A = Copy B to A. Get the next B.
+     * ACTION_DELETE_A_B = Get the next B.
+     */
+    protected function action($command)
+    {
+        switch ($command) {
+            case self::ACTION_KEEP_A:
+                $this->output .= $this->a;
+                // fallthrough
+            case self::ACTION_DELETE_A:
+                $this->a = $this->b;
+                if ($this->a === "'" || $this->a === '"') { // string literal
+                    $str = $this->a; // in case needed for exception
+                    while (true) {
+                        $this->output .= $this->a;
+                        $this->a       = $this->get();
+                        if ($this->a === $this->b) { // end quote
+                            break;
+                        }
+                        if (ord($this->a) <= self::ORD_LF) {
+                            throw new JSMin_UnterminatedStringException(
+                                'Unterminated String: ' . var_export($str, true));
+                        }
+                        $str .= $this->a;
+                        if ($this->a === '\\') {
+                            $this->output .= $this->a;
+                            $this->a       = $this->get();
+                            $str .= $this->a;
+                        }
+                    }
+                }
+                // fallthrough
+            case self::ACTION_DELETE_A_B:
+                $this->b = $this->next();
+                if ($this->b === '/' && $this->isRegexpLiteral()) { // RegExp literal
+                    $this->output .= $this->a . $this->b;
+                    $pattern = '/'; // in case needed for exception
+                    while (true) {
+                        $this->a = $this->get();
+                        $pattern .= $this->a;
+                        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) {
+                            throw new JSMin_UnterminatedRegExpException(
+                                'Unterminated RegExp: '. var_export($pattern, true));
+                        }
+                        $this->output .= $this->a;
+                    }
+                    $this->b = $this->next();
+                }
+            // end case ACTION_DELETE_A_B
+        }
+    }
+    
+    protected function isRegexpLiteral()
+    {
+        if (false !== strpos("\n{;(,=:[!&|?", $this->a)) { // we aren't dividing
+            return true;
+        }
+        if (' ' === $this->a) {
+            $length = strlen($this->output);
+            if ($length < 2) { // weird edge case
+                return true;
+            }
+            // 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)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    
+    /**
+     * Get next char. Convert ctrl char to space.
+     */
+    protected function get()
+    {
+        $c = $this->lookAhead;
+        $this->lookAhead = null;
+        if ($c === null) {
+            if ($this->inputIndex < $this->inputLength) {
+                $c = $this->input[$this->inputIndex];
+                $this->inputIndex += 1;
+            } else {
+                return null;
+            }
+        }
+        if ($c === "\r" || $c === "\n") {
+            return "\n";
+        }
+        if (ord($c) < self::ORD_SPACE) { // control char
+            return ' ';
+        }
+        return $c;
+    }
+    
+    /**
+     * Get next char. If is ctrl character, translate to a space or newline.
+     */
+    protected function peek()
+    {
+        $this->lookAhead = $this->get();
+        return $this->lookAhead;
+    }
+    
+    /**
+     * Is $c a letter, digit, underscore, dollar sign, escape, or non-ASCII?
+     */
+    protected function isAlphaNum($c)
+    {
+        return (preg_match('/^[0-9a-zA-Z_\\$\\\\]$/', $c) || ord($c) > 126);
+    }
+    
+    protected function singleLineComment()
+    {
+        $comment = '';
+        while (true) {
+            $get = $this->get();
+            $comment .= $get;
+            if (ord($get) <= self::ORD_LF) { // EOL reached
+                // if IE conditional comment
+                if (preg_match('/^\\/@(?:cc_on|if|elif|else|end)\\b/', $comment)) {
+                    return "/{$comment}";
+                }
+                return $get;
+            }
+        }
+    }
+    
+    protected function multipleLineComment()
+    {
+        $this->get();
+        $comment = '';
+        while (true) {
+            $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}*/";
+                    }
+                    return ' ';
+                }
+            } elseif ($get === null) {
+                throw new JSMin_UnterminatedCommentException('Unterminated Comment: ' . var_export('/*' . $comment, true));
+            }
+            $comment .= $get;
+        }
+    }
+    
+    /**
+     * Get the next character, skipping over comments.
+     * Some comments may be preserved.
+     */
+    protected function next()
+    {
+        $get = $this->get();
+        if ($get !== '/') {
+            return $get;
+        }
+        switch ($this->peek()) {
+            case '/': return $this->singleLineComment();
+            case '*': return $this->multipleLineComment();
+            default: return $get;
+        }
+    }
+}
+
+class JSMin_UnterminatedStringException extends Exception {}
+class JSMin_UnterminatedCommentException extends Exception {}
+class JSMin_UnterminatedRegExpException extends Exception {}

data/template/src/html/min/lib/JSMinPlus.php

@@ -0,0 +1,1872 @@
+<?php
+
+/**
+ * JSMinPlus version 1.1
+ *
+ * Minifies a javascript file using a javascript parser
+ *
+ * This implements a PHP port of Brendan Eich's Narcissus open source javascript engine (in javascript)
+ * References: http://en.wikipedia.org/wiki/Narcissus_(JavaScript_engine)
+ * Narcissus sourcecode: http://mxr.mozilla.org/mozilla/source/js/narcissus/
+ * JSMinPlus weblog: http://crisp.tweakblogs.net/blog/cat/716
+ *
+ * Tino Zijdel <crisp@tweakers.net>
+ *
+ * Usage: $minified = JSMinPlus::minify($script [, $filename])
+ *
+ * Versionlog (see also changelog.txt):
+ * 12-04-2009 - some small bugfixes and performance improvements
+ * 09-04-2009 - initial open sourced version 1.0
+ *
+ * Latest version of this script: http://files.tweakers.net/jsminplus/jsminplus.zip
+ *
+ */
+
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the Narcissus JavaScript engine.
+ *
+ * The Initial Developer of the Original Code is
+ * Brendan Eich <brendan@mozilla.org>.
+ * Portions created by the Initial Developer are Copyright (C) 2004
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s): Tino Zijdel <crisp@tweakers.net>
+ * PHP port, modifications and minifier routine are (C) 2009
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+define('TOKEN_END', 1);
+define('TOKEN_NUMBER', 2);
+define('TOKEN_IDENTIFIER', 3);
+define('TOKEN_STRING', 4);
+define('TOKEN_REGEXP', 5);
+define('TOKEN_NEWLINE', 6);
+define('TOKEN_CONDCOMMENT_MULTILINE', 7);
+
+define('JS_SCRIPT', 100);
+define('JS_BLOCK', 101);
+define('JS_LABEL', 102);
+define('JS_FOR_IN', 103);
+define('JS_CALL', 104);
+define('JS_NEW_WITH_ARGS', 105);
+define('JS_INDEX', 106);
+define('JS_ARRAY_INIT', 107);
+define('JS_OBJECT_INIT', 108);
+define('JS_PROPERTY_INIT', 109);
+define('JS_GETTER', 110);
+define('JS_SETTER', 111);
+define('JS_GROUP', 112);
+define('JS_LIST', 113);
+
+define('DECLARED_FORM', 0);
+define('EXPRESSED_FORM', 1);
+define('STATEMENT_FORM', 2);
+
+class JSMinPlus
+{
+	private $parser;
+	private $reserved = array(
+		'break', 'case', 'catch', 'continue', 'default', 'delete', 'do',
+		'else', 'finally', 'for', 'function', 'if', 'in', 'instanceof',
+		'new', 'return', 'switch', 'this', 'throw', 'try', 'typeof', 'var',
+		'void', 'while', 'with',
+		// Words reserved for future use
+		'abstract', 'boolean', 'byte', 'char', 'class', 'const', 'debugger',
+		'double', 'enum', 'export', 'extends', 'final', 'float', 'goto',
+		'implements', 'import', 'int', 'interface', 'long', 'native',
+		'package', 'private', 'protected', 'public', 'short', 'static',
+		'super', 'synchronized', 'throws', 'transient', 'volatile',
+		// These are not reserved, but should be taken into account
+		// in isValidIdentifier (See jslint source code)
+		'arguments', 'eval', 'true', 'false', 'Infinity', 'NaN', 'null', 'undefined'
+	);
+
+	private function __construct()
+	{
+		$this->parser = new JSParser();
+	}
+
+	public static function minify($js, $filename='')
+	{
+		static $instance;
+
+		// this is a singleton
+		if(!$instance)
+			$instance = new JSMinPlus();
+
+		return $instance->min($js, $filename);
+	}
+
+	private function min($js, $filename)
+	{
+		try
+		{
+			$n = $this->parser->parse($js, $filename, 1);
+			return $this->parseTree($n);
+		}
+		catch(Exception $e)
+		{
+			echo $e->getMessage() . "\n";
+		}
+
+		return false;
+	}
+
+	private function parseTree($n, $noBlockGrouping = false)
+	{
+		$s = '';
+
+		switch ($n->type)
+		{
+			case KEYWORD_FUNCTION:
+				$s .= 'function' . ($n->name ? ' ' . $n->name : '') . '(';
+				$params = $n->params;
+				for ($i = 0, $j = count($params); $i < $j; $i++)
+					$s .= ($i ? ',' : '') . $params[$i];
+				$s .= '){' . $this->parseTree($n->body, true) . '}';
+			break;
+
+			case JS_SCRIPT:
+				// we do nothing with funDecls or varDecls
+				$noBlockGrouping = true;
+			// fall through
+			case JS_BLOCK:
+				$childs = $n->treeNodes;
+				for ($c = 0, $i = 0, $j = count($childs); $i < $j; $i++)
+				{
+					$t = $this->parseTree($childs[$i]);
+					if (strlen($t))
+					{
+						if ($c)
+						{
+							if ($childs[$i]->type == KEYWORD_FUNCTION && $childs[$i]->functionForm == DECLARED_FORM)
+								$s .= "\n"; // put declared functions on a new line
+							else
+								$s .= ';';
+						}
+
+						$s .= $t;
+
+						$c++;
+					}
+				}
+
+				if ($c > 1 && !$noBlockGrouping)
+				{
+					$s = '{' . $s . '}';
+				}
+			break;
+
+			case KEYWORD_IF:
+				$s = 'if(' . $this->parseTree($n->condition) . ')';
+				$thenPart = $this->parseTree($n->thenPart);
+				$elsePart = $n->elsePart ? $this->parseTree($n->elsePart) : null;
+
+				// quite a rancid hack to see if we should enclose the thenpart in brackets
+				if ($thenPart[0] != '{')
+				{
+					if (strpos($thenPart, 'if(') !== false)
+						$thenPart = '{' . $thenPart . '}';
+					elseif ($elsePart)
+						$thenPart .= ';';
+				}
+
+				$s .= $thenPart;
+
+				if ($elsePart)
+				{
+					$s .= 'else';
+
+					if ($elsePart[0] != '{')
+						$s .= ' ';
+
+					$s .= $elsePart;
+				}
+			break;
+
+			case KEYWORD_SWITCH:
+				$s = 'switch(' . $this->parseTree($n->discriminant) . '){';
+				$cases = $n->cases;
+				for ($i = 0, $j = count($cases); $i < $j; $i++)
+				{
+					$case = $cases[$i];
+					if ($case->type == KEYWORD_CASE)
+						$s .= 'case' . ($case->caseLabel->type != TOKEN_STRING ? ' ' : '') . $this->parseTree($case->caseLabel) . ':';
+					else
+						$s .= 'default:';
+
+					$statement = $this->parseTree($case->statements);
+					if ($statement)
+						$s .= $statement . ';';
+				}
+				$s = rtrim($s, ';') . '}';
+			break;
+
+			case KEYWORD_FOR:
+				$s = 'for(' . ($n->setup ? $this->parseTree($n->setup) : '')
+					. ';' . ($n->condition ? $this->parseTree($n->condition) : '')
+					. ';' . ($n->update ? $this->parseTree($n->update) : '') . ')'
+					. $this->parseTree($n->body);
+			break;
+
+			case KEYWORD_WHILE:
+				$s = 'while(' . $this->parseTree($n->condition) . ')' . $this->parseTree($n->body);
+			break;
+
+			case JS_FOR_IN:
+				$s = 'for(' . ($n->varDecl ? $this->parseTree($n->varDecl) : $this->parseTree($n->iterator)) . ' in ' . $this->parseTree($n->object) . ')' . $this->parseTree($n->body);
+			break;
+
+			case KEYWORD_DO:
+				$s = 'do{' . $this->parseTree($n->body, true) . '}while(' . $this->parseTree($n->condition) . ')';
+			break;
+
+			case KEYWORD_BREAK:
+			case KEYWORD_CONTINUE:
+				$s = $n->value . ($n->label ? ' ' . $n->label : '');
+			break;
+
+			case KEYWORD_TRY:
+				$s = 'try{' . $this->parseTree($n->tryBlock, true) . '}';
+				$catchClauses = $n->catchClauses;
+				for ($i = 0, $j = count($catchClauses); $i < $j; $i++)
+				{
+					$t = $catchClauses[$i];
+					$s .= 'catch(' . $t->varName . ($t->guard ? ' if ' . $this->parseTree($t->guard) : '') . '){' . $this->parseTree($t->block, true) . '}';
+				}
+				if ($n->finallyBlock)
+					$s .= 'finally{' . $this->parseTree($n->finallyBlock, true) . '}';
+			break;
+
+			case KEYWORD_THROW:
+				$s = 'throw ' . $this->parseTree($n->exception);
+			break;
+
+			case KEYWORD_RETURN:
+				$s = 'return' . ($n->value ? ' ' . $this->parseTree($n->value) : '');
+			break;
+
+			case KEYWORD_WITH:
+				$s = 'with(' . $this->parseTree($n->object) . ')' . $this->parseTree($n->body);
+			break;
+
+			case KEYWORD_VAR:
+			case KEYWORD_CONST:
+				$s = $n->value . ' ';
+				$childs = $n->treeNodes;
+				for ($i = 0, $j = count($childs); $i < $j; $i++)
+				{
+					$t = $childs[$i];
+					$s .= ($i ? ',' : '') . $t->name;
+					$u = $t->initializer;
+					if ($u)
+						$s .= '=' . $this->parseTree($u);
+				}
+			break;
+
+			case KEYWORD_DEBUGGER:
+				throw new Exception('NOT IMPLEMENTED: DEBUGGER');
+			break;
+
+			case TOKEN_CONDCOMMENT_MULTILINE:
+				$s = $n->value . ' ';
+				$childs = $n->treeNodes;
+				for ($i = 0, $j = count($childs); $i < $j; $i++)
+					$s .= $this->parseTree($childs[$i]);
+			break;
+
+			case OP_SEMICOLON:
+				if ($expression = $n->expression)
+					$s = $this->parseTree($expression);
+			break;
+
+			case JS_LABEL:
+				$s = $n->label . ':' . $this->parseTree($n->statement);
+			break;
+
+			case OP_COMMA:
+				$childs = $n->treeNodes;
+				for ($i = 0, $j = count($childs); $i < $j; $i++)
+					$s .= ($i ? ',' : '') . $this->parseTree($childs[$i]);
+			break;
+
+			case OP_ASSIGN:
+				$s = $this->parseTree($n->treeNodes[0]) . $n->value . $this->parseTree($n->treeNodes[1]);
+			break;
+
+			case OP_HOOK:
+				$s = $this->parseTree($n->treeNodes[0]) . '?' . $this->parseTree($n->treeNodes[1]) . ':' . $this->parseTree($n->treeNodes[2]);
+			break;
+
+			case OP_OR: case OP_AND:
+			case OP_BITWISE_OR: case OP_BITWISE_XOR: case OP_BITWISE_AND:
+			case OP_EQ: case OP_NE: case OP_STRICT_EQ: case OP_STRICT_NE:
+			case OP_LT: case OP_LE: case OP_GE: case OP_GT:
+			case OP_LSH: case OP_RSH: case OP_URSH:
+			case OP_MUL: case OP_DIV: case OP_MOD:
+				$s = $this->parseTree($n->treeNodes[0]) . $n->type . $this->parseTree($n->treeNodes[1]);
+			break;
+
+			case OP_PLUS:
+			case OP_MINUS:
+				$s = $this->parseTree($n->treeNodes[0]) . $n->type;
+				$nextTokenType = $n->treeNodes[1]->type;
+				if (	$nextTokenType == OP_PLUS || $nextTokenType == OP_MINUS ||
+					$nextTokenType == OP_INCREMENT || $nextTokenType == OP_DECREMENT ||
+					$nextTokenType == OP_UNARY_PLUS || $nextTokenType == OP_UNARY_MINUS
+				)
+					$s .= ' ';
+				$s .= $this->parseTree($n->treeNodes[1]);
+			break;
+
+			case KEYWORD_IN:
+				$s = $this->parseTree($n->treeNodes[0]) . ' in ' . $this->parseTree($n->treeNodes[1]);
+			break;
+
+			case KEYWORD_INSTANCEOF:
+				$s = $this->parseTree($n->treeNodes[0]) . ' instanceof ' . $this->parseTree($n->treeNodes[1]);
+			break;
+
+			case KEYWORD_DELETE:
+				$s = 'delete ' . $this->parseTree($n->treeNodes[0]);
+			break;
+
+			case KEYWORD_VOID:
+				$s = 'void(' . $this->parseTree($n->treeNodes[0]) . ')';
+			break;
+
+			case KEYWORD_TYPEOF:
+				$s = 'typeof ' . $this->parseTree($n->treeNodes[0]);
+			break;
+
+			case OP_NOT:
+			case OP_BITWISE_NOT:
+			case OP_UNARY_PLUS:
+			case OP_UNARY_MINUS:
+				$s = $n->value . $this->parseTree($n->treeNodes[0]);
+			break;
+
+			case OP_INCREMENT:
+			case OP_DECREMENT:
+				if ($n->postfix)
+					$s = $this->parseTree($n->treeNodes[0]) . $n->value;
+				else
+					$s = $n->value . $this->parseTree($n->treeNodes[0]);
+			break;
+
+			case OP_DOT:
+				$s = $this->parseTree($n->treeNodes[0]) . '.' . $this->parseTree($n->treeNodes[1]);
+			break;
+
+			case JS_INDEX:
+				$s = $this->parseTree($n->treeNodes[0]);
+				// See if we can replace named index with a dot saving 3 bytes
+				if (	$n->treeNodes[0]->type == TOKEN_IDENTIFIER &&
+					$n->treeNodes[1]->type == TOKEN_STRING &&
+					$this->isValidIdentifier(substr($n->treeNodes[1]->value, 1, -1))
+				)
+					$s .= '.' . substr($n->treeNodes[1]->value, 1, -1);
+				else
+					$s .= '[' . $this->parseTree($n->treeNodes[1]) . ']';
+			break;
+
+			case JS_LIST:
+				$childs = $n->treeNodes;
+				for ($i = 0, $j = count($childs); $i < $j; $i++)
+					$s .= ($i ? ',' : '') . $this->parseTree($childs[$i]);
+			break;
+
+			case JS_CALL:
+				$s = $this->parseTree($n->treeNodes[0]) . '(' . $this->parseTree($n->treeNodes[1]) . ')';
+			break;
+
+			case KEYWORD_NEW:
+			case JS_NEW_WITH_ARGS:
+				$s = 'new ' . $this->parseTree($n->treeNodes[0]) . '(' . ($n->type == JS_NEW_WITH_ARGS ? $this->parseTree($n->treeNodes[1]) : '') . ')';
+			break;
+
+			case JS_ARRAY_INIT:
+				$s = '[';
+				$childs = $n->treeNodes;
+				for ($i = 0, $j = count($childs); $i < $j; $i++)
+				{
+					$s .= ($i ? ',' : '') . $this->parseTree($childs[$i]);
+				}
+				$s .= ']';
+			break;
+
+			case JS_OBJECT_INIT:
+				$s = '{';
+				$childs = $n->treeNodes;
+				for ($i = 0, $j = count($childs); $i < $j; $i++)
+				{
+					$t = $childs[$i];
+					if ($i)
+						$s .= ',';
+					if ($t->type == JS_PROPERTY_INIT)
+					{
+						// Ditch the quotes when the index is a valid identifier
+						if (	$t->treeNodes[0]->type == TOKEN_STRING &&
+							$this->isValidIdentifier(substr($t->treeNodes[0]->value, 1, -1))
+						)
+							$s .= substr($t->treeNodes[0]->value, 1, -1);
+						else
+							$s .= $t->treeNodes[0]->value;
+
+						$s .= ':' . $this->parseTree($t->treeNodes[1]);
+					}
+					else
+					{
+						$s .= $t->type == JS_GETTER ? 'get' : 'set';
+						$s .= ' ' . $t->name . '(';
+						$params = $t->params;
+						for ($i = 0, $j = count($params); $i < $j; $i++)
+							$s .= ($i ? ',' : '') . $params[$i];
+						$s .= '){' . $this->parseTree($t->body, true) . '}';
+					}
+				}
+				$s .= '}';
+			break;
+
+			case KEYWORD_NULL: case KEYWORD_THIS: case KEYWORD_TRUE: case KEYWORD_FALSE:
+			case TOKEN_IDENTIFIER: case TOKEN_NUMBER: case TOKEN_STRING: case TOKEN_REGEXP:
+				$s = $n->value;
+			break;
+
+			case JS_GROUP:
+				$s = '(' . $this->parseTree($n->treeNodes[0]) . ')';
+			break;
+
+			default:
+				throw new Exception('UNKNOWN TOKEN TYPE: ' . $n->type);
+		}
+
+		return $s;
+	}
+
+	private function isValidIdentifier($string)
+	{
+		return preg_match('/^[a-zA-Z_][a-zA-Z0-9_]*$/', $string) && !in_array($string, $this->reserved);
+	}
+}
+
+class JSParser
+{
+	private $t;
+
+	private $opPrecedence = array(
+		';' => 0,
+		',' => 1,
+		'=' => 2, '?' => 2, ':' => 2,
+		// The above all have to have the same precedence, see bug 330975.
+		'||' => 4,
+		'&&' => 5,
+		'|' => 6,
+		'^' => 7,
+		'&' => 8,
+		'==' => 9, '!=' => 9, '===' => 9, '!==' => 9,
+		'<' => 10, '<=' => 10, '>=' => 10, '>' => 10, 'in' => 10, 'instanceof' => 10,
+		'<<' => 11, '>>' => 11, '>>>' => 11,
+		'+' => 12, '-' => 12,
+		'*' => 13, '/' => 13, '%' => 13,
+		'delete' => 14, 'void' => 14, 'typeof' => 14,
+		'!' => 14, '~' => 14, 'U+' => 14, 'U-' => 14,
+		'++' => 15, '--' => 15,
+		'new' => 16,
+		'.' => 17,
+		JS_NEW_WITH_ARGS => 0, JS_INDEX => 0, JS_CALL => 0,
+		JS_ARRAY_INIT => 0, JS_OBJECT_INIT => 0, JS_GROUP => 0
+	);
+
+	private $opArity = array(
+		',' => -2,
+		'=' => 2,
+		'?' => 3,
+		'||' => 2,
+		'&&' => 2,
+		'|' => 2,
+		'^' => 2,
+		'&' => 2,
+		'==' => 2, '!=' => 2, '===' => 2, '!==' => 2,
+		'<' => 2, '<=' => 2, '>=' => 2, '>' => 2, 'in' => 2, 'instanceof' => 2,
+		'<<' => 2, '>>' => 2, '>>>' => 2,
+		'+' => 2, '-' => 2,
+		'*' => 2, '/' => 2, '%' => 2,
+		'delete' => 1, 'void' => 1, 'typeof' => 1,
+		'!' => 1, '~' => 1, 'U+' => 1, 'U-' => 1,
+		'++' => 1, '--' => 1,
+		'new' => 1,
+		'.' => 2,
+		JS_NEW_WITH_ARGS => 2, JS_INDEX => 2, JS_CALL => 2,
+		JS_ARRAY_INIT => 1, JS_OBJECT_INIT => 1, JS_GROUP => 1,
+		TOKEN_CONDCOMMENT_MULTILINE => 1
+	);
+
+	public function __construct()
+	{
+		$this->t = new JSTokenizer();
+	}
+
+	public function parse($s, $f, $l)
+	{
+		// initialize tokenizer
+		$this->t->init($s, $f, $l);
+
+		$x = new JSCompilerContext(false);
+		$n = $this->Script($x);
+		if (!$this->t->isDone())
+			throw $this->t->newSyntaxError('Syntax error');
+
+		return $n;
+	}
+
+	private function Script($x)
+	{
+		$n = $this->Statements($x);
+		$n->type = JS_SCRIPT;
+		$n->funDecls = $x->funDecls;
+		$n->varDecls = $x->varDecls;
+
+		return $n;
+	}
+
+	private function Statements($x)
+	{
+		$n = new JSNode($this->t, JS_BLOCK);
+		array_push($x->stmtStack, $n);
+
+		while (!$this->t->isDone() && $this->t->peek() != OP_RIGHT_CURLY)
+			$n->addNode($this->Statement($x));
+
+		array_pop($x->stmtStack);
+
+		return $n;
+	}
+
+	private function Block($x)
+	{
+		$this->t->mustMatch(OP_LEFT_CURLY);
+		$n = $this->Statements($x);
+		$this->t->mustMatch(OP_RIGHT_CURLY);
+
+		return $n;
+	}
+
+	private function Statement($x)
+	{
+		$tt = $this->t->get();
+		$n2 = null;
+
+		// Cases for statements ending in a right curly return early, avoiding the
+		// common semicolon insertion magic after this switch.
+		switch ($tt)
+		{
+			case KEYWORD_FUNCTION:
+				return $this->FunctionDefinition(
+					$x,
+					true,
+					count($x->stmtStack) > 1 ? STATEMENT_FORM : DECLARED_FORM
+				);
+			break;
+
+			case OP_LEFT_CURLY:
+				$n = $this->Statements($x);
+				$this->t->mustMatch(OP_RIGHT_CURLY);
+			return $n;
+
+			case KEYWORD_IF:
+				$n = new JSNode($this->t);
+				$n->condition = $this->ParenExpression($x);
+				array_push($x->stmtStack, $n);
+				$n->thenPart = $this->Statement($x);
+				$n->elsePart = $this->t->match(KEYWORD_ELSE) ? $this->Statement($x) : null;
+				array_pop($x->stmtStack);
+			return $n;
+
+			case KEYWORD_SWITCH:
+				$n = new JSNode($this->t);
+				$this->t->mustMatch(OP_LEFT_PAREN);
+				$n->discriminant = $this->Expression($x);
+				$this->t->mustMatch(OP_RIGHT_PAREN);
+				$n->cases = array();
+				$n->defaultIndex = -1;
+
+				array_push($x->stmtStack, $n);
+
+				$this->t->mustMatch(OP_LEFT_CURLY);
+
+				while (($tt = $this->t->get()) != OP_RIGHT_CURLY)
+				{
+					switch ($tt)
+					{
+						case KEYWORD_DEFAULT:
+							if ($n->defaultIndex >= 0)
+								throw $this->t->newSyntaxError('More than one switch default');
+							// FALL THROUGH
+						case KEYWORD_CASE:
+							$n2 = new JSNode($this->t);
+							if ($tt == KEYWORD_DEFAULT)
+								$n->defaultIndex = count($n->cases);
+							else
+								$n2->caseLabel = $this->Expression($x, OP_COLON);
+								break;
+						default:
+							throw $this->t->newSyntaxError('Invalid switch case');
+					}
+
+					$this->t->mustMatch(OP_COLON);
+					$n2->statements = new JSNode($this->t, JS_BLOCK);
+					while (($tt = $this->t->peek()) != KEYWORD_CASE && $tt != KEYWORD_DEFAULT && $tt != OP_RIGHT_CURLY)
+						$n2->statements->addNode($this->Statement($x));
+
+					array_push($n->cases, $n2);
+				}
+
+				array_pop($x->stmtStack);
+			return $n;
+
+			case KEYWORD_FOR:
+				$n = new JSNode($this->t);
+				$n->isLoop = true;
+				$this->t->mustMatch(OP_LEFT_PAREN);
+
+				if (($tt = $this->t->peek()) != OP_SEMICOLON)
+				{
+					$x->inForLoopInit = true;
+					if ($tt == KEYWORD_VAR || $tt == KEYWORD_CONST)
+					{
+						$this->t->get();
+						$n2 = $this->Variables($x);
+					}
+					else
+					{
+						$n2 = $this->Expression($x);
+					}
+					$x->inForLoopInit = false;
+				}
+
+				if ($n2 && $this->t->match(KEYWORD_IN))
+				{
+					$n->type = JS_FOR_IN;
+					if ($n2->type == KEYWORD_VAR)
+					{
+						if (count($n2->treeNodes) != 1)
+						{
+							throw $this->t->SyntaxError(
+								'Invalid for..in left-hand side',
+								$this->t->filename,
+								$n2->lineno
+							);
+						}
+
+						// NB: n2[0].type == IDENTIFIER and n2[0].value == n2[0].name.
+						$n->iterator = $n2->treeNodes[0];
+						$n->varDecl = $n2;
+					}
+					else
+					{
+						$n->iterator = $n2;
+						$n->varDecl = null;
+					}
+
+					$n->object = $this->Expression($x);
+				}
+				else
+				{
+					$n->setup = $n2 ? $n2 : null;
+					$this->t->mustMatch(OP_SEMICOLON);
+					$n->condition = $this->t->peek() == OP_SEMICOLON ? null : $this->Expression($x);
+					$this->t->mustMatch(OP_SEMICOLON);
+					$n->update = $this->t->peek() == OP_RIGHT_PAREN ? null : $this->Expression($x);
+				}
+
+				$this->t->mustMatch(OP_RIGHT_PAREN);
+				$n->body = $this->nest($x, $n);
+			return $n;
+
+			case KEYWORD_WHILE:
+			        $n = new JSNode($this->t);
+			        $n->isLoop = true;
+			        $n->condition = $this->ParenExpression($x);
+			        $n->body = $this->nest($x, $n);
+			return $n;
+
+			case KEYWORD_DO:
+				$n = new JSNode($this->t);
+				$n->isLoop = true;
+				$n->body = $this->nest($x, $n, KEYWORD_WHILE);
+				$n->condition = $this->ParenExpression($x);
+				if (!$x->ecmaStrictMode)
+				{
+					// <script language="JavaScript"> (without version hints) may need
+					// automatic semicolon insertion without a newline after do-while.
+					// See http://bugzilla.mozilla.org/show_bug.cgi?id=238945.
+					$this->t->match(OP_SEMICOLON);
+					return $n;
+				}
+			break;
+
+			case KEYWORD_BREAK:
+			case KEYWORD_CONTINUE:
+				$n = new JSNode($this->t);
+
+				if ($this->t->peekOnSameLine() == TOKEN_IDENTIFIER)
+				{
+					$this->t->get();
+					$n->label = $this->t->currentToken()->value;
+				}
+
+				$ss = $x->stmtStack;
+				$i = count($ss);
+				$label = $n->label;
+				if ($label)
+				{
+					do
+					{
+						if (--$i < 0)
+							throw $this->t->newSyntaxError('Label not found');
+					}
+					while ($ss[$i]->label != $label);
+				}
+				else
+				{
+					do
+					{
+						if (--$i < 0)
+							throw $this->t->newSyntaxError('Invalid ' . $tt);
+					}
+					while (!$ss[$i]->isLoop && ($tt != KEYWORD_BREAK || $ss[$i]->type != KEYWORD_SWITCH));
+				}
+
+				$n->target = $ss[$i];
+			break;
+
+			case KEYWORD_TRY:
+				$n = new JSNode($this->t);
+				$n->tryBlock = $this->Block($x);
+				$n->catchClauses = array();
+
+				while ($this->t->match(KEYWORD_CATCH))
+				{
+					$n2 = new JSNode($this->t);
+					$this->t->mustMatch(OP_LEFT_PAREN);
+					$n2->varName = $this->t->mustMatch(TOKEN_IDENTIFIER)->value;
+
+					if ($this->t->match(KEYWORD_IF))
+					{
+						if ($x->ecmaStrictMode)
+							throw $this->t->newSyntaxError('Illegal catch guard');
+
+						if (count($n->catchClauses) && !end($n->catchClauses)->guard)
+							throw $this->t->newSyntaxError('Guarded catch after unguarded');
+
+						$n2->guard = $this->Expression($x);
+					}
+					else
+					{
+						$n2->guard = null;
+					}
+
+					$this->t->mustMatch(OP_RIGHT_PAREN);
+					$n2->block = $this->Block($x);
+					array_push($n->catchClauses, $n2);
+				}
+
+				if ($this->t->match(KEYWORD_FINALLY))
+					$n->finallyBlock = $this->Block($x);
+
+				if (!count($n->catchClauses) && !$n->finallyBlock)
+					throw $this->t->newSyntaxError('Invalid try statement');
+			return $n;
+
+			case KEYWORD_CATCH:
+			case KEYWORD_FINALLY:
+				throw $this->t->newSyntaxError($tt + ' without preceding try');
+
+			case KEYWORD_THROW:
+				$n = new JSNode($this->t);
+				$n->exception = $this->Expression($x);
+			break;
+
+			case KEYWORD_RETURN:
+				if (!$x->inFunction)
+					throw $this->t->newSyntaxError('Invalid return');
+
+				$n = new JSNode($this->t);
+				$tt = $this->t->peekOnSameLine();
+				if ($tt != TOKEN_END && $tt != TOKEN_NEWLINE && $tt != OP_SEMICOLON && $tt != OP_RIGHT_CURLY)
+					$n->value = $this->Expression($x);
+				else
+					$n->value = null;
+			break;
+
+			case KEYWORD_WITH:
+				$n = new JSNode($this->t);
+				$n->object = $this->ParenExpression($x);
+				$n->body = $this->nest($x, $n);
+			return $n;
+
+			case KEYWORD_VAR:
+			case KEYWORD_CONST:
+			        $n = $this->Variables($x);
+			break;
+
+			case TOKEN_CONDCOMMENT_MULTILINE:
+				$n = new JSNode($this->t);
+			return $n;
+
+			case KEYWORD_DEBUGGER:
+				$n = new JSNode($this->t);
+			break;
+
+			case TOKEN_NEWLINE:
+			case OP_SEMICOLON:
+				$n = new JSNode($this->t, OP_SEMICOLON);
+				$n->expression = null;
+			return $n;
+
+			default:
+				if ($tt == TOKEN_IDENTIFIER)
+				{
+					$this->t->scanOperand = false;
+					$tt = $this->t->peek();
+					$this->t->scanOperand = true;
+					if ($tt == OP_COLON)
+					{
+						$label = $this->t->currentToken()->value;
+						$ss = $x->stmtStack;
+						for ($i = count($ss) - 1; $i >= 0; --$i)
+						{
+							if ($ss[$i]->label == $label)
+								throw $this->t->newSyntaxError('Duplicate label');
+						}
+
+						$this->t->get();
+						$n = new JSNode($this->t, JS_LABEL);
+						$n->label = $label;
+						$n->statement = $this->nest($x, $n);
+
+						return $n;
+					}
+				}
+
+				$n = new JSNode($this->t, OP_SEMICOLON);
+				$this->t->unget();
+				$n->expression = $this->Expression($x);
+				$n->end = $n->expression->end;
+			break;
+		}
+
+		if ($this->t->lineno == $this->t->currentToken()->lineno)
+		{
+			$tt = $this->t->peekOnSameLine();
+			if ($tt != TOKEN_END && $tt != TOKEN_NEWLINE && $tt != OP_SEMICOLON && $tt != OP_RIGHT_CURLY)
+				throw $this->t->newSyntaxError('Missing ; before statement');
+		}
+
+		$this->t->match(OP_SEMICOLON);
+
+		return $n;
+	}
+
+	private function FunctionDefinition($x, $requireName, $functionForm)
+	{
+		$f = new JSNode($this->t);
+
+		if ($f->type != KEYWORD_FUNCTION)
+			$f->type = ($f->value == 'get') ? JS_GETTER : JS_SETTER;
+
+		if ($this->t->match(TOKEN_IDENTIFIER))
+			$f->name = $this->t->currentToken()->value;
+		elseif ($requireName)
+			throw $this->t->newSyntaxError('Missing function identifier');
+
+		$this->t->mustMatch(OP_LEFT_PAREN);
+			$f->params = array();
+
+		while (($tt = $this->t->get()) != OP_RIGHT_PAREN)
+		{
+			if ($tt != TOKEN_IDENTIFIER)
+				throw $this->t->newSyntaxError('Missing formal parameter');
+
+			array_push($f->params, $this->t->currentToken()->value);
+
+			if ($this->t->peek() != OP_RIGHT_PAREN)
+				$this->t->mustMatch(OP_COMMA);
+		}
+
+		$this->t->mustMatch(OP_LEFT_CURLY);
+
+		$x2 = new JSCompilerContext(true);
+		$f->body = $this->Script($x2);
+
+		$this->t->mustMatch(OP_RIGHT_CURLY);
+		$f->end = $this->t->currentToken()->end;
+
+		$f->functionForm = $functionForm;
+		if ($functionForm == DECLARED_FORM)
+			array_push($x->funDecls, $f);
+
+		return $f;
+	}
+
+	private function Variables($x)
+	{
+		$n = new JSNode($this->t);
+
+		do
+		{
+			$this->t->mustMatch(TOKEN_IDENTIFIER);
+
+			$n2 = new JSNode($this->t);
+			$n2->name = $n2->value;
+
+			if ($this->t->match(OP_ASSIGN))
+			{
+				if ($this->t->currentToken()->assignOp)
+					throw $this->t->newSyntaxError('Invalid variable initialization');
+
+				$n2->initializer = $this->Expression($x, OP_COMMA);
+			}
+
+			$n2->readOnly = $n->type == KEYWORD_CONST;
+
+			$n->addNode($n2);
+			array_push($x->varDecls, $n2);
+		}
+		while ($this->t->match(OP_COMMA));
+
+		return $n;
+	}
+
+	private function Expression($x, $stop=false)
+	{
+		$operators = array();
+		$operands = array();
+		$n = false;
+
+		$bl = $x->bracketLevel;
+		$cl = $x->curlyLevel;
+		$pl = $x->parenLevel;
+		$hl = $x->hookLevel;
+
+		while (($tt = $this->t->get()) != TOKEN_END)
+		{
+			if ($tt == $stop &&
+				$x->bracketLevel == $bl &&
+				$x->curlyLevel == $cl &&
+				$x->parenLevel == $pl &&
+				$x->hookLevel == $hl
+			)
+			{
+				// Stop only if tt matches the optional stop parameter, and that
+				// token is not quoted by some kind of bracket.
+				break;
+			}
+
+			switch ($tt)
+			{
+				case OP_SEMICOLON:
+					// NB: cannot be empty, Statement handled that.
+					break 2;
+
+				case OP_ASSIGN:
+				case OP_HOOK:
+				case OP_COLON:
+					if ($this->t->scanOperand)
+						break 2;
+
+					// Use >, not >=, for right-associative ASSIGN and HOOK/COLON.
+					while (	!empty($operators) &&
+						(	$this->opPrecedence[end($operators)->type] > $this->opPrecedence[$tt] ||
+							($tt == OP_COLON && end($operators)->type == OP_ASSIGN)
+						)
+					)
+						$this->reduce($operators, $operands);
+
+					if ($tt == OP_COLON)
+					{
+						$n = end($operators);
+						if ($n->type != OP_HOOK)
+							throw $this->t->newSyntaxError('Invalid label');
+
+						--$x->hookLevel;
+					}
+					else
+					{
+						array_push($operators, new JSNode($this->t));
+						if ($tt == OP_ASSIGN)
+							end($operands)->assignOp = $this->t->currentToken()->assignOp;
+						else
+							++$x->hookLevel;
+					}
+
+					$this->t->scanOperand = true;
+				break;
+
+				case KEYWORD_IN:
+					// An in operator should not be parsed if we're parsing the head of
+					// a for (...) loop, unless it is in the then part of a conditional
+					// expression, or parenthesized somehow.
+					if ($x->inForLoopInit && !$x->hookLevel &&
+						!$x->bracketLevel && !$x->curlyLevel &&
+						!$x->parenLevel
+					)
+					{
+						break 2;
+					}
+				// FALL THROUGH
+				case OP_COMMA:
+					// Treat comma as left-associative so reduce can fold left-heavy
+					// COMMA trees into a single array.
+					// FALL THROUGH
+				case OP_OR:
+				case OP_AND:
+				case OP_BITWISE_OR:
+				case OP_BITWISE_XOR:
+				case OP_BITWISE_AND:
+				case OP_EQ: case OP_NE: case OP_STRICT_EQ: case OP_STRICT_NE:
+				case OP_LT: case OP_LE: case OP_GE: case OP_GT:
+				case KEYWORD_INSTANCEOF:
+				case OP_LSH: case OP_RSH: case OP_URSH:
+				case OP_PLUS: case OP_MINUS:
+				case OP_MUL: case OP_DIV: case OP_MOD:
+				case OP_DOT:
+					if ($this->t->scanOperand)
+						break 2;
+
+					while (	!empty($operators) &&
+						$this->opPrecedence[end($operators)->type] >= $this->opPrecedence[$tt]
+					)
+						$this->reduce($operators, $operands);
+
+					if ($tt == OP_DOT)
+					{
+						$this->t->mustMatch(TOKEN_IDENTIFIER);
+						array_push($operands, new JSNode($this->t, OP_DOT, array_pop($operands), new JSNode($this->t)));
+					}
+					else
+					{
+						array_push($operators, new JSNode($this->t));
+						$this->t->scanOperand = true;
+					}
+				break;
+
+				case KEYWORD_DELETE: case KEYWORD_VOID: case KEYWORD_TYPEOF:
+				case OP_NOT: case OP_BITWISE_NOT: case OP_UNARY_PLUS: case OP_UNARY_MINUS:
+				case KEYWORD_NEW:
+					if (!$this->t->scanOperand)
+						break 2;
+
+					array_push($operators, new JSNode($this->t));
+				break;
+
+				case OP_INCREMENT: case OP_DECREMENT:
+					if ($this->t->scanOperand)
+					{
+						array_push($operators, new JSNode($this->t));  // prefix increment or decrement
+					}
+					else
+					{
+						// Don't cross a line boundary for postfix {in,de}crement.
+						$t = $this->t->tokens[($this->t->tokenIndex + $this->t->lookahead - 1) & 3];
+						if ($t && $t->lineno != $this->t->lineno)
+							break 2;
+
+						if (!empty($operators))
+						{
+							// Use >, not >=, so postfix has higher precedence than prefix.
+							while ($this->opPrecedence[end($operators)->type] > $this->opPrecedence[$tt])
+								$this->reduce($operators, $operands);
+						}
+
+						$n = new JSNode($this->t, $tt, array_pop($operands));
+						$n->postfix = true;
+						array_push($operands, $n);
+					}
+				break;
+
+				case KEYWORD_FUNCTION:
+					if (!$this->t->scanOperand)
+						break 2;
+
+					array_push($operands, $this->FunctionDefinition($x, false, EXPRESSED_FORM));
+					$this->t->scanOperand = false;
+				break;
+
+				case KEYWORD_NULL: case KEYWORD_THIS: case KEYWORD_TRUE: case KEYWORD_FALSE:
+				case TOKEN_IDENTIFIER: case TOKEN_NUMBER: case TOKEN_STRING: case TOKEN_REGEXP:
+					if (!$this->t->scanOperand)
+						break 2;
+
+					array_push($operands, new JSNode($this->t));
+					$this->t->scanOperand = false;
+				break;
+
+				case TOKEN_CONDCOMMENT_MULTILINE:
+					if ($this->t->scanOperand)
+						array_push($operators, new JSNode($this->t));
+					else
+						array_push($operands, new JSNode($this->t));
+				break;
+
+				case OP_LEFT_BRACKET:
+					if ($this->t->scanOperand)
+					{
+						// Array initialiser.  Parse using recursive descent, as the
+						// sub-grammar here is not an operator grammar.
+						$n = new JSNode($this->t, JS_ARRAY_INIT);
+						while (($tt = $this->t->peek()) != OP_RIGHT_BRACKET)
+						{
+							if ($tt == OP_COMMA)
+							{
+								$this->t->get();
+								$n->addNode(null);
+								continue;
+							}
+
+							$n->addNode($this->Expression($x, OP_COMMA));
+							if (!$this->t->match(OP_COMMA))
+								break;
+						}
+
+						$this->t->mustMatch(OP_RIGHT_BRACKET);
+						array_push($operands, $n);
+						$this->t->scanOperand = false;
+					}
+					else
+					{
+						// Property indexing operator.
+						array_push($operators, new JSNode($this->t, JS_INDEX));
+						$this->t->scanOperand = true;
+						++$x->bracketLevel;
+					}
+				break;
+
+				case OP_RIGHT_BRACKET:
+					if ($this->t->scanOperand || $x->bracketLevel == $bl)
+						break 2;
+
+					while ($this->reduce($operators, $operands)->type != JS_INDEX)
+						continue;
+
+					--$x->bracketLevel;
+				break;
+
+				case OP_LEFT_CURLY:
+					if (!$this->t->scanOperand)
+						break 2;
+
+					// Object initialiser.  As for array initialisers (see above),
+					// parse using recursive descent.
+					++$x->curlyLevel;
+					$n = new JSNode($this->t, JS_OBJECT_INIT);
+					while (!$this->t->match(OP_RIGHT_CURLY))
+					{
+						do
+						{
+							$tt = $this->t->get();
+							$tv = $this->t->currentToken()->value;
+							if (($tv == 'get' || $tv == 'set') && $this->t->peek() == TOKEN_IDENTIFIER)
+							{
+								if ($x->ecmaStrictMode)
+									throw $this->t->newSyntaxError('Illegal property accessor');
+
+								$n->addNode($this->FunctionDefinition($x, true, EXPRESSED_FORM));
+							}
+							else
+							{
+								switch ($tt)
+								{
+									case TOKEN_IDENTIFIER:
+									case TOKEN_NUMBER:
+									case TOKEN_STRING:
+										$id = new JSNode($this->t);
+									break;
+
+									case OP_RIGHT_CURLY:
+										if ($x->ecmaStrictMode)
+											throw $this->t->newSyntaxError('Illegal trailing ,');
+									break 3;
+
+									default:
+										throw $this->t->newSyntaxError('Invalid property name');
+								}
+
+								$this->t->mustMatch(OP_COLON);
+								$n->addNode(new JSNode($this->t, JS_PROPERTY_INIT, $id, $this->Expression($x, OP_COMMA)));
+							}
+						}
+						while ($this->t->match(OP_COMMA));
+
+						$this->t->mustMatch(OP_RIGHT_CURLY);
+						break;
+					}
+
+					array_push($operands, $n);
+					$this->t->scanOperand = false;
+					--$x->curlyLevel;
+				break;
+
+				case OP_RIGHT_CURLY:
+					if (!$this->t->scanOperand && $x->curlyLevel != $cl)
+						throw new Exception('PANIC: right curly botch');
+				break 2;
+
+				case OP_LEFT_PAREN:
+					if ($this->t->scanOperand)
+					{
+						array_push($operators, new JSNode($this->t, JS_GROUP));
+					}
+					else
+					{
+						while (	!empty($operators) &&
+							$this->opPrecedence[end($operators)->type] > $this->opPrecedence[KEYWORD_NEW]
+						)
+							$this->reduce($operators, $operands);
+
+						// Handle () now, to regularize the n-ary case for n > 0.
+						// We must set scanOperand in case there are arguments and
+						// the first one is a regexp or unary+/-.
+						$n = end($operators);
+						$this->t->scanOperand = true;
+						if ($this->t->match(OP_RIGHT_PAREN))
+						{
+							if ($n && $n->type == KEYWORD_NEW)
+							{
+								array_pop($operators);
+								$n->addNode(array_pop($operands));
+							}
+							else
+							{
+								$n = new JSNode($this->t, JS_CALL, array_pop($operands), new JSNode($this->t, JS_LIST));
+							}
+
+							array_push($operands, $n);
+							$this->t->scanOperand = false;
+							break;
+						}
+
+						if ($n && $n->type == KEYWORD_NEW)
+							$n->type = JS_NEW_WITH_ARGS;
+						else
+							array_push($operators, new JSNode($this->t, JS_CALL));
+					}
+
+					++$x->parenLevel;
+				break;
+
+				case OP_RIGHT_PAREN:
+					if ($this->t->scanOperand || $x->parenLevel == $pl)
+						break 2;
+
+					while (($tt = $this->reduce($operators, $operands)->type) != JS_GROUP &&
+						$tt != JS_CALL && $tt != JS_NEW_WITH_ARGS
+					)
+					{
+						continue;
+					}
+
+					if ($tt != JS_GROUP)
+					{
+						$n = end($operands);
+						if ($n->treeNodes[1]->type != OP_COMMA)
+							$n->treeNodes[1] = new JSNode($this->t, JS_LIST, $n->treeNodes[1]);
+						else
+							$n->treeNodes[1]->type = JS_LIST;
+					}
+
+					--$x->parenLevel;
+				break;
+
+				// Automatic semicolon insertion means we may scan across a newline
+				// and into the beginning of another statement.  If so, break out of
+				// the while loop and let the t.scanOperand logic handle errors.
+				default:
+					break 2;
+			}
+		}
+
+		if ($x->hookLevel != $hl)
+			throw $this->t->newSyntaxError('Missing : after ?');
+
+		if ($x->parenLevel != $pl)
+			throw $this->t->newSyntaxError('Missing ) in parenthetical');
+
+		if ($x->bracketLevel != $bl)
+			throw $this->t->newSyntaxError('Missing ] in index expression');
+
+		if ($this->t->scanOperand)
+			throw $this->t->newSyntaxError('Missing operand');
+
+		// Resume default mode, scanning for operands, not operators.
+		$this->t->scanOperand = true;
+		$this->t->unget();
+
+		while (count($operators))
+			$this->reduce($operators, $operands);
+
+		return array_pop($operands);
+	}
+
+	private function ParenExpression($x)
+	{
+		$this->t->mustMatch(OP_LEFT_PAREN);
+		$n = $this->Expression($x);
+		$this->t->mustMatch(OP_RIGHT_PAREN);
+
+		return $n;
+	}
+
+	// Statement stack and nested statement handler.
+	private function nest($x, $node, $end = false)
+	{
+		array_push($x->stmtStack, $node);
+		$n = $this->statement($x);
+		array_pop($x->stmtStack);
+
+		if ($end)
+			$this->t->mustMatch($end);
+
+		return $n;
+	}
+
+	private function reduce(&$operators, &$operands)
+	{
+		$n = array_pop($operators);
+		$op = $n->type;
+		$arity = $this->opArity[$op];
+		$c = count($operands);
+		if ($arity == -2)
+		{
+			// Flatten left-associative trees
+			if ($c >= 2)
+			{
+				$left = $operands[$c - 2];
+				if ($left->type == $op)
+				{
+					$right = array_pop($operands);
+					$left->addNode($right);
+					return $left;
+				}
+			}
+			$arity = 2;
+		}
+
+		// Always use push to add operands to n, to update start and end
+		$a = array_splice($operands, $c - $arity);
+		for ($i = 0; $i < $arity; $i++)
+			$n->addNode($a[$i]);
+
+		// Include closing bracket or postfix operator in [start,end]
+		$te = $this->t->currentToken()->end;
+		if ($n->end < $te)
+			$n->end = $te;
+
+		array_push($operands, $n);
+
+		return $n;
+	}
+}
+
+class JSCompilerContext
+{
+	public $inFunction = false;
+	public $inForLoopInit = false;
+	public $ecmaStrictMode = false;
+	public $bracketLevel = 0;
+	public $curlyLevel = 0;
+	public $parenLevel = 0;
+	public $hookLevel = 0;
+
+	public $stmtStack = array();
+	public $funDecls = array();
+	public $varDecls = array();
+
+	public function __construct($inFunction)
+	{
+		$this->inFunction = $inFunction;
+	}
+}
+
+class JSNode
+{
+	private $type;
+	private $value;
+	private $lineno;
+	private $start;
+	private $end;
+
+	public $treeNodes = array();
+	public $funDecls = array();
+	public $varDecls = array();
+
+	public function __construct($t, $type=0)
+	{
+		if ($token = $t->currentToken())
+		{
+			$this->type = $type ? $type : $token->type;
+			$this->value = $token->value;
+			$this->lineno = $token->lineno;
+			$this->start = $token->start;
+			$this->end = $token->end;
+		}
+		else
+		{
+			$this->type = $type;
+			$this->lineno = $t->lineno;
+		}
+
+		if (($numargs = func_num_args()) > 2)
+		{
+			$args = func_get_args();;
+			for ($i = 2; $i < $numargs; $i++)
+				$this->addNode($args[$i]);
+		}
+	}
+
+	// we don't want to bloat our object with all kind of specific properties, so we use overloading
+	public function __set($name, $value)
+	{
+		$this->$name = $value;
+	}
+
+	public function __get($name)
+	{
+		if (isset($this->$name))
+			return $this->$name;
+
+		return null;
+	}
+
+	public function addNode($node)
+	{
+		$this->treeNodes[] = $node;
+	}
+}
+
+class JSTokenizer
+{
+	private $cursor = 0;
+	private $source;
+
+	public $tokens = array();
+	public $tokenIndex = 0;
+	public $lookahead = 0;
+	public $scanNewlines = false;
+	public $scanOperand = true;
+
+	public $filename;
+	public $lineno;
+
+	private $keywords = array(
+		'break',
+		'case', 'catch', 'const', 'continue',
+		'debugger', 'default', 'delete', 'do',
+		'else', 'enum',
+		'false', 'finally', 'for', 'function',
+		'if', 'in', 'instanceof',
+		'new', 'null',
+		'return',
+		'switch',
+		'this', 'throw', 'true', 'try', 'typeof',
+		'var', 'void',
+		'while', 'with'
+	);
+
+	private $opTypeNames = array(
+		';'	=> 'SEMICOLON',
+		','	=> 'COMMA',
+		'?'	=> 'HOOK',
+		':'	=> 'COLON',
+		'||'	=> 'OR',
+		'&&'	=> 'AND',
+		'|'	=> 'BITWISE_OR',
+		'^'	=> 'BITWISE_XOR',
+		'&'	=> 'BITWISE_AND',
+		'==='	=> 'STRICT_EQ',
+		'=='	=> 'EQ',
+		'='	=> 'ASSIGN',
+		'!=='	=> 'STRICT_NE',
+		'!='	=> 'NE',
+		'<<'	=> 'LSH',
+		'<='	=> 'LE',
+		'<'	=> 'LT',
+		'>>>'	=> 'URSH',
+		'>>'	=> 'RSH',
+		'>='	=> 'GE',
+		'>'	=> 'GT',
+		'++'	=> 'INCREMENT',
+		'--'	=> 'DECREMENT',
+		'+'	=> 'PLUS',
+		'-'	=> 'MINUS',
+		'*'	=> 'MUL',
+		'/'	=> 'DIV',
+		'%'	=> 'MOD',
+		'!'	=> 'NOT',
+		'~'	=> 'BITWISE_NOT',
+		'.'	=> 'DOT',
+		'['	=> 'LEFT_BRACKET',
+		']'	=> 'RIGHT_BRACKET',
+		'{'	=> 'LEFT_CURLY',
+		'}'	=> 'RIGHT_CURLY',
+		'('	=> 'LEFT_PAREN',
+		')'	=> 'RIGHT_PAREN',
+		'@*/'	=> 'CONDCOMMENT_END'
+	);
+
+	private $assignOps = array('|', '^', '&', '<<', '>>', '>>>', '+', '-', '*', '/', '%');
+	private $opRegExp;
+
+	public function __construct()
+	{
+		$this->opRegExp = '#^(' . implode('|', array_map('preg_quote', array_keys($this->opTypeNames))) . ')#';
+
+		// this is quite a hidden yet convenient place to create the defines for operators and keywords
+		foreach ($this->opTypeNames as $operand => $name)
+			define('OP_' . $name, $operand);
+
+		define('OP_UNARY_PLUS', 'U+');
+		define('OP_UNARY_MINUS', 'U-');
+
+		foreach ($this->keywords as $keyword)
+			define('KEYWORD_' . strtoupper($keyword), $keyword);
+	}
+
+	public function init($source, $filename = '', $lineno = 1)
+	{
+		$this->source = $source;
+		$this->filename = $filename ? $filename : '[inline]';
+		$this->lineno = $lineno;
+
+		$this->cursor = 0;
+		$this->tokens = array();
+		$this->tokenIndex = 0;
+		$this->lookahead = 0;
+		$this->scanNewlines = false;
+		$this->scanOperand = true;
+	}
+
+	public function getInput($chunksize)
+	{
+		if ($chunksize)
+			return substr($this->source, $this->cursor, $chunksize);
+
+		return substr($this->source, $this->cursor);
+	}
+
+	public function isDone()
+	{
+		return $this->peek() == TOKEN_END;
+	}
+
+	public function match($tt)
+	{
+		return $this->get() == $tt || $this->unget();
+	}
+
+	public function mustMatch($tt)
+	{
+	        if (!$this->match($tt))
+			throw $this->newSyntaxError('Unexpected token; token ' . $tt . ' expected');
+
+		return $this->currentToken();
+	}
+
+	public function peek()
+	{
+		if ($this->lookahead)
+		{
+			$next = $this->tokens[($this->tokenIndex + $this->lookahead) & 3];
+			if ($this->scanNewlines && $next->lineno != $this->lineno)
+				$tt = TOKEN_NEWLINE;
+			else
+				$tt = $next->type;
+		}
+		else
+		{
+			$tt = $this->get();
+			$this->unget();
+		}
+
+		return $tt;
+	}
+
+	public function peekOnSameLine()
+	{
+		$this->scanNewlines = true;
+		$tt = $this->peek();
+		$this->scanNewlines = false;
+
+		return $tt;
+	}
+
+	public function currentToken()
+	{
+		if (!empty($this->tokens))
+			return $this->tokens[$this->tokenIndex];
+	}
+
+	public function get($chunksize = 1000)
+	{
+		while($this->lookahead)
+		{
+			$this->lookahead--;
+			$this->tokenIndex = ($this->tokenIndex + 1) & 3;
+			$token = $this->tokens[$this->tokenIndex];
+			if ($token->type != TOKEN_NEWLINE || $this->scanNewlines)
+				return $token->type;
+		}
+
+		$conditional_comment = false;
+
+		// strip whitespace and comments
+		while(true)
+		{
+			$input = $this->getInput($chunksize);
+
+			// whitespace handling; gobble up \r as well (effectively we don't have support for MAC newlines!)
+			$re = $this->scanNewlines ? '/^[ \r\t]+/' : '/^\s+/';
+			if (preg_match($re, $input, $match))
+			{
+				$spaces = $match[0];
+				$spacelen = strlen($spaces);
+				$this->cursor += $spacelen;
+				if (!$this->scanNewlines)
+					$this->lineno += substr_count($spaces, "\n");
+
+				if ($spacelen == $chunksize)
+					continue; // complete chunk contained whitespace
+
+				$input = $this->getInput($chunksize);
+				if ($input == '' || $input[0] != '/')
+					break;
+			}
+
+			// Comments
+			if (!preg_match('/^\/(?:\*(@(?:cc_on|if|elif|else|end))?(?:.|\n)*?\*\/|\/.*)/', $input, $match))
+			{
+				if (!$chunksize)
+					break;
+
+				// retry with a full chunk fetch; this also prevents breakage of long regular expressions (which will never match a comment)
+				$chunksize = null;
+				continue;
+			}
+
+			// check if this is a conditional (JScript) comment
+			if (!empty($match[1]))
+			{
+				//$match[0] = '/*' . $match[1];
+				$conditional_comment = true;
+				break;
+			}
+			else
+			{
+				$this->cursor += strlen($match[0]);
+				$this->lineno += substr_count($match[0], "\n");
+			}
+		}
+
+		if ($input == '')
+		{
+			$tt = TOKEN_END;
+			$match = array('');
+		}
+		elseif ($conditional_comment)
+		{
+			$tt = TOKEN_CONDCOMMENT_MULTILINE;
+		}
+		else
+		{
+			switch ($input[0])
+			{
+				case '0': case '1': case '2': case '3': case '4':
+				case '5': case '6': case '7': case '8': case '9':
+					if (preg_match('/^\d+\.\d*(?:[eE][-+]?\d+)?|^\d+(?:\.\d*)?[eE][-+]?\d+/', $input, $match))
+					{
+						$tt = TOKEN_NUMBER;
+					}
+					elseif (preg_match('/^0[xX][\da-fA-F]+|^0[0-7]*|^\d+/', $input, $match))
+					{
+						// this should always match because of \d+
+						$tt = TOKEN_NUMBER;
+					}
+				break;
+
+				case '"':
+				case "'":
+					if (preg_match('/^"(?:\\\\(?:.|\r?\n)|[^\\\\"\r\n])*"|^\'(?:\\\\(?:.|\r?\n)|[^\\\\\'\r\n])*\'/', $input, $match))
+					{
+						$tt = TOKEN_STRING;
+					}
+					else
+					{
+						if ($chunksize)
+							return $this->get(null); // retry with a full chunk fetch
+
+						throw $this->newSyntaxError('Unterminated string literal');
+					}
+				break;
+
+				case '/':
+					if ($this->scanOperand && preg_match('/^\/((?:\\\\.|\[(?:\\\\.|[^\]])*\]|[^\/])+)\/([gimy]*)/', $input, $match))
+					{
+						$tt = TOKEN_REGEXP;
+						break;
+					}
+				// fall through
+
+				case '|':
+				case '^':
+				case '&':
+				case '<':
+				case '>':
+				case '+':
+				case '-':
+				case '*':
+				case '%':
+				case '=':
+				case '!':
+					// should always match
+					preg_match($this->opRegExp, $input, $match);
+					$op = $match[0];
+					if (in_array($op, $this->assignOps) && $input[strlen($op)] == '=')
+					{
+						$tt = OP_ASSIGN;
+						$match[0] .= '=';
+					}
+					else
+					{
+						$tt = $op;
+						if ($this->scanOperand)
+						{
+							if ($op == OP_PLUS)
+								$tt = OP_UNARY_PLUS;
+							elseif ($op == OP_MINUS)
+								$tt = OP_UNARY_MINUS;
+						}
+						$op = null;
+					}
+				break;
+
+				case '.':
+					if (preg_match('/^\.\d+(?:[eE][-+]?\d+)?/', $input, $match))
+					{
+						$tt = TOKEN_NUMBER;
+						break;
+					}
+				// fall through
+
+				case ';':
+				case ',':
+				case '?':
+				case ':':
+				case '~':
+				case '[':
+				case ']':
+				case '{':
+				case '}':
+				case '(':
+				case ')':
+					// these are all single
+					$match = array($input[0]);
+					$tt = $input[0];
+				break;
+
+				case '@':
+					throw $this->newSyntaxError('Illegal token');
+				break;
+
+				case "\n":
+					if ($this->scanNewlines)
+					{
+						$match = array("\n");
+						$tt = TOKEN_NEWLINE;
+					}
+					else
+						throw $this->newSyntaxError('Illegal token');
+				break;
+
+				default:
+					// FIXME: add support for unicode and unicode escape sequence \uHHHH
+					if (preg_match('/^[$\w]+/', $input, $match))
+					{
+						$tt = in_array($match[0], $this->keywords) ? $match[0] : TOKEN_IDENTIFIER;
+					}
+					else
+						throw $this->newSyntaxError('Illegal token');
+			}
+		}
+
+		$this->tokenIndex = ($this->tokenIndex + 1) & 3;
+
+		if (!isset($this->tokens[$this->tokenIndex]))
+			$this->tokens[$this->tokenIndex] = new JSToken();
+
+		$token = $this->tokens[$this->tokenIndex];
+		$token->type = $tt;
+
+		if ($tt == OP_ASSIGN)
+			$token->assignOp = $op;
+
+		$token->start = $this->cursor;
+
+		$token->value = $match[0];
+		$this->cursor += strlen($match[0]);
+
+		$token->end = $this->cursor;
+		$token->lineno = $this->lineno;
+
+		return $tt;
+	}
+
+	public function unget()
+	{
+		if (++$this->lookahead == 4)
+			throw $this->newSyntaxError('PANIC: too much lookahead!');
+
+		$this->tokenIndex = ($this->tokenIndex - 1) & 3;
+	}
+
+	public function newSyntaxError($m)
+	{
+		return new Exception('Parse error: ' . $m . ' in file \'' . $this->filename . '\' on line ' . $this->lineno);
+	}
+}
+
+class JSToken
+{
+	public $type;
+	public $value;
+	public $start;
+	public $end;
+	public $lineno;
+	public $assignOp;
+}
+
+?>