Download as
Browse Code »

Commit 6f9fe6a0969ac16b347b83f386c0246bee421728

Authored by Edmar Moretti
1 parent f1e1a758
Exists in master and in 7 other branches composer, doc-root, docker, guia, licenca, readme, unmaintened

biblioteca packer movida para pacotes

Showing 5 changed files with 0 additions and 1602 deletions   Show diff stats
classesjs/packer/class.JavaScriptPacker.php
View file @f1e1a75
@@ -1,736 +0,0 @@ @@ -1,736 +0,0 @@
1 -<?php  
2 -/* 7 December 2006. version 1.0  
3 - *  
4 - * This is the php version of the Dean Edwards JavaScript 's Packer,  
5 - * Based on :  
6 - *  
7 - * ParseMaster, version 1.0.2 (2005-08-19) Copyright 2005, Dean Edwards  
8 - * a multi-pattern parser.  
9 - * KNOWN BUG: erroneous behavior when using escapeChar with a replacement  
10 - * value that is a function  
11 - *  
12 - * packer, version 2.0.2 (2005-08-19) Copyright 2004-2005, Dean Edwards  
13 - *  
14 - * License: http://creativecommons.org/licenses/LGPL/2.1/  
15 - *  
16 - * Ported to PHP by Nicolas Martin.  
17 - *  
18 - * ----------------------------------------------------------------------  
19 - *  
20 - * examples of usage :  
21 - * $myPacker = new JavaScriptPacker($script, 62, true, false);  
22 - * $packed = $myPacker->pack();  
23 - *  
24 - * or  
25 - *  
26 - * $myPacker = new JavaScriptPacker($script, 'Normal', true, false);  
27 - * $packed = $myPacker->pack();  
28 - *  
29 - * or (default values)  
30 - *  
31 - * $myPacker = new JavaScriptPacker($script);  
32 - * $packed = $myPacker->pack();  
33 - *  
34 - *  
35 - * params of the constructor :  
36 - * $script: the JavaScript to pack, string.  
37 - * $encoding: level of encoding, int or string :  
38 - * 0,10,62,95 or 'None', 'Numeric', 'Normal', 'High ASCII'.  
39 - * default: 62.  
40 - * $fastDecode: include the fast decoder in the packed result, boolean.  
41 - * default : true.  
42 - * $specialChars: if you are flagged your private and local variables  
43 - * in the script, boolean.  
44 - * default: false.  
45 - *  
46 - * The pack() method return the compressed JavasScript, as a string.  
47 - *  
48 - * see http://dean.edwards.name/packer/usage/ for more information.  
49 - *  
50 - * Notes :  
51 - * # need PHP 5 . Tested with PHP 5.1.2  
52 - *  
53 - * # The packed result may be different than with the Dean Edwards  
54 - * version, but with the same length. The reason is that the PHP  
55 - * function usort to sort array don't necessarily preserve the  
56 - * original order of two equal member. The Javascript sort function  
57 - * in fact preserve this order (but that's not require by the  
58 - * ECMAScript standard). So the encoded keywords order can be  
59 - * different in the two results.  
60 - *  
61 - * # Be careful with the 'High ASCII' Level encoding if you use  
62 - * UTF-8 in your files...  
63 - */  
64 -  
65 -  
66 -class JavaScriptPacker {  
67 - // constants  
68 - const IGNORE = '$1';  
69 -  
70 - // validate parameters  
71 - private $_script = '';  
72 - private $_encoding = 62;  
73 - private $_fastDecode = true;  
74 - private $_specialChars = false;  
75 -  
76 - private $LITERAL_ENCODING = array(  
77 - 'None' => 0,  
78 - 'Numeric' => 10,  
79 - 'Normal' => 62,  
80 - 'High ASCII' => 95  
81 - );  
82 -  
83 - public function __construct($_script, $_encoding = 62, $_fastDecode = true, $_specialChars = false)  
84 - {  
85 - $this->_script = $_script . "\n";  
86 - if (array_key_exists($_encoding, $this->LITERAL_ENCODING))  
87 - $_encoding = $this->LITERAL_ENCODING[$_encoding];  
88 - $this->_encoding = min((int)$_encoding, 95);  
89 - $this->_fastDecode = $_fastDecode;  
90 - $this->_specialChars = $_specialChars;  
91 - }  
92 -  
93 - public function pack() {  
94 - $this->_addParser('_basicCompression');  
95 - if ($this->_specialChars)  
96 - $this->_addParser('_encodeSpecialChars');  
97 - if ($this->_encoding)  
98 - $this->_addParser('_encodeKeywords');  
99 -  
100 - // go!  
101 - return $this->_pack($this->_script);  
102 - }  
103 -  
104 - // apply all parsing routines  
105 - private function _pack($script) {  
106 - for ($i = 0; isset($this->_parsers[$i]); $i++) {  
107 - $script = call_user_func(array(&$this,$this->_parsers[$i]), $script);  
108 - }  
109 - return $script;  
110 - }  
111 -  
112 - // keep a list of parsing functions, they'll be executed all at once  
113 - private $_parsers = array();  
114 - private function _addParser($parser) {  
115 - $this->_parsers[] = $parser;  
116 - }  
117 -  
118 - // zero encoding - just removal of white space and comments  
119 - private function _basicCompression($script) {  
120 - $parser = new ParseMaster();  
121 - // make safe  
122 - $parser->escapeChar = '\\';  
123 - // protect strings  
124 - $parser->add('/\'[^\'\\n\\r]*\'/', self::IGNORE);  
125 - $parser->add('/"[^"\\n\\r]*"/', self::IGNORE);  
126 - // remove comments  
127 - $parser->add('/\\/\\/[^\\n\\r]*[\\n\\r]/', ' ');  
128 - $parser->add('/\\/\\*[^*]*\\*+([^\\/][^*]*\\*+)*\\//', ' ');  
129 - // protect regular expressions  
130 - $parser->add('/\\s+(\\/[^\\/\\n\\r\\*][^\\/\\n\\r]*\\/g?i?)/', '$2'); // IGNORE  
131 - $parser->add('/[^\\w\\x24\\/\'"*)\\?:]\\/[^\\/\\n\\r\\*][^\\/\\n\\r]*\\/g?i?/', self::IGNORE);  
132 - // remove: ;;; doSomething();  
133 - if ($this->_specialChars) $parser->add('/;;;[^\\n\\r]+[\\n\\r]/');  
134 - // remove redundant semi-colons  
135 - $parser->add('/\\(;;\\)/', self::IGNORE); // protect for (;;) loops  
136 - $parser->add('/;+\\s*([};])/', '$2');  
137 - // apply the above  
138 - $script = $parser->exec($script);  
139 -  
140 - // remove white-space  
141 - $parser->add('/(\\b|\\x24)\\s+(\\b|\\x24)/', '$2 $3');  
142 - $parser->add('/([+\\-])\\s+([+\\-])/', '$2 $3');  
143 - $parser->add('/\\s+/', '');  
144 - // done  
145 - return $parser->exec($script);  
146 - }  
147 -  
148 - private function _encodeSpecialChars($script) {  
149 - $parser = new ParseMaster();  
150 - // replace: $name -> n, $$name -> na  
151 - $parser->add('/((\\x24+)([a-zA-Z$_]+))(\\d*)/',  
152 - array('fn' => '_replace_name')  
153 - );  
154 - // replace: _name -> _0, double-underscore (__name) is ignored  
155 - $regexp = '/\\b_[A-Za-z\\d]\\w*/';  
156 - // build the word list  
157 - $keywords = $this->_analyze($script, $regexp, '_encodePrivate');  
158 - // quick ref  
159 - $encoded = $keywords['encoded'];  
160 -  
161 - $parser->add($regexp,  
162 - array(  
163 - 'fn' => '_replace_encoded',  
164 - 'data' => $encoded  
165 - )  
166 - );  
167 - return $parser->exec($script);  
168 - }  
169 -  
170 - private function _encodeKeywords($script) {  
171 - // escape high-ascii values already in the script (i.e. in strings)  
172 - if ($this->_encoding > 62)  
173 - $script = $this->_escape95($script);  
174 - // create the parser  
175 - $parser = new ParseMaster();  
176 - $encode = $this->_getEncoder($this->_encoding);  
177 - // for high-ascii, don't encode single character low-ascii  
178 - $regexp = ($this->_encoding > 62) ? '/\\w\\w+/' : '/\\w+/';  
179 - // build the word list  
180 - $keywords = $this->_analyze($script, $regexp, $encode);  
181 - $encoded = $keywords['encoded'];  
182 -  
183 - // encode  
184 - $parser->add($regexp,  
185 - array(  
186 - 'fn' => '_replace_encoded',  
187 - 'data' => $encoded  
188 - )  
189 - );  
190 - if (empty($script)) return $script;  
191 - else {  
192 - //$res = $parser->exec($script);  
193 - //$res = $this->_bootStrap($res, $keywords);  
194 - //return $res;  
195 - return $this->_bootStrap($parser->exec($script), $keywords);  
196 - }  
197 - }  
198 -  
199 - private function _analyze($script, $regexp, $encode) {  
200 - // analyse  
201 - // retreive all words in the script  
202 - $all = array();  
203 - preg_match_all($regexp, $script, $all);  
204 - $_sorted = array(); // list of words sorted by frequency  
205 - $_encoded = array(); // dictionary of word->encoding  
206 - $_protected = array(); // instances of "protected" words  
207 - $all = $all[0]; // simulate the javascript comportement of global match  
208 - if (!empty($all)) {  
209 - $unsorted = array(); // same list, not sorted  
210 - $protected = array(); // "protected" words (dictionary of word->"word")  
211 - $value = array(); // dictionary of charCode->encoding (eg. 256->ff)  
212 - $this->_count = array(); // word->count  
213 - $i = count($all); $j = 0; //$word = null;  
214 - // count the occurrences - used for sorting later  
215 - do {  
216 - --$i;  
217 - $word = '$' . $all[$i];  
218 - if (!isset($this->_count[$word])) {  
219 - $this->_count[$word] = 0;  
220 - $unsorted[$j] = $word;  
221 - // make a dictionary of all of the protected words in this script  
222 - // these are words that might be mistaken for encoding  
223 - //if (is_string($encode) && method_exists($this, $encode))  
224 - $values[$j] = call_user_func(array(&$this, $encode), $j);  
225 - $protected['$' . $values[$j]] = $j++;  
226 - }  
227 - // increment the word counter  
228 - $this->_count[$word]++;  
229 - } while ($i > 0);  
230 - // prepare to sort the word list, first we must protect  
231 - // words that are also used as codes. we assign them a code  
232 - // equivalent to the word itself.  
233 - // e.g. if "do" falls within our encoding range  
234 - // then we store keywords["do"] = "do";  
235 - // this avoids problems when decoding  
236 - $i = count($unsorted);  
237 - do {  
238 - $word = $unsorted[--$i];  
239 - if (isset($protected[$word]) /*!= null*/) {  
240 - $_sorted[$protected[$word]] = substr($word, 1);  
241 - $_protected[$protected[$word]] = true;  
242 - $this->_count[$word] = 0;  
243 - }  
244 - } while ($i);  
245 -  
246 - // sort the words by frequency  
247 - // Note: the javascript and php version of sort can be different :  
248 - // in php manual, usort :  
249 - // " If two members compare as equal,  
250 - // their order in the sorted array is undefined."  
251 - // so the final packed script is different of the Dean's javascript version  
252 - // but equivalent.  
253 - // the ECMAscript standard does not guarantee this behaviour,  
254 - // and thus not all browsers (e.g. Mozilla versions dating back to at  
255 - // least 2003) respect this.  
256 - usort($unsorted, array(&$this, '_sortWords'));  
257 - $j = 0;  
258 - // because there are "protected" words in the list  
259 - // we must add the sorted words around them  
260 - do {  
261 - if (!isset($_sorted[$i]))  
262 - $_sorted[$i] = substr($unsorted[$j++], 1);  
263 - $_encoded[$_sorted[$i]] = $values[$i];  
264 - } while (++$i < count($unsorted));  
265 - }  
266 - return array(  
267 - 'sorted' => $_sorted,  
268 - 'encoded' => $_encoded,  
269 - 'protected' => $_protected);  
270 - }  
271 -  
272 - private $_count = array();  
273 - private function _sortWords($match1, $match2) {  
274 - return $this->_count[$match2] - $this->_count[$match1];  
275 - }  
276 -  
277 - // build the boot function used for loading and decoding  
278 - private function _bootStrap($packed, $keywords) {  
279 - $ENCODE = $this->_safeRegExp('$encode\\($count\\)');  
280 -  
281 - // $packed: the packed script  
282 - $packed = "'" . $this->_escape($packed) . "'";  
283 -  
284 - // $ascii: base for encoding  
285 - $ascii = min(count($keywords['sorted']), $this->_encoding);  
286 - if ($ascii == 0) $ascii = 1;  
287 -  
288 - // $count: number of words contained in the script  
289 - $count = count($keywords['sorted']);  
290 -  
291 - // $keywords: list of words contained in the script  
292 - foreach ($keywords['protected'] as $i=>$value) {  
293 - $keywords['sorted'][$i] = '';  
294 - }  
295 - // convert from a string to an array  
296 - ksort($keywords['sorted']);  
297 - $keywords = "'" . implode('|',$keywords['sorted']) . "'.split('|')";  
298 -  
299 - $encode = ($this->_encoding > 62) ? '_encode95' : $this->_getEncoder($ascii);  
300 - $encode = $this->_getJSFunction($encode);  
301 - $encode = preg_replace('/_encoding/','$ascii', $encode);  
302 - $encode = preg_replace('/arguments\\.callee/','$encode', $encode);  
303 - $inline = '\\$count' . ($ascii > 10 ? '.toString(\\$ascii)' : '');  
304 -  
305 - // $decode: code snippet to speed up decoding  
306 - if ($this->_fastDecode) {  
307 - // create the decoder  
308 - $decode = $this->_getJSFunction('_decodeBody');  
309 - if ($this->_encoding > 62)  
310 - $decode = preg_replace('/\\\\w/', '[\\xa1-\\xff]', $decode);  
311 - // perform the encoding inline for lower ascii values  
312 - elseif ($ascii < 36)  
313 - $decode = preg_replace($ENCODE, $inline, $decode);  
314 - // special case: when $count==0 there are no keywords. I want to keep  
315 - // the basic shape of the unpacking funcion so i'll frig the code...  
316 - if ($count == 0)  
317 - $decode = preg_replace($this->_safeRegExp('($count)\\s*=\\s*1'), '$1=0', $decode, 1);  
318 - }  
319 -  
320 - // boot function  
321 - $unpack = $this->_getJSFunction('_unpack');  
322 - if ($this->_fastDecode) {  
323 - // insert the decoder  
324 - $this->buffer = $decode;  
325 - $unpack = preg_replace_callback('/\\{/', array(&$this, '_insertFastDecode'), $unpack, 1);  
326 - }  
327 - $unpack = preg_replace('/"/', "'", $unpack);  
328 - if ($this->_encoding > 62) { // high-ascii  
329 - // get rid of the word-boundaries for regexp matches  
330 - $unpack = preg_replace('/\'\\\\\\\\b\'\s*\\+|\\+\s*\'\\\\\\\\b\'/', '', $unpack);  
331 - }  
332 - if ($ascii > 36 || $this->_encoding > 62 || $this->_fastDecode) {  
333 - // insert the encode function  
334 - $this->buffer = $encode;  
335 - $unpack = preg_replace_callback('/\\{/', array(&$this, '_insertFastEncode'), $unpack, 1);  
336 - } else {  
337 - // perform the encoding inline  
338 - $unpack = preg_replace($ENCODE, $inline, $unpack);  
339 - }  
340 - // pack the boot function too  
341 - $unpackPacker = new JavaScriptPacker($unpack, 0, false, true);  
342 - $unpack = $unpackPacker->pack();  
343 -  
344 - // arguments  
345 - $params = array($packed, $ascii, $count, $keywords);  
346 - if ($this->_fastDecode) {  
347 - $params[] = 0;  
348 - $params[] = '{}';  
349 - }  
350 - $params = implode(',', $params);  
351 -  
352 - // the whole thing  
353 - return 'eval(' . $unpack . '(' . $params . "))\n";  
354 - }  
355 -  
356 - private $buffer;  
357 - private function _insertFastDecode($match) {  
358 - return '{' . $this->buffer . ';';  
359 - }  
360 - private function _insertFastEncode($match) {  
361 - return '{$encode=' . $this->buffer . ';';  
362 - }  
363 -  
364 - // mmm.. ..which one do i need ??  
365 - private function _getEncoder($ascii) {  
366 - return $ascii > 10 ? $ascii > 36 ? $ascii > 62 ?  
367 - '_encode95' : '_encode62' : '_encode36' : '_encode10';  
368 - }  
369 -  
370 - // zero encoding  
371 - // characters: 0123456789  
372 - private function _encode10($charCode) {  
373 - return $charCode;  
374 - }  
375 -  
376 - // inherent base36 support  
377 - // characters: 0123456789abcdefghijklmnopqrstuvwxyz  
378 - private function _encode36($charCode) {  
379 - return base_convert($charCode, 10, 36);  
380 - }  
381 -  
382 - // hitch a ride on base36 and add the upper case alpha characters  
383 - // characters: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ  
384 - private function _encode62($charCode) {  
385 - $res = '';  
386 - if ($charCode >= $this->_encoding) {  
387 - $res = $this->_encode62((int)($charCode / $this->_encoding));  
388 - }  
389 - $charCode = $charCode % $this->_encoding;  
390 -  
391 - if ($charCode > 35)  
392 - return $res . chr($charCode + 29);  
393 - else  
394 - return $res . base_convert($charCode, 10, 36);  
395 - }  
396 -  
397 - // use high-ascii values  
398 - // characters: ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþ  
399 - private function _encode95($charCode) {  
400 - $res = '';  
401 - if ($charCode >= $this->_encoding)  
402 - $res = $this->_encode95($charCode / $this->_encoding);  
403 -  
404 - return $res . chr(($charCode % $this->_encoding) + 161);  
405 - }  
406 -  
407 - private function _safeRegExp($string) {  
408 - return '/'.preg_replace('/\$/', '\\\$', $string).'/';  
409 - }  
410 -  
411 - private function _encodePrivate($charCode) {  
412 - return "_" . $charCode;  
413 - }  
414 -  
415 - // protect characters used by the parser  
416 - private function _escape($script) {  
417 - return preg_replace('/([\\\\\'])/', '\\\$1', $script);  
418 - }  
419 -  
420 - // protect high-ascii characters already in the script  
421 - private function _escape95($script) {  
422 - return preg_replace_callback(  
423 - '/[\\xa1-\\xff]/',  
424 - array(&$this, '_escape95Bis'),  
425 - $script  
426 - );  
427 - }  
428 - private function _escape95Bis($match) {  
429 - return '\x'.((string)dechex(ord($match)));  
430 - }  
431 -  
432 -  
433 - private function _getJSFunction($aName) {  
434 - if (defined('self::JSFUNCTION'.$aName))  
435 - return constant('self::JSFUNCTION'.$aName);  
436 - else  
437 - return '';  
438 - }  
439 -  
440 - // JavaScript Functions used.  
441 - // Note : In Dean's version, these functions are converted  
442 - // with 'String(aFunctionName);'.  
443 - // This internal conversion complete the original code, ex :  
444 - // 'while (aBool) anAction();' is converted to  
445 - // 'while (aBool) { anAction(); }'.  
446 - // The JavaScript functions below are corrected.  
447 -  
448 - // unpacking function - this is the boot strap function  
449 - // data extracted from this packing routine is passed to  
450 - // this function when decoded in the target  
451 - // NOTE ! : without the ';' final.  
452 - const JSFUNCTION_unpack =  
453 -  
454 -'function($packed, $ascii, $count, $keywords, $encode, $decode) {  
455 - while ($count--) {  
456 - if ($keywords[$count]) {  
457 - $packed = $packed.replace(new RegExp(\'\\\\b\' + $encode($count) + \'\\\\b\', \'g\'), $keywords[$count]);  
458 - }  
459 - }  
460 - return $packed;  
461 -}';  
462 -/*  
463 -'function($packed, $ascii, $count, $keywords, $encode, $decode) {  
464 - while ($count--)  
465 - if ($keywords[$count])  
466 - $packed = $packed.replace(new RegExp(\'\\\\b\' + $encode($count) + \'\\\\b\', \'g\'), $keywords[$count]);  
467 - return $packed;  
468 -}';  
469 -*/  
470 -  
471 - // code-snippet inserted into the unpacker to speed up decoding  
472 - const JSFUNCTION_decodeBody =  
473 -//_decode = function() {  
474 -// does the browser support String.replace where the  
475 -// replacement value is a function?  
476 -  
477 -' if (!\'\'.replace(/^/, String)) {  
478 - // decode all the values we need  
479 - while ($count--) {  
480 - $decode[$encode($count)] = $keywords[$count] || $encode($count);  
481 - }  
482 - // global replacement function  
483 - $keywords = [function ($encoded) {return $decode[$encoded]}];  
484 - // generic match  
485 - $encode = function () {return \'\\\\w+\'};  
486 - // reset the loop counter - we are now doing a global replace  
487 - $count = 1;  
488 - }  
489 -';  
490 -//};  
491 -/*  
492 -' if (!\'\'.replace(/^/, String)) {  
493 - // decode all the values we need  
494 - while ($count--) $decode[$encode($count)] = $keywords[$count] || $encode($count);  
495 - // global replacement function  
496 - $keywords = [function ($encoded) {return $decode[$encoded]}];  
497 - // generic match  
498 - $encode = function () {return\'\\\\w+\'};  
499 - // reset the loop counter - we are now doing a global replace  
500 - $count = 1;  
501 - }';  
502 -*/  
503 -  
504 - // zero encoding  
505 - // characters: 0123456789  
506 - const JSFUNCTION_encode10 =  
507 -'function($charCode) {  
508 - return $charCode;  
509 -}';//;';  
510 -  
511 - // inherent base36 support  
512 - // characters: 0123456789abcdefghijklmnopqrstuvwxyz  
513 - const JSFUNCTION_encode36 =  
514 -'function($charCode) {  
515 - return $charCode.toString(36);  
516 -}';//;';  
517 -  
518 - // hitch a ride on base36 and add the upper case alpha characters  
519 - // characters: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ  
520 - const JSFUNCTION_encode62 =  
521 -'function($charCode) {  
522 - return ($charCode < _encoding ? \'\' : arguments.callee(parseInt($charCode / _encoding))) +  
523 - (($charCode = $charCode % _encoding) > 35 ? String.fromCharCode($charCode + 29) : $charCode.toString(36));  
524 -}';  
525 -  
526 - // use high-ascii values  
527 - // characters: ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþ  
528 - const JSFUNCTION_encode95 =  
529 -'function($charCode) {  
530 - return ($charCode < _encoding ? \'\' : arguments.callee($charCode / _encoding)) +  
531 - String.fromCharCode($charCode % _encoding + 161);  
532 -}';  
533 -  
534 -}  
535 -  
536 -  
537 -class ParseMaster {  
538 - public $ignoreCase = false;  
539 - public $escapeChar = '';  
540 -  
541 - // constants  
542 - const EXPRESSION = 0;  
543 - const REPLACEMENT = 1;  
544 - const LENGTH = 2;  
545 -  
546 - // used to determine nesting levels  
547 - private $GROUPS = '/\\(/';//g  
548 - private $SUB_REPLACE = '/\\$\\d/';  
549 - private $INDEXED = '/^\\$\\d+$/';  
550 - private $TRIM = '/([\'"])\\1\\.(.*)\\.\\1\\1$/';  
551 - private $ESCAPE = '/\\\./';//g  
552 - private $QUOTE = '/\'/';  
553 - private $DELETED = '/\\x01[^\\x01]*\\x01/';//g  
554 -  
555 - public function add($expression, $replacement = '') {  
556 - // count the number of sub-expressions  
557 - // - add one because each pattern is itself a sub-expression  
558 - $length = 1 + preg_match_all($this->GROUPS, $this->_internalEscape((string)$expression), $out);  
559 -  
560 - // treat only strings $replacement  
561 - if (is_string($replacement)) {  
562 - // does the pattern deal with sub-expressions?  
563 - if (preg_match($this->SUB_REPLACE, $replacement)) {  
564 - // a simple lookup? (e.g. "$2")  
565 - if (preg_match($this->INDEXED, $replacement)) {  
566 - // store the index (used for fast retrieval of matched strings)  
567 - $replacement = (int)(substr($replacement, 1)) - 1;  
568 - } else { // a complicated lookup (e.g. "Hello $2 $1")  
569 - // build a function to do the lookup  
570 - $quote = preg_match($this->QUOTE, $this->_internalEscape($replacement))  
571 - ? '"' : "'";  
572 - $replacement = array(  
573 - 'fn' => '_backReferences',  
574 - 'data' => array(  
575 - 'replacement' => $replacement,  
576 - 'length' => $length,  
577 - 'quote' => $quote  
578 - )  
579 - );  
580 - }  
581 - }  
582 - }  
583 - // pass the modified arguments  
584 - if (!empty($expression)) $this->_add($expression, $replacement, $length);  
585 - else $this->_add('/^$/', $replacement, $length);  
586 - }  
587 -  
588 - public function exec($string) {  
589 - // execute the global replacement  
590 - $this->_escaped = array();  
591 -  
592 - // simulate the _patterns.toSTring of Dean  
593 - $regexp = '/';  
594 - foreach ($this->_patterns as $reg) {  
595 - $regexp .= '(' . substr($reg[self::EXPRESSION], 1, -1) . ')|';  
596 - }  
597 - $regexp = substr($regexp, 0, -1) . '/';  
598 - $regexp .= ($this->ignoreCase) ? 'i' : '';  
599 -  
600 - $string = $this->_escape($string, $this->escapeChar);  
601 - $string = preg_replace_callback(  
602 - $regexp,  
603 - array(  
604 - &$this,  
605 - '_replacement'  
606 - ),  
607 - $string  
608 - );  
609 - $string = $this->_unescape($string, $this->escapeChar);  
610 -  
611 - return preg_replace($this->DELETED, '', $string);  
612 - }  
613 -  
614 - public function reset() {  
615 - // clear the patterns collection so that this object may be re-used  
616 - $this->_patterns = array();  
617 - }  
618 -  
619 - // private  
620 - private $_escaped = array(); // escaped characters  
621 - private $_patterns = array(); // patterns stored by index  
622 -  
623 - // create and add a new pattern to the patterns collection  
624 - private function _add() {  
625 - $arguments = func_get_args();  
626 - $this->_patterns[] = $arguments;  
627 - }  
628 -  
629 - // this is the global replace function (it's quite complicated)  
630 - private function _replacement($arguments) {  
631 - if (empty($arguments)) return '';  
632 -  
633 - $i = 1; $j = 0;  
634 - // loop through the patterns  
635 - while (isset($this->_patterns[$j])) {  
636 - $pattern = $this->_patterns[$j++];  
637 - // do we have a result?  
638 - if (isset($arguments[$i]) && ($arguments[$i] != '')) {  
639 - $replacement = $pattern[self::REPLACEMENT];  
640 -  
641 - if (is_array($replacement) && isset($replacement['fn'])) {  
642 -  
643 - if (isset($replacement['data'])) $this->buffer = $replacement['data'];  
644 - return call_user_func(array(&$this, $replacement['fn']), $arguments, $i);  
645 -  
646 - } elseif (is_int($replacement)) {  
647 - return $arguments[$replacement + $i];  
648 -  
649 - }  
650 - $delete = ($this->escapeChar == '' ||  
651 - strpos($arguments[$i], $this->escapeChar) === false)  
652 - ? '' : "\x01" . $arguments[$i] . "\x01";  
653 - return $delete . $replacement;  
654 -  
655 - // skip over references to sub-expressions  
656 - } else {  
657 - $i += $pattern[self::LENGTH];  
658 - }  
659 - }  
660 - }  
661 -  
662 - private function _backReferences($match, $offset) {  
663 - $replacement = $this->buffer['replacement'];  
664 - $quote = $this->buffer['quote'];  
665 - $i = $this->buffer['length'];  
666 - while ($i) {  
667 - $replacement = str_replace('$'.$i--, $match[$offset + $i], $replacement);  
668 - }  
669 - return $replacement;  
670 - }  
671 -  
672 - private function _replace_name($match, $offset){  
673 - $length = strlen($match[$offset + 2]);  
674 - $start = $length - max($length - strlen($match[$offset + 3]), 0);  
675 - return substr($match[$offset + 1], $start, $length) . $match[$offset + 4];  
676 - }  
677 -  
678 - private function _replace_encoded($match, $offset) {  
679 - return $this->buffer[$match[$offset]];  
680 - }  
681 -  
682 -  
683 - // php : we cannot pass additional data to preg_replace_callback,  
684 - // and we cannot use &$this in create_function, so let's go to lower level  
685 - private $buffer;  
686 -  
687 - // encode escaped characters  
688 - private function _escape($string, $escapeChar) {  
689 - if ($escapeChar) {  
690 - $this->buffer = $escapeChar;  
691 - return preg_replace_callback(  
692 - '/\\' . $escapeChar . '(.)' .'/',  
693 - array(&$this, '_escapeBis'),  
694 - $string  
695 - );  
696 -  
697 - } else {  
698 - return $string;  
699 - }  
700 - }  
701 - private function _escapeBis($match) {  
702 - $this->_escaped[] = $match[1];  
703 - return $this->buffer;  
704 - }  
705 -  
706 - // decode escaped characters  
707 - private function _unescape($string, $escapeChar) {  
708 - if ($escapeChar) {  
709 - $regexp = '/'.'\\'.$escapeChar.'/';  
710 - $this->buffer = array('escapeChar'=> $escapeChar, 'i' => 0);  
711 - return preg_replace_callback  
712 - (  
713 - $regexp,  
714 - array(&$this, '_unescapeBis'),  
715 - $string  
716 - );  
717 -  
718 - } else {  
719 - return $string;  
720 - }  
721 - }  
722 - private function _unescapeBis() {  
723 - if (!empty($this->_escaped[$this->buffer['i']])) {  
724 - $temp = $this->_escaped[$this->buffer['i']];  
725 - } else {  
726 - $temp = '';  
727 - }  
728 - $this->buffer['i']++;  
729 - return $this->buffer['escapeChar'] . $temp;  
730 - }  
731 -  
732 - private function _internalEscape($string) {  
733 - return preg_replace($this->ESCAPE, '', $string);  
734 - }  
735 -}  
736 -?>  
classesjs/packer/class.JavaScriptPacker.php4
View file @f1e1a75
@@ -1,732 +0,0 @@ @@ -1,732 +0,0 @@
1 -<?php  
2 -/* 7 December 2006. version 1.0  
3 - *  
4 - * This is the php version of the Dean Edwards JavaScript 's Packer,  
5 - * Based on :  
6 - *  
7 - * ParseMaster, version 1.0.2 (2005-08-19) Copyright 2005, Dean Edwards  
8 - * a multi-pattern parser.  
9 - * KNOWN BUG: erroneous behavior when using escapeChar with a replacement  
10 - * value that is a function  
11 - *  
12 - * packer, version 2.0.2 (2005-08-19) Copyright 2004-2005, Dean Edwards  
13 - *  
14 - * License: http://creativecommons.org/licenses/LGPL/2.1/  
15 - *  
16 - * Ported to PHP by Nicolas Martin.  
17 - * modified by Mark Fabrizio Jr. to work with php 4  
18 - *  
19 - * ----------------------------------------------------------------------  
20 - *  
21 - * examples of usage :  
22 - * $myPacker = new JavaScriptPacker($script, 62, true, false);  
23 - * $packed = $myPacker->pack();  
24 - *  
25 - * or  
26 - *  
27 - * $myPacker = new JavaScriptPacker($script, 'Normal', true, false);  
28 - * $packed = $myPacker->pack();  
29 - *  
30 - * or (default values)  
31 - *  
32 - * $myPacker = new JavaScriptPacker($script);  
33 - * $packed = $myPacker->pack();  
34 - *  
35 - *  
36 - * params of the constructor :  
37 - * $script: the JavaScript to pack, string.  
38 - * $encoding: level of encoding, int or string :  
39 - * 0,10,62,95 or 'None', 'Numeric', 'Normal', 'High ASCII'.  
40 - * default: 62.  
41 - * $fastDecode: include the fast decoder in the packed result, boolean.  
42 - * default : true.  
43 - * $specialChars: if you are flagged your private and local variables  
44 - * in the script, boolean.  
45 - * default: false.  
46 - *  
47 - * The pack() method return the compressed JavasScript, as a string.  
48 - *  
49 - * see http://dean.edwards.name/packer/usage/ for more information.  
50 - *  
51 - * Notes :  
52 - * # [del]need PHP 5 . Tested with PHP 5.1.2[/del]  
53 - * this is a modified version for PHP 4  
54 - *  
55 - * # The packed result may be different than with the Dean Edwards  
56 - * version, but with the same length. The reason is that the PHP  
57 - * function usort to sort array don't necessarily preserve the  
58 - * original order of two equal member. The Javascript sort function  
59 - * in fact preserve this order (but that's not require by the  
60 - * ECMAScript standard). So the encoded keywords order can be  
61 - * different in the two results.  
62 - *  
63 - * # Be careful with the 'High ASCII' Level encoding if you use  
64 - * UTF-8 in your files...  
65 - */  
66 -  
67 - /*  
68 - * modified by Mark Fabrizio Jr. to work with php 4  
69 - */  
70 -  
71 -  
72 -class JavaScriptPacker {  
73 - var $IGNORE = '$1';  
74 -  
75 - // validate parameters  
76 - var $_script = '';  
77 - var $_encoding = 62;  
78 - var $_fastDecode = true;  
79 - var $_specialChars = false;  
80 -  
81 - var $LITERAL_ENCODING = array(  
82 - 'None' => 0,  
83 - 'Numeric' => 10,  
84 - 'Normal' => 62,  
85 - 'High ASCII' => 95  
86 - );  
87 -  
88 - function JavaScriptPacker($_script, $_encoding = 62, $_fastDecode = true, $_specialChars = false)  
89 - {  
90 - $this->_script = $_script . "\n";  
91 - if (array_key_exists($_encoding, $this->LITERAL_ENCODING))  
92 - $_encoding = $this->LITERAL_ENCODING[$_encoding];  
93 - $this->_encoding = min((int)$_encoding, 95);  
94 - $this->_fastDecode = $_fastDecode;  
95 - $this->_specialChars = $_specialChars;  
96 - }  
97 -  
98 - function pack() {  
99 - $this->_addParser('_basicCompression');  
100 - if ($this->_specialChars)  
101 - $this->_addParser('_encodeSpecialChars');  
102 - if ($this->_encoding)  
103 - $this->_addParser('_encodeKeywords');  
104 -  
105 - // go!  
106 - return $this->_pack($this->_script);  
107 - }  
108 -  
109 - // apply all parsing routines  
110 - function _pack($script) {  
111 - for ($i = 0; isset($this->_parsers[$i]); $i++) {  
112 - $script = call_user_func(array(&$this,$this->_parsers[$i]), $script);  
113 - }  
114 - return $script;  
115 - }  
116 -  
117 - // keep a list of parsing functions, they'll be executed all at once  
118 - var $_parsers = array();  
119 - function _addParser($parser) {  
120 - $this->_parsers[] = $parser;  
121 - }  
122 -  
123 - // zero encoding - just removal of white space and comments  
124 - function _basicCompression($script) {  
125 - $parser = new ParseMaster();  
126 - // make safe  
127 - $parser->escapeChar = '\\';  
128 - // protect strings  
129 - $parser->add('/\'[^\'\\n\\r]*\'/',$this->IGNORE);  
130 - $parser->add('/"[^"\\n\\r]*"/', $this->IGNORE);  
131 - // remove comments  
132 - $parser->add('/\\/\\/[^\\n\\r]*[\\n\\r]/', ' ');  
133 - $parser->add('/\\/\\*[^*]*\\*+([^\\/][^*]*\\*+)*\\//', ' ');  
134 - // protect regular expressions  
135 - $parser->add('/\\s+(\\/[^\\/\\n\\r\\*][^\\/\\n\\r]*\\/g?i?)/', '$2'); // IGNORE  
136 - $parser->add('/[^\\w\\x24\\/\'"*)\\?:]\\/[^\\/\\n\\r\\*][^\\/\\n\\r]*\\/g?i?/', $this->IGNORE);  
137 - // remove: ;;; doSomething();  
138 - if ($this->_specialChars) $parser->add('/;;;[^\\n\\r]+[\\n\\r]/');  
139 - // remove redundant semi-colons  
140 - $parser->add('/\\(;;\\)/', $this->IGNORE); // protect for (;;) loops  
141 - $parser->add('/;+\\s*([};])/', '$2');  
142 - // apply the above  
143 - $script = $parser->exec($script);  
144 -  
145 - // remove white-space  
146 - $parser->add('/(\\b|\\x24)\\s+(\\b|\\x24)/', '$2 $3');  
147 - $parser->add('/([+\\-])\\s+([+\\-])/', '$2 $3');  
148 - $parser->add('/\\s+/', '');  
149 - // done  
150 - return $parser->exec($script);  
151 - }  
152 -  
153 - function _encodeSpecialChars($script) {  
154 - $parser = new ParseMaster();  
155 - // replace: $name -> n, $$name -> na  
156 - $parser->add('/((\\x24+)([a-zA-Z$_]+))(\\d*)/',  
157 - array('fn' => '_replace_name')  
158 - );  
159 - // replace: _name -> _0, double-underscore (__name) is ignored  
160 - $regexp = '/\\b_[A-Za-z\\d]\\w*/';  
161 - // build the word list  
162 - $keywords = $this->_analyze($script, $regexp, '_encodePrivate');  
163 - // quick ref  
164 - $encoded = $keywords['encoded'];  
165 -  
166 - $parser->add($regexp,  
167 - array(  
168 - 'fn' => '_replace_encoded',  
169 - 'data' => $encoded  
170 - )  
171 - );  
172 - return $parser->exec($script);  
173 - }  
174 -  
175 - function _encodeKeywords($script) {  
176 - // escape high-ascii values already in the script (i.e. in strings)  
177 - if ($this->_encoding > 62)  
178 - $script = $this->_escape95($script);  
179 - // create the parser  
180 - $parser = new ParseMaster();  
181 - $encode = $this->_getEncoder($this->_encoding);  
182 - // for high-ascii, don't encode single character low-ascii  
183 - $regexp = ($this->_encoding > 62) ? '/\\w\\w+/' : '/\\w+/';  
184 - // build the word list  
185 - $keywords = $this->_analyze($script, $regexp, $encode);  
186 - $encoded = $keywords['encoded'];  
187 -  
188 - // encode  
189 - $parser->add($regexp,  
190 - array(  
191 - 'fn' => '_replace_encoded',  
192 - 'data' => $encoded  
193 - )  
194 - );  
195 - if (empty($script)) return $script;  
196 - else {  
197 - //$res = $parser->exec($script);  
198 - //$res = $this->_bootStrap($res, $keywords);  
199 - //return $res;  
200 - return $this->_bootStrap($parser->exec($script), $keywords);  
201 - }  
202 - }  
203 -  
204 - function _analyze($script, $regexp, $encode) {  
205 - // analyse  
206 - // retreive all words in the script  
207 - $all = array();  
208 - preg_match_all($regexp, $script, $all);  
209 - $_sorted = array(); // list of words sorted by frequency  
210 - $_encoded = array(); // dictionary of word->encoding  
211 - $_protected = array(); // instances of "protected" words  
212 - $all = $all[0]; // simulate the javascript comportement of global match  
213 - if (!empty($all)) {  
214 - $unsorted = array(); // same list, not sorted  
215 - $protected = array(); // "protected" words (dictionary of word->"word")  
216 - $value = array(); // dictionary of charCode->encoding (eg. 256->ff)  
217 - $this->_count = array(); // word->count  
218 - $i = count($all); $j = 0; //$word = null;  
219 - // count the occurrences - used for sorting later  
220 - do {  
221 - --$i;  
222 - $word = '$' . $all[$i];  
223 - if (!isset($this->_count[$word])) {  
224 - $this->_count[$word] = 0;  
225 - $unsorted[$j] = $word;  
226 - // make a dictionary of all of the protected words in this script  
227 - // these are words that might be mistaken for encoding  
228 - //if (is_string($encode) && method_exists($this, $encode))  
229 - $values[$j] = call_user_func(array(&$this, $encode), $j);  
230 - $protected['$' . $values[$j]] = $j++;  
231 - }  
232 - // increment the word counter  
233 - $this->_count[$word]++;  
234 - } while ($i > 0);  
235 - // prepare to sort the word list, first we must protect  
236 - // words that are also used as codes. we assign them a code  
237 - // equivalent to the word itself.  
238 - // e.g. if "do" falls within our encoding range  
239 - // then we store keywords["do"] = "do";  
240 - // this avoids problems when decoding  
241 - $i = count($unsorted);  
242 - do {  
243 - $word = $unsorted[--$i];  
244 - if (isset($protected[$word]) /*!= null*/) {  
245 - $_sorted[$protected[$word]] = substr($word, 1);  
246 - $_protected[$protected[$word]] = true;  
247 - $this->_count[$word] = 0;  
248 - }  
249 - } while ($i);  
250 -  
251 - // sort the words by frequency  
252 - // Note: the javascript and php version of sort can be different :  
253 - // in php manual, usort :  
254 - // " If two members compare as equal,  
255 - // their order in the sorted array is undefined."  
256 - // so the final packed script is different of the Dean's javascript version  
257 - // but equivalent.  
258 - // the ECMAscript standard does not guarantee this behaviour,  
259 - // and thus not all browsers (e.g. Mozilla versions dating back to at  
260 - // least 2003) respect this.  
261 - usort($unsorted, array(&$this, '_sortWords'));  
262 - $j = 0;  
263 - // because there are "protected" words in the list  
264 - // we must add the sorted words around them  
265 - do {  
266 - if (!isset($_sorted[$i]))  
267 - $_sorted[$i] = substr($unsorted[$j++], 1);  
268 - $_encoded[$_sorted[$i]] = $values[$i];  
269 - } while (++$i < count($unsorted));  
270 - }  
271 - return array(  
272 - 'sorted' => $_sorted,  
273 - 'encoded' => $_encoded,  
274 - 'protected' => $_protected);  
275 - }  
276 -  
277 - var $_count = array();  
278 - function _sortWords($match1, $match2) {  
279 - return $this->_count[$match2] - $this->_count[$match1];  
280 - }  
281 -  
282 - // build the boot function used for loading and decoding  
283 - function _bootStrap($packed, $keywords) {  
284 - $ENCODE = $this->_safeRegExp('$encode\\($count\\)');  
285 -  
286 - // $packed: the packed script  
287 - $packed = "'" . $this->_escape($packed) . "'";  
288 -  
289 - // $ascii: base for encoding  
290 - $ascii = min(count($keywords['sorted']), $this->_encoding);  
291 - if ($ascii == 0) $ascii = 1;  
292 -  
293 - // $count: number of words contained in the script  
294 - $count = count($keywords['sorted']);  
295 -  
296 - // $keywords: list of words contained in the script  
297 - foreach ($keywords['protected'] as $i=>$value) {  
298 - $keywords['sorted'][$i] = '';  
299 - }  
300 - // convert from a string to an array  
301 - ksort($keywords['sorted']);  
302 - $keywords = "'" . implode('|',$keywords['sorted']) . "'.split('|')";  
303 -  
304 - $encode = ($this->_encoding > 62) ? '_encode95' : $this->_getEncoder($ascii);  
305 - $encode = $this->_getJSFunction($encode);  
306 - $encode = preg_replace('/_encoding/','$ascii', $encode);  
307 - $encode = preg_replace('/arguments\\.callee/','$encode', $encode);  
308 - $inline = '\\$count' . ($ascii > 10 ? '.toString(\\$ascii)' : '');  
309 -  
310 - // $decode: code snippet to speed up decoding  
311 - if ($this->_fastDecode) {  
312 - // create the decoder  
313 - $decode = $this->_getJSFunction('_decodeBody');  
314 - if ($this->_encoding > 62)  
315 - $decode = preg_replace('/\\\\w/', '[\\xa1-\\xff]', $decode);  
316 - // perform the encoding inline for lower ascii values  
317 - elseif ($ascii < 36)  
318 - $decode = preg_replace($ENCODE, $inline, $decode);  
319 - // special case: when $count==0 there are no keywords. I want to keep  
320 - // the basic shape of the unpacking funcion so i'll frig the code...  
321 - if ($count == 0)  
322 - $decode = preg_replace($this->_safeRegExp('($count)\\s*=\\s*1'), '$1=0', $decode, 1);  
323 - }  
324 -  
325 - // boot function  
326 - $unpack = $this->_getJSFunction('_unpack');  
327 - if ($this->_fastDecode) {  
328 - // insert the decoder  
329 - $this->buffer = $decode;  
330 - $unpack = preg_replace_callback('/\\{/', array(&$this, '_insertFastDecode'), $unpack, 1);  
331 - }  
332 - $unpack = preg_replace('/"/', "'", $unpack);  
333 - if ($this->_encoding > 62) { // high-ascii  
334 - // get rid of the word-boundaries for regexp matches  
335 - $unpack = preg_replace('/\'\\\\\\\\b\'\s*\\+|\\+\s*\'\\\\\\\\b\'/', '', $unpack);  
336 - }  
337 - if ($ascii > 36 || $this->_encoding > 62 || $this->_fastDecode) {  
338 - // insert the encode function  
339 - $this->buffer = $encode;  
340 - $unpack = preg_replace_callback('/\\{/', array(&$this, '_insertFastEncode'), $unpack, 1);  
341 - } else {  
342 - // perform the encoding inline  
343 - $unpack = preg_replace($ENCODE, $inline, $unpack);  
344 - }  
345 - // pack the boot function too  
346 - $unpackPacker = new JavaScriptPacker($unpack, 0, false, true);  
347 - $unpack = $unpackPacker->pack();  
348 -  
349 - // arguments  
350 - $params = array($packed, $ascii, $count, $keywords);  
351 - if ($this->_fastDecode) {  
352 - $params[] = 0;  
353 - $params[] = '{}';  
354 - }  
355 - $params = implode(',', $params);  
356 -  
357 - // the whole thing  
358 - return 'eval(' . $unpack . '(' . $params . "))\n";  
359 - }  
360 -  
361 - var $buffer;  
362 - function _insertFastDecode($match) {  
363 - return '{' . $this->buffer . ';';  
364 - }  
365 - function _insertFastEncode($match) {  
366 - return '{$encode=' . $this->buffer . ';';  
367 - }  
368 -  
369 - // mmm.. ..which one do i need ??  
370 - function _getEncoder($ascii) {  
371 - return $ascii > 10 ? $ascii > 36 ? $ascii > 62 ?  
372 - '_encode95' : '_encode62' : '_encode36' : '_encode10';  
373 - }  
374 -  
375 - // zero encoding  
376 - // characters: 0123456789  
377 - function _encode10($charCode) {  
378 - return $charCode;  
379 - }  
380 -  
381 - // inherent base36 support  
382 - // characters: 0123456789abcdefghijklmnopqrstuvwxyz  
383 - function _encode36($charCode) {  
384 - return base_convert($charCode, 10, 36);  
385 - }  
386 -  
387 - // hitch a ride on base36 and add the upper case alpha characters  
388 - // characters: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ  
389 - function _encode62($charCode) {  
390 - $res = '';  
391 - if ($charCode >= $this->_encoding) {  
392 - $res = $this->_encode62((int)($charCode / $this->_encoding));  
393 - }  
394 - $charCode = $charCode % $this->_encoding;  
395 -  
396 - if ($charCode > 35)  
397 - return $res . chr($charCode + 29);  
398 - else  
399 - return $res . base_convert($charCode, 10, 36);  
400 - }  
401 -  
402 - // use high-ascii values  
403 - // characters: ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÃ?ÂÃÄÅÆÇÈÉÊËÌÃ?ÎÃ?Ã?ÑÒÓÔÕÖ×ØÙÚÛÜÃ?Þßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþ  
404 - function _encode95($charCode) {  
405 - $res = '';  
406 - if ($charCode >= $this->_encoding)  
407 - $res = $this->_encode95($charCode / $this->_encoding);  
408 -  
409 - return $res . chr(($charCode % $this->_encoding) + 161);  
410 - }  
411 -  
412 - function _safeRegExp($string) {  
413 - return '/'.preg_replace('/\$/', '\\\$', $string).'/';  
414 - }  
415 -  
416 - function _encodePrivate($charCode) {  
417 - return "_" . $charCode;  
418 - }  
419 -  
420 - // protect characters used by the parser  
421 - function _escape($script) {  
422 - return preg_replace('/([\\\\\'])/', '\\\$1', $script);  
423 - }  
424 -  
425 - // protect high-ascii characters already in the script  
426 - function _escape95($script) {  
427 - return preg_replace_callback(  
428 - '/[\\xa1-\\xff]/',  
429 - array(&$this, '_escape95Bis'),  
430 - $script  
431 - );  
432 - }  
433 - function _escape95Bis($match) {  
434 - return '\x'.((string)dechex(ord($match)));  
435 - }  
436 -  
437 -  
438 - function _getJSFunction($aName) {  
439 - $func = 'JSFUNCTION'.$aName;  
440 - if (isset($this->$func)){  
441 - return $this->$func;  
442 - }  
443 - else  
444 - return '';  
445 - }  
446 -  
447 - // JavaScript Functions used.  
448 - // Note : In Dean's version, these functions are converted  
449 - // with 'String(aFunctionName);'.  
450 - // This internal conversion complete the original code, ex :  
451 - // 'while (aBool) anAction();' is converted to  
452 - // 'while (aBool) { anAction(); }'.  
453 - // The JavaScript functions below are corrected.  
454 -  
455 - // unpacking function - this is the boot strap function  
456 - // data extracted from this packing routine is passed to  
457 - // this function when decoded in the target  
458 - // NOTE ! : without the ';' final.  
459 - var $JSFUNCTION_unpack = 'function($packed, $ascii, $count, $keywords, $encode, $decode) {  
460 - while ($count--) {  
461 - if ($keywords[$count]) {  
462 - $packed = $packed.replace(new RegExp(\'\\\\b\' + $encode($count) + \'\\\\b\', \'g\'), $keywords[$count]);  
463 - }  
464 - }  
465 - return $packed;  
466 -}';  
467 -/*  
468 -'function($packed, $ascii, $count, $keywords, $encode, $decode) {  
469 - while ($count--)  
470 - if ($keywords[$count])  
471 - $packed = $packed.replace(new RegExp(\'\\\\b\' + $encode($count) + \'\\\\b\', \'g\'), $keywords[$count]);  
472 - return $packed;  
473 -}';  
474 -*/  
475 -  
476 - // code-snippet inserted into the unpacker to speed up decoding  
477 - var $JSFUNCTION_decodeBody = ' if (!\'\'.replace(/^/, String)) {  
478 - // decode all the values we need  
479 - while ($count--) {  
480 - $decode[$encode($count)] = $keywords[$count] || $encode($count);  
481 - }  
482 - // global replacement function  
483 - $keywords = [function ($encoded) {return $decode[$encoded]}];  
484 - // generic match  
485 - $encode = function () {return \'\\\\w+\'};  
486 - // reset the loop counter - we are now doing a global replace  
487 - $count = 1;  
488 - }  
489 -';  
490 -//};  
491 -/*  
492 -' if (!\'\'.replace(/^/, String)) {  
493 - // decode all the values we need  
494 - while ($count--) $decode[$encode($count)] = $keywords[$count] || $encode($count);  
495 - // global replacement function  
496 - $keywords = [function ($encoded) {return $decode[$encoded]}];  
497 - // generic match  
498 - $encode = function () {return\'\\\\w+\'};  
499 - // reset the loop counter - we are now doing a global replace  
500 - $count = 1;  
501 - }';  
502 -*/  
503 -  
504 - // zero encoding  
505 - // characters: 0123456789  
506 - var $JSFUNCTION_encode10 = 'function($charCode) {  
507 - return $charCode;  
508 -}';//;';  
509 -  
510 - // inherent base36 support  
511 - // characters: 0123456789abcdefghijklmnopqrstuvwxyz  
512 - var $JSFUNCTION_encode36 = 'function($charCode) {  
513 - return $charCode.toString(36);  
514 -}';//;';  
515 -  
516 - // hitch a ride on base36 and add the upper case alpha characters  
517 - // characters: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ  
518 - var $JSFUNCTION_encode62 = 'function($charCode) {  
519 - return ($charCode < _encoding ? \'\' : arguments.callee(parseInt($charCode / _encoding))) +  
520 - (($charCode = $charCode % _encoding) > 35 ? String.fromCharCode($charCode + 29) : $charCode.toString(36));  
521 -}';  
522 -  
523 - // use high-ascii values  
524 - // characters: ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÃ?ÂÃÄÅÆÇÈÉÊËÌÃ?ÎÃ?Ã?ÑÒÓÔÕÖ×ØÙÚÛÜÃ?Þßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþ  
525 - var $JSFUNCTION_encode95 = 'function($charCode) {  
526 - return ($charCode < _encoding ? \'\' : arguments.callee($charCode / _encoding)) +  
527 - String.fromCharCode($charCode % _encoding + 161);  
528 -}';  
529 -  
530 -}  
531 -  
532 -  
533 -class ParseMaster {  
534 - var $ignoreCase = false;  
535 - var $escapeChar = '';  
536 -  
537 - // constants  
538 - var $EXPRESSION = 0;  
539 - var $REPLACEMENT = 1;  
540 - var $LENGTH = 2;  
541 -  
542 - // used to determine nesting levels  
543 - var $GROUPS = '/\\(/';//g  
544 - var $SUB_REPLACE = '/\\$\\d/';  
545 - var $INDEXED = '/^\\$\\d+$/';  
546 - var $TRIM = '/([\'"])\\1\\.(.*)\\.\\1\\1$/';  
547 - var $ESCAPE = '/\\\./';//g  
548 - var $QUOTE = '/\'/';  
549 - var $DELETED = '/\\x01[^\\x01]*\\x01/';//g  
550 -  
551 - function add($expression, $replacement = '') {  
552 - // count the number of sub-expressions  
553 - // - add one because each pattern is itself a sub-expression  
554 - $length = 1 + preg_match_all($this->GROUPS, $this->_internalEscape((string)$expression), $out);  
555 -  
556 - // treat only strings $replacement  
557 - if (is_string($replacement)) {  
558 - // does the pattern deal with sub-expressions?  
559 - if (preg_match($this->SUB_REPLACE, $replacement)) {  
560 - // a simple lookup? (e.g. "$2")  
561 - if (preg_match($this->INDEXED, $replacement)) {  
562 - // store the index (used for fast retrieval of matched strings)  
563 - $replacement = (int)(substr($replacement, 1)) - 1;  
564 - } else { // a complicated lookup (e.g. "Hello $2 $1")  
565 - // build a function to do the lookup  
566 - $quote = preg_match($this->QUOTE, $this->_internalEscape($replacement))  
567 - ? '"' : "'";  
568 - $replacement = array(  
569 - 'fn' => '_backReferences',  
570 - 'data' => array(  
571 - 'replacement' => $replacement,  
572 - 'length' => $length,  
573 - 'quote' => $quote  
574 - )  
575 - );  
576 - }  
577 - }  
578 - }  
579 - // pass the modified arguments  
580 - if (!empty($expression)) $this->_add($expression, $replacement, $length);  
581 - else $this->_add('/^$/', $replacement, $length);  
582 - }  
583 -  
584 - function exec($string) {  
585 - // execute the global replacement  
586 - $this->_escaped = array();  
587 -  
588 - // simulate the _patterns.toSTring of Dean  
589 - $regexp = '/';  
590 - foreach ($this->_patterns as $reg) {  
591 - $regexp .= '(' . substr($reg[$this->EXPRESSION], 1, -1) . ')|';  
592 - }  
593 - $regexp = substr($regexp, 0, -1) . '/';  
594 - $regexp .= ($this->ignoreCase) ? 'i' : '';  
595 -  
596 - $string = $this->_escape($string, $this->escapeChar);  
597 - $string = preg_replace_callback(  
598 - $regexp,  
599 - array(  
600 - &$this,  
601 - '_replacement'  
602 - ),  
603 - $string  
604 - );  
605 - $string = $this->_unescape($string, $this->escapeChar);  
606 -  
607 - return preg_replace($this->DELETED, '', $string);  
608 - }  
609 -  
610 - function reset() {  
611 - // clear the patterns collection so that this object may be re-used  
612 - $this->_patterns = array();  
613 - }  
614 -  
615 - // private  
616 - var $_escaped = array(); // escaped characters  
617 - var $_patterns = array(); // patterns stored by index  
618 -  
619 - // create and add a new pattern to the patterns collection  
620 - function _add() {  
621 - $arguments = func_get_args();  
622 - $this->_patterns[] = $arguments;  
623 - }  
624 -  
625 - // this is the global replace function (it's quite complicated)  
626 - function _replacement($arguments) {  
627 - if (empty($arguments)) return '';  
628 -  
629 - $i = 1; $j = 0;  
630 - // loop through the patterns  
631 - while (isset($this->_patterns[$j])) {  
632 - $pattern = $this->_patterns[$j++];  
633 - // do we have a result?  
634 - if (isset($arguments[$i]) && ($arguments[$i] != '')) {  
635 - $replacement = $pattern[$this->REPLACEMENT];  
636 -  
637 - if (is_array($replacement) && isset($replacement['fn'])) {  
638 -  
639 - if (isset($replacement['data'])) $this->buffer = $replacement['data'];  
640 - return call_user_func(array(&$this, $replacement['fn']), $arguments, $i);  
641 -  
642 - } elseif (is_int($replacement)) {  
643 - return $arguments[$replacement + $i];  
644 -  
645 - }  
646 - $delete = ($this->escapeChar == '' ||  
647 - strpos($arguments[$i], $this->escapeChar) === false)  
648 - ? '' : "\x01" . $arguments[$i] . "\x01";  
649 - return $delete . $replacement;  
650 -  
651 - // skip over references to sub-expressions  
652 - } else {  
653 - $i += $pattern[$this->LENGTH];  
654 - }  
655 - }  
656 - }  
657 -  
658 - function _backReferences($match, $offset) {  
659 - $replacement = $this->buffer['replacement'];  
660 - $quote = $this->buffer['quote'];  
661 - $i = $this->buffer['length'];  
662 - while ($i) {  
663 - $replacement = str_replace('$'.$i--, $match[$offset + $i], $replacement);  
664 - }  
665 - return $replacement;  
666 - }  
667 -  
668 - function _replace_name($match, $offset){  
669 - $length = strlen($match[$offset + 2]);  
670 - $start = $length - max($length - strlen($match[$offset + 3]), 0);  
671 - return substr($match[$offset + 1], $start, $length) . $match[$offset + 4];  
672 - }  
673 -  
674 - function _replace_encoded($match, $offset) {  
675 - return $this->buffer[$match[$offset]];  
676 - }  
677 -  
678 -  
679 - // php : we cannot pass additional data to preg_replace_callback,  
680 - // and we cannot use &$this in create_function, so let's go to lower level  
681 - var $buffer;  
682 -  
683 - // encode escaped characters  
684 - function _escape($string, $escapeChar) {  
685 - if ($escapeChar) {  
686 - $this->buffer = $escapeChar;  
687 - return preg_replace_callback(  
688 - '/\\' . $escapeChar . '(.)' .'/',  
689 - array(&$this, '_escapeBis'),  
690 - $string  
691 - );  
692 -  
693 - } else {  
694 - return $string;  
695 - }  
696 - }  
697 - function _escapeBis($match) {  
698 - $this->_escaped[] = $match[1];  
699 - return $this->buffer;  
700 - }  
701 -  
702 - // decode escaped characters  
703 - function _unescape($string, $escapeChar) {  
704 - if ($escapeChar) {  
705 - $regexp = '/'.'\\'.$escapeChar.'/';  
706 - $this->buffer = array('escapeChar'=> $escapeChar, 'i' => 0);  
707 - return preg_replace_callback  
708 - (  
709 - $regexp,  
710 - array(&$this, '_unescapeBis'),  
711 - $string  
712 - );  
713 -  
714 - } else {  
715 - return $string;  
716 - }  
717 - }  
718 - function _unescapeBis() {  
719 - if (!empty($this->_escaped[$this->buffer['i']])) {  
720 - $temp = $this->_escaped[$this->buffer['i']];  
721 - } else {  
722 - $temp = '';  
723 - }  
724 - $this->buffer['i']++;  
725 - return $this->buffer['escapeChar'] . $temp;  
726 - }  
727 -  
728 - function _internalEscape($string) {  
729 - return preg_replace($this->ESCAPE, '', $string);  
730 - }  
731 -}  
732 -?>  
classesjs/packer/example-file.php
View file @f1e1a75
@@ -1,34 +0,0 @@ @@ -1,34 +0,0 @@
1 -<?php  
2 -// you can pass this script to PHP CLI to convert your file.  
3 -  
4 -// adapt these 2 paths to your files.  
5 -$src = 'myScript-src.js';  
6 -$out = 'myScript.js';  
7 -  
8 -// or uncomment these lines to use the argc and argv passed by CLI :  
9 -/*  
10 -if ($argc >= 3) {  
11 - $src = $argv[1];  
12 - $out = $argv[2];  
13 -} else {  
14 - echo 'you must specify a source file and a result filename',"\n";  
15 - echo 'example :', "\n", 'php example-file.php myScript-src.js myPackedScript.js',"\n";  
16 - return;  
17 -}  
18 -*/  
19 -  
20 -require 'class.JavaScriptPacker.php';  
21 -  
22 -$script = file_get_contents($src);  
23 -  
24 -$t1 = microtime(true);  
25 -  
26 -$packer = new JavaScriptPacker($script, 'Normal', true, false);  
27 -$packed = $packer->pack();  
28 -  
29 -$t2 = microtime(true);  
30 -$time = sprintf('%.4f', ($t2 - $t1) );  
31 -echo 'script ', $src, ' packed in ' , $out, ', in ', $time, ' s.', "\n";  
32 -  
33 -file_put_contents($out, $packed);  
34 -?>  
classesjs/packer/example-inline.php
View file @f1e1a75
@@ -1,88 +0,0 @@ @@ -1,88 +0,0 @@
1 -<?php  
2 -  
3 -$treat = false;  
4 -if (isset($_POST['src'])) {  
5 - $script = $_POST['src'];  
6 - if (get_magic_quotes_gpc())  
7 - $script = stripslashes($script);  
8 - $encoding = (int)$_POST['ascii_encoding'];  
9 - $fast_decode = isset($_POST['fast_decode']) && $_POST['fast_decode'];  
10 - $special_char = isset($_POST['special_char'])&& $_POST['special_char'];  
11 -  
12 - require 'class.JavaScriptPacker.php';  
13 - $t1 = microtime(true);  
14 - $packer = new JavaScriptPacker($script, $encoding, $fast_decode, $special_char);  
15 - $packed = $packer->pack();  
16 - $t2 = microtime(true);  
17 -  
18 - $originalLength = strlen($script);  
19 - $packedLength = strlen($packed);  
20 - $ratio = number_format($packedLength / $originalLength, 3);  
21 - $time = sprintf('%.4f', ($t2 - $t1) );  
22 -  
23 - $treat = true;  
24 -}  
25 -?>  
26 -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"  
27 - "http://www.w3.org/TR/html4/strict.dtd">  
28 -<html>  
29 -<head>  
30 -<title>JavaScript Packer in PHP</title>  
31 -<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">  
32 -<style type="text/css">  
33 -.result {  
34 - border: 1px blue dashed;  
35 - color: black;  
36 - background-color: #e5e5e5;  
37 - padding: 0.2em;  
38 -}  
39 -</style>  
40 -<script type="text/javascript">  
41 -function decode() {  
42 - var packed = document.getElementById('packed');  
43 - eval("packed.value=String" + packed.value.slice(4));  
44 -}  
45 -</script>  
46 -</head>  
47 -<body>  
48 - <form action="<?php echo $_SERVER['PHP_SELF']?>" method="post">  
49 - <div>  
50 - <h3>script to pack:</h3>  
51 - <textarea name="src" id="src" rows="10" cols="80"><?php if($treat) echo htmlspecialchars($script);?></textarea>  
52 - </div>  
53 - <!-- <fieldset> -->  
54 - <div>  
55 - <label for="ascii-encoding">Encoding:</label>  
56 - <select name="ascii_encoding" id="ascii-encoding">  
57 - <option value="0"<?php if ($treat && $encoding == 0) echo ' selected'?>>None</option>  
58 - <option value="10"<?php if ($treat && $encoding == 10) echo ' selected'?>>Numeric</option>  
59 - <option value="62"<?php if (!$treat) echo 'selected';if ($treat && $encoding == 62) echo ' selected';?>>Normal</option>  
60 - <option value="95"<?php if ($treat && $encoding == 95) echo ' selected'?>>High ASCII</option>  
61 - </select>  
62 - <label>  
63 - Fast Decode:  
64 - <input type="checkbox" name="fast_decode" id="fast-decode"<?php if (!$treat || $fast_decode) echo ' checked'?>>  
65 - </label>  
66 - <label>  
67 - Special Characters:  
68 - <input type="checkbox" name="special_char" id="special-char"<?php if ($treat && $special_char) echo ' checked'?>>  
69 - </label>  
70 - <input type="submit" value="Pack">  
71 - </div>  
72 - <!-- </fieldset> -->  
73 - </form>  
74 -  
75 - <?php if ($treat) {?>  
76 - <div id="result">  
77 - <h3>packed result:</h3>  
78 - <textarea id="packed" class="result" rows="10" cols="80" readonly="readonly"><?php echo htmlspecialchars($packed);?></textarea>  
79 - <p>  
80 - compression ratio:  
81 - <?php echo $originalLength, '/', $packedLength, ' = ',$ratio; ?>  
82 - <br>performed in <?php echo $time; ?> s.  
83 - </p>  
84 - <p><button type="button" onclick="decode()">decode</button></p>  
85 - </div>  
86 - <?php };//end if($treat)?>  
87 -</body>  
88 -</html>  
classesjs/packer/readme.txt
View file @f1e1a75
@@ -1,12 +0,0 @@ @@ -1,12 +0,0 @@
1 -PHP 5 :  
2 -use class.JavaScriptPacker.php (Tested under PHP 5.1.2, 5.1.3 et 5.1.4.)  
3 - - usage and comments in source.  
4 - - there is 2 examples in this archive for PHP 5,  
5 - 'example-file.php' and example-inline.php  
6 -  
7 -PHP 4 :  
8 -use class.JavaScriptPacker.php4, it's an adaptation for PHP4.  
9 -The examples in this archive will not work directly with PHP 4, they are  
10 -writed in PHP5, you'll need to adapt them. If some functions are missing in  
11 -PHP 4, you can find their equivalent here :  
12 -http://pear.php.net/package/PHP_Compat