includes/libs/JavaScriptMinifier.php

   1 <?php
   2 // @codingStandardsIgnoreFile File external to MediaWiki. Ignore coding conventions checks.
   3 /**
   4  * JavaScript Minifier
   5  *
   6  * @file
   7  * @author Paul Copperman <paul.copperman@gmail.com>
   8  * @license Choose any of Apache, MIT, GPL, LGPL
   9  */
  10
  11 /**
  12  * This class is meant to safely minify javascript code, while leaving syntactically correct
  13  * programs intact. Other libraries, such as JSMin require a certain coding style to work
  14  * correctly. OTOH, libraries like jsminplus, that do parse the code correctly are rather
  15  * slow, because they construct a complete parse tree before outputting the code minified.
  16  * So this class is meant to allow arbitrary (but syntactically correct) input, while being
  17  * fast enough to be used for on-the-fly minifying.
  18  */
  19 class JavaScriptMinifier {
  20
  21         /* Class constants */
  22         /* Parsing states.
  23          * The state machine is only necessary to decide whether to parse a slash as division
  24          * operator or as regexp literal.
  25          * States are named after the next expected item. We only distinguish states when the
  26          * distinction is relevant for our purpose.
  27          */
  28         const STATEMENT                = 0;
  29         const CONDITION                = 1;
  30         const PROPERTY_ASSIGNMENT      = 2;
  31         const EXPRESSION               = 3;
  32         const EXPRESSION_NO_NL         = 4; // only relevant for semicolon insertion
  33         const EXPRESSION_OP            = 5;
  34         const EXPRESSION_FUNC          = 6;
  35         const EXPRESSION_TERNARY       = 7; // used to determine the role of a colon
  36         const EXPRESSION_TERNARY_OP    = 8;
  37         const EXPRESSION_TERNARY_FUNC  = 9;
  38         const PAREN_EXPRESSION         = 10; // expression which is not on the top level
  39         const PAREN_EXPRESSION_OP      = 11;
  40         const PAREN_EXPRESSION_FUNC    = 12;
  41         const PROPERTY_EXPRESSION      = 13; // expression which is within an object literal
  42         const PROPERTY_EXPRESSION_OP   = 14;
  43         const PROPERTY_EXPRESSION_FUNC = 15;
  44
  45         /* Token types */
  46         const TYPE_UN_OP       = 1; // unary operators
  47         const TYPE_INCR_OP     = 2; // ++ and --
  48         const TYPE_BIN_OP      = 3; // binary operators
  49         const TYPE_ADD_OP      = 4; // + and - which can be either unary or binary ops
  50         const TYPE_HOOK        = 5; // ?
  51         const TYPE_COLON       = 6; // :
  52         const TYPE_COMMA       = 7; // ,
  53         const TYPE_SEMICOLON   = 8; // ;
  54         const TYPE_BRACE_OPEN  = 9; // {
  55         const TYPE_BRACE_CLOSE = 10; // }
  56         const TYPE_PAREN_OPEN  = 11; // ( and [
  57         const TYPE_PAREN_CLOSE = 12; // ) and ]
  58         const TYPE_RETURN      = 13; // keywords: break, continue, return, throw
  59         const TYPE_IF          = 14; // keywords: catch, for, with, switch, while, if
  60         const TYPE_DO          = 15; // keywords: case, var, finally, else, do, try
  61         const TYPE_FUNC        = 16; // keywords: function
  62         const TYPE_LITERAL     = 17; // all literals, identifiers and unrecognised tokens
  63
  64         // Sanity limit to avoid excessive memory usage
  65         const STACK_LIMIT = 1000;
  66
  67         /* Static functions */
  68
  69         /**
  70          * Returns minified JavaScript code.
  71          *
  72          * NOTE: $maxLineLength isn't a strict maximum. Longer lines will be produced when
  73          *       literals (e.g. quoted strings) longer than $maxLineLength are encountered
  74          *       or when required to guard against semicolon insertion.
  75          *
  76          * @param string $s JavaScript code to minify
  77          * @param int $maxLineLength Maximum length of a single line, or -1 for no maximum.
  78          * @return String Minified code
  79          */
  80         public static function minify( $s, $maxLineLength = 1000 ) {
  81                 // First we declare a few tables that contain our parsing rules
  82
  83                 // $opChars : characters, which can be combined without whitespace in between them
  84                 $opChars = array(
  85                         '!' => true,
  86                         '"' => true,
  87                         '%' => true,
  88                         '&' => true,
  89                         "'" => true,
  90                         '(' => true,
  91                         ')' => true,
  92                         '*' => true,
  93                         '+' => true,
  94                         ',' => true,
  95                         '-' => true,
  96                         '.' => true,
  97                         '/' => true,
  98                         ':' => true,
  99                         ';' => true,
 100                         '<' => true,
 101                         '=' => true,
 102                         '>' => true,
 103                         '?' => true,
 104                         '[' => true,
 105                         ']' => true,
 106                         '^' => true,
 107                         '{' => true,
 108                         '|' => true,
 109                         '}' => true,
 110                         '~' => true
 111                 );
 112
 113                 // $tokenTypes : maps keywords and operators to their corresponding token type
 114                 $tokenTypes = array(
 115                         '!'          => self::TYPE_UN_OP,
 116                         '~'          => self::TYPE_UN_OP,
 117                         'delete'     => self::TYPE_UN_OP,
 118                         'new'        => self::TYPE_UN_OP,
 119                         'typeof'     => self::TYPE_UN_OP,
 120                         'void'       => self::TYPE_UN_OP,
 121                         '++'         => self::TYPE_INCR_OP,
 122                         '--'         => self::TYPE_INCR_OP,
 123                         '!='         => self::TYPE_BIN_OP,
 124                         '!=='        => self::TYPE_BIN_OP,
 125                         '%'          => self::TYPE_BIN_OP,
 126                         '%='         => self::TYPE_BIN_OP,
 127                         '&'          => self::TYPE_BIN_OP,
 128                         '&&'         => self::TYPE_BIN_OP,
 129                         '&='         => self::TYPE_BIN_OP,
 130                         '*'          => self::TYPE_BIN_OP,
 131                         '*='         => self::TYPE_BIN_OP,
 132                         '+='         => self::TYPE_BIN_OP,
 133                         '-='         => self::TYPE_BIN_OP,
 134                         '.'          => self::TYPE_BIN_OP,
 135                         '/'          => self::TYPE_BIN_OP,
 136                         '/='         => self::TYPE_BIN_OP,
 137                         '<'          => self::TYPE_BIN_OP,
 138                         '<<'         => self::TYPE_BIN_OP,
 139                         '<<='        => self::TYPE_BIN_OP,
 140                         '<='         => self::TYPE_BIN_OP,
 141                         '='          => self::TYPE_BIN_OP,
 142                         '=='         => self::TYPE_BIN_OP,
 143                         '==='        => self::TYPE_BIN_OP,
 144                         '>'          => self::TYPE_BIN_OP,
 145                         '>='         => self::TYPE_BIN_OP,
 146                         '>>'         => self::TYPE_BIN_OP,
 147                         '>>='        => self::TYPE_BIN_OP,
 148                         '>>>'        => self::TYPE_BIN_OP,
 149                         '>>>='       => self::TYPE_BIN_OP,
 150                         '^'          => self::TYPE_BIN_OP,
 151                         '^='         => self::TYPE_BIN_OP,
 152                         '|'          => self::TYPE_BIN_OP,
 153                         '|='         => self::TYPE_BIN_OP,
 154                         '||'         => self::TYPE_BIN_OP,
 155                         'in'         => self::TYPE_BIN_OP,
 156                         'instanceof' => self::TYPE_BIN_OP,
 157                         '+'          => self::TYPE_ADD_OP,
 158                         '-'          => self::TYPE_ADD_OP,
 159                         '?'          => self::TYPE_HOOK,
 160                         ':'          => self::TYPE_COLON,
 161                         ','          => self::TYPE_COMMA,
 162                         ';'          => self::TYPE_SEMICOLON,
 163                         '{'          => self::TYPE_BRACE_OPEN,
 164                         '}'          => self::TYPE_BRACE_CLOSE,
 165                         '('          => self::TYPE_PAREN_OPEN,
 166                         '['          => self::TYPE_PAREN_OPEN,
 167                         ')'          => self::TYPE_PAREN_CLOSE,
 168                         ']'          => self::TYPE_PAREN_CLOSE,
 169                         'break'      => self::TYPE_RETURN,
 170                         'continue'   => self::TYPE_RETURN,
 171                         'return'     => self::TYPE_RETURN,
 172                         'throw'      => self::TYPE_RETURN,
 173                         'catch'      => self::TYPE_IF,
 174                         'for'        => self::TYPE_IF,
 175                         'if'         => self::TYPE_IF,
 176                         'switch'     => self::TYPE_IF,
 177                         'while'      => self::TYPE_IF,
 178                         'with'       => self::TYPE_IF,
 179                         'case'       => self::TYPE_DO,
 180                         'do'         => self::TYPE_DO,
 181                         'else'       => self::TYPE_DO,
 182                         'finally'    => self::TYPE_DO,
 183                         'try'        => self::TYPE_DO,
 184                         'var'        => self::TYPE_DO,
 185                         'function'   => self::TYPE_FUNC
 186                 );
 187
 188                 // $goto : This is the main table for our state machine. For every state/token pair
 189                 //         the following state is defined. When no rule exists for a given pair,
 190                 //         the state is left unchanged.
 191                 $goto = array(
 192                         self::STATEMENT => array(
 193                                 self::TYPE_UN_OP      => self::EXPRESSION,
 194                                 self::TYPE_INCR_OP    => self::EXPRESSION,
 195                                 self::TYPE_ADD_OP     => self::EXPRESSION,
 196                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
 197                                 self::TYPE_RETURN     => self::EXPRESSION_NO_NL,
 198                                 self::TYPE_IF         => self::CONDITION,
 199                                 self::TYPE_FUNC       => self::CONDITION,
 200                                 self::TYPE_LITERAL    => self::EXPRESSION_OP
 201                         ),
 202                         self::CONDITION => array(
 203                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION
 204                         ),
 205                         self::PROPERTY_ASSIGNMENT => array(
 206                                 self::TYPE_COLON      => self::PROPERTY_EXPRESSION,
 207                                 self::TYPE_BRACE_OPEN => self::STATEMENT
 208                         ),
 209                         self::EXPRESSION => array(
 210                                 self::TYPE_SEMICOLON  => self::STATEMENT,
 211                                 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT,
 212                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
 213                                 self::TYPE_FUNC       => self::EXPRESSION_FUNC,
 214                                 self::TYPE_LITERAL    => self::EXPRESSION_OP
 215                         ),
 216                         self::EXPRESSION_NO_NL => array(
 217                                 self::TYPE_SEMICOLON  => self::STATEMENT,
 218                                 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT,
 219                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
 220                                 self::TYPE_FUNC       => self::EXPRESSION_FUNC,
 221                                 self::TYPE_LITERAL    => self::EXPRESSION_OP
 222                         ),
 223                         self::EXPRESSION_OP => array(
 224                                 self::TYPE_BIN_OP     => self::EXPRESSION,
 225                                 self::TYPE_ADD_OP     => self::EXPRESSION,
 226                                 self::TYPE_HOOK       => self::EXPRESSION_TERNARY,
 227                                 self::TYPE_COLON      => self::STATEMENT,
 228                                 self::TYPE_COMMA      => self::EXPRESSION,
 229                                 self::TYPE_SEMICOLON  => self::STATEMENT,
 230                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION
 231                         ),
 232                         self::EXPRESSION_FUNC => array(
 233                                 self::TYPE_BRACE_OPEN => self::STATEMENT
 234                         ),
 235                         self::EXPRESSION_TERNARY => array(
 236                                 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT,
 237                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
 238                                 self::TYPE_FUNC       => self::EXPRESSION_TERNARY_FUNC,
 239                                 self::TYPE_LITERAL    => self::EXPRESSION_TERNARY_OP
 240                         ),
 241                         self::EXPRESSION_TERNARY_OP => array(
 242                                 self::TYPE_BIN_OP     => self::EXPRESSION_TERNARY,
 243                                 self::TYPE_ADD_OP     => self::EXPRESSION_TERNARY,
 244                                 self::TYPE_HOOK       => self::EXPRESSION_TERNARY,
 245                                 self::TYPE_COMMA      => self::EXPRESSION_TERNARY,
 246                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION
 247                         ),
 248                         self::EXPRESSION_TERNARY_FUNC => array(
 249                                 self::TYPE_BRACE_OPEN => self::STATEMENT
 250                         ),
 251                         self::PAREN_EXPRESSION => array(
 252                                 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT,
 253                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
 254                                 self::TYPE_FUNC       => self::PAREN_EXPRESSION_FUNC,
 255                                 self::TYPE_LITERAL    => self::PAREN_EXPRESSION_OP
 256                         ),
 257                         self::PAREN_EXPRESSION_OP => array(
 258                                 self::TYPE_BIN_OP     => self::PAREN_EXPRESSION,
 259                                 self::TYPE_ADD_OP     => self::PAREN_EXPRESSION,
 260                                 self::TYPE_HOOK       => self::PAREN_EXPRESSION,
 261                                 self::TYPE_COLON      => self::PAREN_EXPRESSION,
 262                                 self::TYPE_COMMA      => self::PAREN_EXPRESSION,
 263                                 self::TYPE_SEMICOLON  => self::PAREN_EXPRESSION,
 264                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION
 265                         ),
 266                         self::PAREN_EXPRESSION_FUNC => array(
 267                                 self::TYPE_BRACE_OPEN => self::STATEMENT
 268                         ),
 269                         self::PROPERTY_EXPRESSION => array(
 270                                 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT,
 271                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
 272                                 self::TYPE_FUNC       => self::PROPERTY_EXPRESSION_FUNC,
 273                                 self::TYPE_LITERAL    => self::PROPERTY_EXPRESSION_OP
 274                         ),
 275                         self::PROPERTY_EXPRESSION_OP => array(
 276                                 self::TYPE_BIN_OP     => self::PROPERTY_EXPRESSION,
 277                                 self::TYPE_ADD_OP     => self::PROPERTY_EXPRESSION,
 278                                 self::TYPE_HOOK       => self::PROPERTY_EXPRESSION,
 279                                 self::TYPE_COMMA      => self::PROPERTY_ASSIGNMENT,
 280                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION
 281                         ),
 282                         self::PROPERTY_EXPRESSION_FUNC => array(
 283                                 self::TYPE_BRACE_OPEN => self::STATEMENT
 284                         )
 285                 );
 286
 287                 // $push : This table contains the rules for when to push a state onto the stack.
 288                 //         The pushed state is the state to return to when the corresponding
 289                 //         closing token is found
 290                 $push = array(
 291                         self::STATEMENT => array(
 292                                 self::TYPE_BRACE_OPEN => self::STATEMENT,
 293                                 self::TYPE_PAREN_OPEN => self::EXPRESSION_OP
 294                         ),
 295                         self::CONDITION => array(
 296                                 self::TYPE_PAREN_OPEN => self::STATEMENT
 297                         ),
 298                         self::PROPERTY_ASSIGNMENT => array(
 299                                 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT
 300                         ),
 301                         self::EXPRESSION => array(
 302                                 self::TYPE_BRACE_OPEN => self::EXPRESSION_OP,
 303                                 self::TYPE_PAREN_OPEN => self::EXPRESSION_OP
 304                         ),
 305                         self::EXPRESSION_NO_NL => array(
 306                                 self::TYPE_BRACE_OPEN => self::EXPRESSION_OP,
 307                                 self::TYPE_PAREN_OPEN => self::EXPRESSION_OP
 308                         ),
 309                         self::EXPRESSION_OP => array(
 310                                 self::TYPE_HOOK       => self::EXPRESSION,
 311                                 self::TYPE_PAREN_OPEN => self::EXPRESSION_OP
 312                         ),
 313                         self::EXPRESSION_FUNC => array(
 314                                 self::TYPE_BRACE_OPEN => self::EXPRESSION_OP
 315                         ),
 316                         self::EXPRESSION_TERNARY => array(
 317                                 self::TYPE_BRACE_OPEN => self::EXPRESSION_TERNARY_OP,
 318                                 self::TYPE_PAREN_OPEN => self::EXPRESSION_TERNARY_OP
 319                         ),
 320                         self::EXPRESSION_TERNARY_OP => array(
 321                                 self::TYPE_HOOK       => self::EXPRESSION_TERNARY,
 322                                 self::TYPE_PAREN_OPEN => self::EXPRESSION_TERNARY_OP
 323                         ),
 324                         self::EXPRESSION_TERNARY_FUNC => array(
 325                                 self::TYPE_BRACE_OPEN => self::EXPRESSION_TERNARY_OP
 326                         ),
 327                         self::PAREN_EXPRESSION => array(
 328                                 self::TYPE_BRACE_OPEN => self::PAREN_EXPRESSION_OP,
 329                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION_OP
 330                         ),
 331                         self::PAREN_EXPRESSION_OP => array(
 332                                 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION_OP
 333                         ),
 334                         self::PAREN_EXPRESSION_FUNC => array(
 335                                 self::TYPE_BRACE_OPEN => self::PAREN_EXPRESSION_OP
 336                         ),
 337                         self::PROPERTY_EXPRESSION => array(
 338                                 self::TYPE_BRACE_OPEN => self::PROPERTY_EXPRESSION_OP,
 339                                 self::TYPE_PAREN_OPEN => self::PROPERTY_EXPRESSION_OP
 340                         ),
 341                         self::PROPERTY_EXPRESSION_OP => array(
 342                                 self::TYPE_PAREN_OPEN => self::PROPERTY_EXPRESSION_OP
 343                         ),
 344                         self::PROPERTY_EXPRESSION_FUNC => array(
 345                                 self::TYPE_BRACE_OPEN => self::PROPERTY_EXPRESSION_OP
 346                         )
 347                 );
 348
 349                 // $pop : Rules for when to pop a state from the stack
 350                 $pop = array(
 351                         self::STATEMENT              => array( self::TYPE_BRACE_CLOSE => true ),
 352                         self::PROPERTY_ASSIGNMENT    => array( self::TYPE_BRACE_CLOSE => true ),
 353                         self::EXPRESSION             => array( self::TYPE_BRACE_CLOSE => true ),
 354                         self::EXPRESSION_NO_NL       => array( self::TYPE_BRACE_CLOSE => true ),
 355                         self::EXPRESSION_OP          => array( self::TYPE_BRACE_CLOSE => true ),
 356                         self::EXPRESSION_TERNARY_OP  => array( self::TYPE_COLON       => true ),
 357                         self::PAREN_EXPRESSION       => array( self::TYPE_PAREN_CLOSE => true ),
 358                         self::PAREN_EXPRESSION_OP    => array( self::TYPE_PAREN_CLOSE => true ),
 359                         self::PROPERTY_EXPRESSION    => array( self::TYPE_BRACE_CLOSE => true ),
 360                         self::PROPERTY_EXPRESSION_OP => array( self::TYPE_BRACE_CLOSE => true )
 361                 );
 362
 363                 // $semicolon : Rules for when a semicolon insertion is appropriate
 364                 $semicolon = array(
 365                         self::EXPRESSION_NO_NL => array(
 366                                 self::TYPE_UN_OP      => true,
 367                                 self::TYPE_INCR_OP    => true,
 368                                 self::TYPE_ADD_OP     => true,
 369                                 self::TYPE_BRACE_OPEN => true,
 370                                 self::TYPE_PAREN_OPEN => true,
 371                                 self::TYPE_RETURN     => true,
 372                                 self::TYPE_IF         => true,
 373                                 self::TYPE_DO         => true,
 374                                 self::TYPE_FUNC       => true,
 375                                 self::TYPE_LITERAL    => true
 376                         ),
 377                         self::EXPRESSION_OP => array(
 378                                 self::TYPE_UN_OP      => true,
 379                                 self::TYPE_INCR_OP    => true,
 380                                 self::TYPE_BRACE_OPEN => true,
 381                                 self::TYPE_RETURN     => true,
 382                                 self::TYPE_IF         => true,
 383                                 self::TYPE_DO         => true,
 384                                 self::TYPE_FUNC       => true,
 385                                 self::TYPE_LITERAL    => true
 386                         )
 387                 );
 388
 389                 // $divStates : Contains all states that can be followed by a division operator
 390                 $divStates = array(
 391                         self::EXPRESSION_OP          => true,
 392                         self::EXPRESSION_TERNARY_OP  => true,
 393                         self::PAREN_EXPRESSION_OP    => true,
 394                         self::PROPERTY_EXPRESSION_OP => true
 395                 );
 396
 397                 // Here's where the minifying takes place: Loop through the input, looking for tokens
 398                 // and output them to $out, taking actions to the above defined rules when appropriate.
 399                 $out = '';
 400                 $pos = 0;
 401                 $length = strlen( $s );
 402                 $lineLength = 0;
 403                 $newlineFound = true;
 404                 $state = self::STATEMENT;
 405                 $stack = array();
 406                 $last = ';'; // Pretend that we have seen a semicolon yet
 407                 while( $pos < $length ) {
 408                         // First, skip over any whitespace and multiline comments, recording whether we
 409                         // found any newline character
 410                         $skip = strspn( $s, " \t\n\r\xb\xc", $pos );
 411                         if( !$skip ) {
 412                                 $ch = $s[$pos];
 413                                 if( $ch === '/' && substr( $s, $pos, 2 ) === '/*' ) {
 414                                         // Multiline comment. Search for the end token or EOT.
 415                                         $end = strpos( $s, '*/', $pos + 2 );
 416                                         $skip = $end === false ? $length - $pos : $end - $pos + 2;
 417                                 }
 418                         }
 419                         if( $skip ) {
 420                                 // The semicolon insertion mechanism needs to know whether there was a newline
 421                                 // between two tokens, so record it now.
 422                                 if( !$newlineFound && strcspn( $s, "\r\n", $pos, $skip ) !== $skip ) {
 423                                         $newlineFound = true;
 424                                 }
 425                                 $pos += $skip;
 426                                 continue;
 427                         }
 428                         // Handle C++-style comments and html comments, which are treated as single line
 429                         // comments by the browser, regardless of whether the end tag is on the same line.
 430                         // Handle --> the same way, but only if it's at the beginning of the line
 431                         if( ( $ch === '/' && substr( $s, $pos, 2 ) === '//' )
 432                                 || ( $ch === '<' && substr( $s, $pos, 4 ) === '<!--' )
 433                                 || ( $ch === '-' && $newlineFound && substr( $s, $pos, 3 ) === '-->' )
 434                         ) {
 435                                 $pos += strcspn( $s, "\r\n", $pos );
 436                                 continue;
 437                         }
 438
 439                         // Find out which kind of token we're handling. $end will point past the end of it.
 440                         $end = $pos + 1;
 441                         // Handle string literals
 442                         if( $ch === "'" || $ch === '"' ) {
 443                                 // Search to the end of the string literal, skipping over backslash escapes
 444                                 $search = $ch . '\\';
 445                                 do{
 446                                         $end += strcspn( $s, $search, $end ) + 2;
 447                                 } while( $end - 2 < $length && $s[$end - 2] === '\\' );
 448                                 $end--;
 449                         // We have to distinguish between regexp literals and division operators
 450                         // A division operator is only possible in certain states
 451                         } elseif( $ch === '/' && !isset( $divStates[$state] ) ) {
 452                                 // Regexp literal
 453                                 for( ; ; ) {
 454                                         do{
 455                                                 // Skip until we find "/" (end of regexp), "\" (backslash escapes),
 456                                                 // or "[" (start of character classes).
 457                                                 $end += strcspn( $s, '/[\\', $end ) + 2;
 458                                                 // If backslash escape, keep searching...
 459                                         } while( $end - 2 < $length && $s[$end - 2] === '\\' );
 460                                         $end--;
 461                                         // If the end, stop here.
 462                                         if( $end - 1 >= $length || $s[$end - 1] === '/' ) {
 463                                                 break;
 464                                         }
 465                                         // (Implicit else), we must've found the start of a char class,
 466                                         // skip until we find "]" (end of char class), or "\" (backslash escape)
 467                                         do{
 468                                                 $end += strcspn( $s, ']\\', $end ) + 2;
 469                                                 // If backslash escape, keep searching...
 470                                         } while( $end - 2 < $length && $s[$end - 2] === '\\' );
 471                                         $end--;
 472                                 };
 473                                 // Search past the regexp modifiers (gi)
 474                                 while( $end < $length && ctype_alpha( $s[$end] ) ) {
 475                                         $end++;
 476                                 }
 477                         } elseif(
 478                                 $ch === '0'
 479                                 && ($pos + 1 < $length) && ($s[$pos + 1] === 'x' || $s[$pos + 1] === 'X' )
 480                         ) {
 481                                 // Hex numeric literal
 482                                 $end++; // x or X
 483                                 $len = strspn( $s, '0123456789ABCDEFabcdef', $end );
 484                                 if ( !$len ) {
 485                                         return self::parseError($s, $pos, 'Expected a hexadecimal number but found ' . substr( $s, $pos, 5 ) . '...' );
 486                                 }
 487                                 $end += $len;
 488                         } elseif(
 489                                 ctype_digit( $ch )
 490                                 || ( $ch === '.' && $pos + 1 < $length && ctype_digit( $s[$pos + 1] ) )
 491                         ) {
 492                                 $end += strspn( $s, '0123456789', $end );
 493                                 $decimal = strspn( $s, '.', $end );
 494                                 if ($decimal) {
 495                                         if ( $decimal > 2 ) {
 496                                                 return self::parseError($s, $end, 'The number has too many decimal points' );
 497                                         }
 498                                         $end += strspn( $s, '0123456789', $end + 1 ) + $decimal;
 499                                 }
 500                                 $exponent = strspn( $s, 'eE', $end );
 501                                 if( $exponent ) {
 502                                         if ( $exponent > 1 ) {
 503                                                 return self::parseError($s, $end, 'Number with several E' );
 504                                         }
 505                                         $end++;
 506
 507                                         // + sign is optional; - sign is required.
 508                                         $end += strspn( $s, '-+', $end );
 509                                         $len = strspn( $s, '0123456789', $end );
 510                                         if ( !$len ) {
 511                                                 return self::parseError($s, $pos, 'No decimal digits after e, how many zeroes should be added?' );
 512                                         }
 513                                         $end += $len;
 514                                 }
 515                         } elseif( isset( $opChars[$ch] ) ) {
 516                                 // Punctuation character. Search for the longest matching operator.
 517                                 while(
 518                                         $end < $length
 519                                         && isset( $tokenTypes[substr( $s, $pos, $end - $pos + 1 )] )
 520                                 ) {
 521                                         $end++;
 522                                 }
 523                         } else {
 524                                 // Identifier or reserved word. Search for the end by excluding whitespace and
 525                                 // punctuation.
 526                                 $end += strcspn( $s, " \t\n.;,=<>+-{}()[]?:*/%'\"!&|^~\xb\xc\r", $end );
 527                         }
 528
 529                         // Now get the token type from our type array
 530                         $token = substr( $s, $pos, $end - $pos ); // so $end - $pos == strlen( $token )
 531                         $type = isset( $tokenTypes[$token] ) ? $tokenTypes[$token] : self::TYPE_LITERAL;
 532
 533                         if( $newlineFound && isset( $semicolon[$state][$type] ) ) {
 534                                 // This token triggers the semicolon insertion mechanism of javascript. While we
 535                                 // could add the ; token here ourselves, keeping the newline has a few advantages.
 536                                 $out .= "\n";
 537                                 $state = self::STATEMENT;
 538                                 $lineLength = 0;
 539                         } elseif( $maxLineLength > 0 && $lineLength + $end - $pos > $maxLineLength &&
 540                                         !isset( $semicolon[$state][$type] ) && $type !== self::TYPE_INCR_OP )
 541                         {
 542                                 // This line would get too long if we added $token, so add a newline first.
 543                                 // Only do this if it won't trigger semicolon insertion and if it won't
 544                                 // put a postfix increment operator on its own line, which is illegal in js.
 545                                 $out .= "\n";
 546                                 $lineLength = 0;
 547                         // Check, whether we have to separate the token from the last one with whitespace
 548                         } elseif( !isset( $opChars[$last] ) && !isset( $opChars[$ch] ) ) {
 549                                 $out .= ' ';
 550                                 $lineLength++;
 551                         // Don't accidentally create ++, -- or // tokens
 552                         } elseif( $last === $ch && ( $ch === '+' || $ch === '-' || $ch === '/' ) ) {
 553                                 $out .= ' ';
 554                                 $lineLength++;
 555                         }
 556                         if (
 557                                 $type === self::TYPE_LITERAL
 558                                 && ( $token === 'true' || $token === 'false' )
 559                                 && ( $state === self::EXPRESSION || $state === self::PROPERTY_EXPRESSION )
 560                                 && $last !== '.'
 561                         ) {
 562                                 $token = ( $token === 'true' ) ? '!0' : '!1';
 563                         }
 564
 565                         $out .= $token;
 566                         $lineLength += $end - $pos; // += strlen( $token )
 567                         $last = $s[$end - 1];
 568                         $pos = $end;
 569                         $newlineFound = false;
 570
 571                         // Now that we have output our token, transition into the new state.
 572                         if( isset( $push[$state][$type] ) && count( $stack ) < self::STACK_LIMIT ) {
 573                                 $stack[] = $push[$state][$type];
 574                         }
 575                         if( $stack && isset( $pop[$state][$type] ) ) {
 576                                 $state = array_pop( $stack );
 577                         } elseif( isset( $goto[$state][$type] ) ) {
 578                                 $state = $goto[$state][$type];
 579                         }
 580                 }
 581                 return $out;
 582         }
 583
 584         static function parseError($fullJavascript, $position, $errorMsg) {
 585                 // TODO: Handle the error: trigger_error, throw exception, return false...
 586                 return false;
 587         }
 588 }