6 * @author Paul Copperman <paul.copperman@gmail.com>
9 * @license GPL-2.0-or-later
10 * @license LGPL-2.1-or-later
14 * This class is meant to safely minify javascript code, while leaving syntactically correct
15 * programs intact. Other libraries, such as JSMin require a certain coding style to work
16 * correctly. OTOH, libraries like jsminplus, that do parse the code correctly are rather
17 * slow, because they construct a complete parse tree before outputting the code minified.
18 * So this class is meant to allow arbitrary (but syntactically correct) input, while being
19 * fast enough to be used for on-the-fly minifying.
21 class JavaScriptMinifier
{
24 * The state machine is only necessary to decide whether to parse a slash as division
25 * operator or as regexp literal.
26 * States are named after the next expected item. We only distinguish states when the
27 * distinction is relevant for our purpose.
31 const PROPERTY_ASSIGNMENT
= 2;
33 const EXPRESSION_NO_NL
= 4; // only relevant for semicolon insertion
34 const EXPRESSION_OP
= 5;
35 const EXPRESSION_FUNC
= 6;
36 const EXPRESSION_TERNARY
= 7; // used to determine the role of a colon
37 const EXPRESSION_TERNARY_OP
= 8;
38 const EXPRESSION_TERNARY_FUNC
= 9;
39 const PAREN_EXPRESSION
= 10; // expression which is not on the top level
40 const PAREN_EXPRESSION_OP
= 11;
41 const PAREN_EXPRESSION_FUNC
= 12;
42 const PROPERTY_EXPRESSION
= 13; // expression which is within an object literal
43 const PROPERTY_EXPRESSION_OP
= 14;
44 const PROPERTY_EXPRESSION_FUNC
= 15;
47 const TYPE_UN_OP
= 1; // unary operators
48 const TYPE_INCR_OP
= 2; // ++ and --
49 const TYPE_BIN_OP
= 3; // binary operators
50 const TYPE_ADD_OP
= 4; // + and - which can be either unary or binary ops
51 const TYPE_HOOK
= 5; // ?
52 const TYPE_COLON
= 6; // :
53 const TYPE_COMMA
= 7; // ,
54 const TYPE_SEMICOLON
= 8; // ;
55 const TYPE_BRACE_OPEN
= 9; // {
56 const TYPE_BRACE_CLOSE
= 10; // }
57 const TYPE_PAREN_OPEN
= 11; // ( and [
58 const TYPE_PAREN_CLOSE
= 12; // ) and ]
59 const TYPE_RETURN
= 13; // keywords: break, continue, return, throw
60 const TYPE_IF
= 14; // keywords: catch, for, with, switch, while, if
61 const TYPE_DO
= 15; // keywords: case, var, finally, else, do, try
62 const TYPE_FUNC
= 16; // keywords: function
63 const TYPE_LITERAL
= 17; // all literals, identifiers and unrecognised tokens
65 // Sanity limit to avoid excessive memory usage
66 const STACK_LIMIT
= 1000;
69 * NOTE: This isn't a strict maximum. Longer lines will be produced when
70 * literals (e.g. quoted strings) longer than this are encountered
71 * or when required to guard against semicolon insertion.
73 const MAX_LINE_LENGTH
= 1000;
76 * Returns minified JavaScript code.
78 * @param string $s JavaScript code to minify
79 * @return String Minified code
81 public static function minify( $s ) {
82 // First we declare a few tables that contain our parsing rules
84 // $opChars : characters, which can be combined without whitespace in between them
114 // $tokenTypes : maps keywords and operators to their corresponding token type
116 '!' => self
::TYPE_UN_OP
,
117 '~' => self
::TYPE_UN_OP
,
118 'delete' => self
::TYPE_UN_OP
,
119 'new' => self
::TYPE_UN_OP
,
120 'typeof' => self
::TYPE_UN_OP
,
121 'void' => self
::TYPE_UN_OP
,
122 '++' => self
::TYPE_INCR_OP
,
123 '--' => self
::TYPE_INCR_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 '||' => self
::TYPE_BIN_OP
,
156 'in' => self
::TYPE_BIN_OP
,
157 'instanceof' => self
::TYPE_BIN_OP
,
158 '+' => self
::TYPE_ADD_OP
,
159 '-' => self
::TYPE_ADD_OP
,
160 '?' => self
::TYPE_HOOK
,
161 ':' => self
::TYPE_COLON
,
162 ',' => self
::TYPE_COMMA
,
163 ';' => self
::TYPE_SEMICOLON
,
164 '{' => self
::TYPE_BRACE_OPEN
,
165 '}' => self
::TYPE_BRACE_CLOSE
,
166 '(' => self
::TYPE_PAREN_OPEN
,
167 '[' => self
::TYPE_PAREN_OPEN
,
168 ')' => self
::TYPE_PAREN_CLOSE
,
169 ']' => self
::TYPE_PAREN_CLOSE
,
170 'break' => self
::TYPE_RETURN
,
171 'continue' => self
::TYPE_RETURN
,
172 'return' => self
::TYPE_RETURN
,
173 'throw' => self
::TYPE_RETURN
,
174 'catch' => self
::TYPE_IF
,
175 'for' => self
::TYPE_IF
,
176 'if' => self
::TYPE_IF
,
177 'switch' => self
::TYPE_IF
,
178 'while' => self
::TYPE_IF
,
179 'with' => self
::TYPE_IF
,
180 'case' => self
::TYPE_DO
,
181 'do' => self
::TYPE_DO
,
182 'else' => self
::TYPE_DO
,
183 'finally' => self
::TYPE_DO
,
184 'try' => self
::TYPE_DO
,
185 'var' => self
::TYPE_DO
,
186 'function' => self
::TYPE_FUNC
189 // $goto : This is the main table for our state machine. For every state/token pair
190 // the following state is defined. When no rule exists for a given pair,
191 // the state is left unchanged.
194 self
::TYPE_UN_OP
=> self
::EXPRESSION
,
195 self
::TYPE_INCR_OP
=> self
::EXPRESSION
,
196 self
::TYPE_ADD_OP
=> self
::EXPRESSION
,
197 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
,
198 self
::TYPE_RETURN
=> self
::EXPRESSION_NO_NL
,
199 self
::TYPE_IF
=> self
::CONDITION
,
200 self
::TYPE_FUNC
=> self
::CONDITION
,
201 self
::TYPE_LITERAL
=> self
::EXPRESSION_OP
204 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
206 self
::PROPERTY_ASSIGNMENT
=> [
207 self
::TYPE_COLON
=> self
::PROPERTY_EXPRESSION
,
208 self
::TYPE_BRACE_OPEN
=> self
::STATEMENT
210 self
::EXPRESSION
=> [
211 self
::TYPE_SEMICOLON
=> self
::STATEMENT
,
212 self
::TYPE_BRACE_OPEN
=> self
::PROPERTY_ASSIGNMENT
,
213 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
,
214 self
::TYPE_FUNC
=> self
::EXPRESSION_FUNC
,
215 self
::TYPE_LITERAL
=> self
::EXPRESSION_OP
217 self
::EXPRESSION_NO_NL
=> [
218 self
::TYPE_SEMICOLON
=> self
::STATEMENT
,
219 self
::TYPE_BRACE_OPEN
=> self
::PROPERTY_ASSIGNMENT
,
220 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
,
221 self
::TYPE_FUNC
=> self
::EXPRESSION_FUNC
,
222 self
::TYPE_LITERAL
=> self
::EXPRESSION_OP
224 self
::EXPRESSION_OP
=> [
225 self
::TYPE_BIN_OP
=> self
::EXPRESSION
,
226 self
::TYPE_ADD_OP
=> self
::EXPRESSION
,
227 self
::TYPE_HOOK
=> self
::EXPRESSION_TERNARY
,
228 self
::TYPE_COLON
=> self
::STATEMENT
,
229 self
::TYPE_COMMA
=> self
::EXPRESSION
,
230 self
::TYPE_SEMICOLON
=> self
::STATEMENT
,
231 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
233 self
::EXPRESSION_FUNC
=> [
234 self
::TYPE_BRACE_OPEN
=> self
::STATEMENT
236 self
::EXPRESSION_TERNARY
=> [
237 self
::TYPE_BRACE_OPEN
=> self
::PROPERTY_ASSIGNMENT
,
238 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
,
239 self
::TYPE_FUNC
=> self
::EXPRESSION_TERNARY_FUNC
,
240 self
::TYPE_LITERAL
=> self
::EXPRESSION_TERNARY_OP
242 self
::EXPRESSION_TERNARY_OP
=> [
243 self
::TYPE_BIN_OP
=> self
::EXPRESSION_TERNARY
,
244 self
::TYPE_ADD_OP
=> self
::EXPRESSION_TERNARY
,
245 self
::TYPE_HOOK
=> self
::EXPRESSION_TERNARY
,
246 self
::TYPE_COMMA
=> self
::EXPRESSION_TERNARY
,
247 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
249 self
::EXPRESSION_TERNARY_FUNC
=> [
250 self
::TYPE_BRACE_OPEN
=> self
::STATEMENT
252 self
::PAREN_EXPRESSION
=> [
253 self
::TYPE_BRACE_OPEN
=> self
::PROPERTY_ASSIGNMENT
,
254 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
,
255 self
::TYPE_FUNC
=> self
::PAREN_EXPRESSION_FUNC
,
256 self
::TYPE_LITERAL
=> self
::PAREN_EXPRESSION_OP
258 self
::PAREN_EXPRESSION_OP
=> [
259 self
::TYPE_BIN_OP
=> self
::PAREN_EXPRESSION
,
260 self
::TYPE_ADD_OP
=> self
::PAREN_EXPRESSION
,
261 self
::TYPE_HOOK
=> self
::PAREN_EXPRESSION
,
262 self
::TYPE_COLON
=> self
::PAREN_EXPRESSION
,
263 self
::TYPE_COMMA
=> self
::PAREN_EXPRESSION
,
264 self
::TYPE_SEMICOLON
=> self
::PAREN_EXPRESSION
,
265 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
267 self
::PAREN_EXPRESSION_FUNC
=> [
268 self
::TYPE_BRACE_OPEN
=> self
::STATEMENT
270 self
::PROPERTY_EXPRESSION
=> [
271 self
::TYPE_BRACE_OPEN
=> self
::PROPERTY_ASSIGNMENT
,
272 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
,
273 self
::TYPE_FUNC
=> self
::PROPERTY_EXPRESSION_FUNC
,
274 self
::TYPE_LITERAL
=> self
::PROPERTY_EXPRESSION_OP
276 self
::PROPERTY_EXPRESSION_OP
=> [
277 self
::TYPE_BIN_OP
=> self
::PROPERTY_EXPRESSION
,
278 self
::TYPE_ADD_OP
=> self
::PROPERTY_EXPRESSION
,
279 self
::TYPE_HOOK
=> self
::PROPERTY_EXPRESSION
,
280 self
::TYPE_COMMA
=> self
::PROPERTY_ASSIGNMENT
,
281 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION
283 self
::PROPERTY_EXPRESSION_FUNC
=> [
284 self
::TYPE_BRACE_OPEN
=> self
::STATEMENT
288 // $push : This table contains the rules for when to push a state onto the stack.
289 // The pushed state is the state to return to when the corresponding
290 // closing token is found
293 self
::TYPE_BRACE_OPEN
=> self
::STATEMENT
,
294 self
::TYPE_PAREN_OPEN
=> self
::EXPRESSION_OP
297 self
::TYPE_PAREN_OPEN
=> self
::STATEMENT
299 self
::PROPERTY_ASSIGNMENT
=> [
300 self
::TYPE_BRACE_OPEN
=> self
::PROPERTY_ASSIGNMENT
302 self
::EXPRESSION
=> [
303 self
::TYPE_BRACE_OPEN
=> self
::EXPRESSION_OP
,
304 self
::TYPE_PAREN_OPEN
=> self
::EXPRESSION_OP
306 self
::EXPRESSION_NO_NL
=> [
307 self
::TYPE_BRACE_OPEN
=> self
::EXPRESSION_OP
,
308 self
::TYPE_PAREN_OPEN
=> self
::EXPRESSION_OP
310 self
::EXPRESSION_OP
=> [
311 self
::TYPE_HOOK
=> self
::EXPRESSION
,
312 self
::TYPE_PAREN_OPEN
=> self
::EXPRESSION_OP
314 self
::EXPRESSION_FUNC
=> [
315 self
::TYPE_BRACE_OPEN
=> self
::EXPRESSION_OP
317 self
::EXPRESSION_TERNARY
=> [
318 self
::TYPE_BRACE_OPEN
=> self
::EXPRESSION_TERNARY_OP
,
319 self
::TYPE_PAREN_OPEN
=> self
::EXPRESSION_TERNARY_OP
321 self
::EXPRESSION_TERNARY_OP
=> [
322 self
::TYPE_HOOK
=> self
::EXPRESSION_TERNARY
,
323 self
::TYPE_PAREN_OPEN
=> self
::EXPRESSION_TERNARY_OP
325 self
::EXPRESSION_TERNARY_FUNC
=> [
326 self
::TYPE_BRACE_OPEN
=> self
::EXPRESSION_TERNARY_OP
328 self
::PAREN_EXPRESSION
=> [
329 self
::TYPE_BRACE_OPEN
=> self
::PAREN_EXPRESSION_OP
,
330 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION_OP
332 self
::PAREN_EXPRESSION_OP
=> [
333 self
::TYPE_PAREN_OPEN
=> self
::PAREN_EXPRESSION_OP
335 self
::PAREN_EXPRESSION_FUNC
=> [
336 self
::TYPE_BRACE_OPEN
=> self
::PAREN_EXPRESSION_OP
338 self
::PROPERTY_EXPRESSION
=> [
339 self
::TYPE_BRACE_OPEN
=> self
::PROPERTY_EXPRESSION_OP
,
340 self
::TYPE_PAREN_OPEN
=> self
::PROPERTY_EXPRESSION_OP
342 self
::PROPERTY_EXPRESSION_OP
=> [
343 self
::TYPE_PAREN_OPEN
=> self
::PROPERTY_EXPRESSION_OP
345 self
::PROPERTY_EXPRESSION_FUNC
=> [
346 self
::TYPE_BRACE_OPEN
=> self
::PROPERTY_EXPRESSION_OP
350 // $pop : Rules for when to pop a state from the stack
352 self
::STATEMENT
=> [ self
::TYPE_BRACE_CLOSE
=> true ],
353 self
::PROPERTY_ASSIGNMENT
=> [ self
::TYPE_BRACE_CLOSE
=> true ],
354 self
::EXPRESSION
=> [ self
::TYPE_BRACE_CLOSE
=> true ],
355 self
::EXPRESSION_NO_NL
=> [ self
::TYPE_BRACE_CLOSE
=> true ],
356 self
::EXPRESSION_OP
=> [ self
::TYPE_BRACE_CLOSE
=> true ],
357 self
::EXPRESSION_TERNARY_OP
=> [ self
::TYPE_COLON
=> true ],
358 self
::PAREN_EXPRESSION
=> [ self
::TYPE_PAREN_CLOSE
=> true ],
359 self
::PAREN_EXPRESSION_OP
=> [ self
::TYPE_PAREN_CLOSE
=> true ],
360 self
::PROPERTY_EXPRESSION
=> [ self
::TYPE_BRACE_CLOSE
=> true ],
361 self
::PROPERTY_EXPRESSION_OP
=> [ self
::TYPE_BRACE_CLOSE
=> true ]
364 // $semicolon : Rules for when a semicolon insertion is appropriate
366 self
::EXPRESSION_NO_NL
=> [
367 self
::TYPE_UN_OP
=> true,
368 self
::TYPE_INCR_OP
=> true,
369 self
::TYPE_ADD_OP
=> true,
370 self
::TYPE_BRACE_OPEN
=> true,
371 self
::TYPE_PAREN_OPEN
=> true,
372 self
::TYPE_RETURN
=> true,
373 self
::TYPE_IF
=> true,
374 self
::TYPE_DO
=> true,
375 self
::TYPE_FUNC
=> true,
376 self
::TYPE_LITERAL
=> true
378 self
::EXPRESSION_OP
=> [
379 self
::TYPE_UN_OP
=> true,
380 self
::TYPE_INCR_OP
=> true,
381 self
::TYPE_BRACE_OPEN
=> true,
382 self
::TYPE_RETURN
=> true,
383 self
::TYPE_IF
=> true,
384 self
::TYPE_DO
=> true,
385 self
::TYPE_FUNC
=> true,
386 self
::TYPE_LITERAL
=> true
390 // $divStates : Contains all states that can be followed by a division operator
392 self
::EXPRESSION_OP
=> true,
393 self
::EXPRESSION_TERNARY_OP
=> true,
394 self
::PAREN_EXPRESSION_OP
=> true,
395 self
::PROPERTY_EXPRESSION_OP
=> true
398 // Here's where the minifying takes place: Loop through the input, looking for tokens
399 // and output them to $out, taking actions to the above defined rules when appropriate.
402 $length = strlen( $s );
404 $newlineFound = true;
405 $state = self
::STATEMENT
;
407 $last = ';'; // Pretend that we have seen a semicolon yet
408 while ( $pos < $length ) {
409 // First, skip over any whitespace and multiline comments, recording whether we
410 // found any newline character
411 $skip = strspn( $s, " \t\n\r\xb\xc", $pos );
414 if ( $ch === '/' && substr( $s, $pos, 2 ) === '/*' ) {
415 // Multiline comment. Search for the end token or EOT.
416 $end = strpos( $s, '*/', $pos +
2 );
417 $skip = $end === false ?
$length - $pos : $end - $pos +
2;
421 // The semicolon insertion mechanism needs to know whether there was a newline
422 // between two tokens, so record it now.
423 if ( !$newlineFound && strcspn( $s, "\r\n", $pos, $skip ) !== $skip ) {
424 $newlineFound = true;
429 // Handle C++-style comments and html comments, which are treated as single line
430 // comments by the browser, regardless of whether the end tag is on the same line.
431 // Handle --> the same way, but only if it's at the beginning of the line
432 if ( ( $ch === '/' && substr( $s, $pos, 2 ) === '//' )
433 ||
( $ch === '<' && substr( $s, $pos, 4 ) === '<!--' )
434 ||
( $ch === '-' && $newlineFound && substr( $s, $pos, 3 ) === '-->' )
436 $pos +
= strcspn( $s, "\r\n", $pos );
440 // Find out which kind of token we're handling.
441 // Note: $end must point past the end of the current token
442 // so that `substr($s, $pos, $end - $pos)` would be the entire token.
443 // In order words, $end will be the offset of the last relevant character
444 // in the stream + 1, or simply put: The offset of the first character
445 // of any next token in the stream.
447 // Handle string literals
448 if ( $ch === "'" ||
$ch === '"' ) {
449 // Search to the end of the string literal, skipping over backslash escapes
450 $search = $ch . '\\';
452 // Speculatively add 2 to the end so that if we see a backslash,
453 // the next iteration will start 2 characters further (one for the
454 // backslash, one for the escaped character).
455 // We'll correct this outside the loop.
456 $end +
= strcspn( $s, $search, $end ) +
2;
457 // If the last character in our search for a quote or a backlash
458 // matched a backslash and we haven't reached the end, keep searching..
459 } while ( $end - 2 < $length && $s[$end - 2] === '\\' );
460 // Correction (1): Undo speculative add, keep only one (end of string literal)
462 if ( $end > $length ) {
463 // Correction (2): Loop wrongly assumed an end quote ended the search,
464 // but search ended because we've reached the end. Correct $end.
465 // TODO: This is invalid and should throw.
468 // We have to distinguish between regexp literals and division operators
469 // A division operator is only possible in certain states
470 } elseif ( $ch === '/' && !isset( $divStates[$state] ) ) {
473 // Search until we find "/" (end of regexp), "\" (backslash escapes),
474 // or "[" (start of character classes).
476 // Speculatively add 2 to ensure next iteration skips
477 // over backslash and escaped character.
478 // We'll correct this outside the loop.
479 $end +
= strcspn( $s, '/[\\', $end ) +
2;
480 // If backslash escape, keep searching...
481 } while ( $end - 2 < $length && $s[$end - 2] === '\\' );
482 // Correction (1): Undo speculative add, keep only one (end of regexp)
484 if ( $end > $length ) {
485 // Correction (2): Loop wrongly assumed end slash was seen
486 // String ended without end of regexp. Correct $end.
487 // TODO: This is invalid and should throw.
491 if ( $s[$end - 1] === '/' ) {
494 // (Implicit else), we must've found the start of a char class,
495 // skip until we find "]" (end of char class), or "\" (backslash escape)
497 // Speculatively add 2 for backslash escape.
498 // We'll substract one outside the loop.
499 $end +
= strcspn( $s, ']\\', $end ) +
2;
500 // If backslash escape, keep searching...
501 } while ( $end - 2 < $length && $s[$end - 2] === '\\' );
502 // Correction (1): Undo speculative add, keep only one (end of regexp)
504 if ( $end > $length ) {
505 // Correction (2): Loop wrongly assumed "]" was seen
506 // String ended without ending char class or regexp. Correct $end.
507 // TODO: This is invalid and should throw.
512 // Search past the regexp modifiers (gi)
513 while ( $end < $length && ctype_alpha( $s[$end] ) ) {
518 && ( $pos +
1 < $length ) && ( $s[$pos +
1] === 'x' ||
$s[$pos +
1] === 'X' )
520 // Hex numeric literal
522 $len = strspn( $s, '0123456789ABCDEFabcdef', $end );
524 return self
::parseError(
527 'Expected a hexadecimal number but found ' . substr( $s, $pos, 5 ) . '...'
533 ||
( $ch === '.' && $pos +
1 < $length && ctype_digit( $s[$pos +
1] ) )
535 $end +
= strspn( $s, '0123456789', $end );
536 $decimal = strspn( $s, '.', $end );
538 if ( $decimal > 2 ) {
539 return self
::parseError( $s, $end, 'The number has too many decimal points' );
541 $end +
= strspn( $s, '0123456789', $end +
1 ) +
$decimal;
543 $exponent = strspn( $s, 'eE', $end );
545 if ( $exponent > 1 ) {
546 return self
::parseError( $s, $end, 'Number with several E' );
550 // + sign is optional; - sign is required.
551 $end +
= strspn( $s, '-+', $end );
552 $len = strspn( $s, '0123456789', $end );
554 return self
::parseError(
557 'No decimal digits after e, how many zeroes should be added?'
562 } elseif ( isset( $opChars[$ch] ) ) {
563 // Punctuation character. Search for the longest matching operator.
566 && isset( $tokenTypes[substr( $s, $pos, $end - $pos +
1 )] )
571 // Identifier or reserved word. Search for the end by excluding whitespace and
573 $end +
= strcspn( $s, " \t\n.;,=<>+-{}()[]?:*/%'\"!&|^~\xb\xc\r", $end );
576 // Now get the token type from our type array
577 $token = substr( $s, $pos, $end - $pos ); // so $end - $pos == strlen( $token )
578 $type = $tokenTypes[$token] ?? self
::TYPE_LITERAL
;
580 if ( $newlineFound && isset( $semicolon[$state][$type] ) ) {
581 // This token triggers the semicolon insertion mechanism of javascript. While we
582 // could add the ; token here ourselves, keeping the newline has a few advantages.
584 $state = self
::STATEMENT
;
586 } elseif ( $lineLength +
$end - $pos > self
::MAX_LINE_LENGTH
&&
587 !isset( $semicolon[$state][$type] ) && $type !== self
::TYPE_INCR_OP
) {
588 // This line would get too long if we added $token, so add a newline first.
589 // Only do this if it won't trigger semicolon insertion and if it won't
590 // put a postfix increment operator on its own line, which is illegal in js.
593 // Check, whether we have to separate the token from the last one with whitespace
594 } elseif ( !isset( $opChars[$last] ) && !isset( $opChars[$ch] ) ) {
597 // Don't accidentally create ++, -- or // tokens
598 } elseif ( $last === $ch && ( $ch === '+' ||
$ch === '-' ||
$ch === '/' ) ) {
603 $type === self
::TYPE_LITERAL
604 && ( $token === 'true' ||
$token === 'false' )
605 && ( $state === self
::EXPRESSION ||
$state === self
::PROPERTY_EXPRESSION
)
608 $token = ( $token === 'true' ) ?
'!0' : '!1';
612 $lineLength +
= $end - $pos; // += strlen( $token )
613 $last = $s[$end - 1];
615 $newlineFound = false;
617 // Now that we have output our token, transition into the new state.
618 if ( isset( $push[$state][$type] ) && count( $stack ) < self
::STACK_LIMIT
) {
619 $stack[] = $push[$state][$type];
621 if ( $stack && isset( $pop[$state][$type] ) ) {
622 $state = array_pop( $stack );
623 } elseif ( isset( $goto[$state][$type] ) ) {
624 $state = $goto[$state][$type];
630 static function parseError( $fullJavascript, $position, $errorMsg ) {
631 // TODO: Handle the error: trigger_error, throw exception, return false...