ice framework documentation ice doc v1.11.0
Class Github
Class Ice Filter

Js

  1.     
  2. namespace Ice\Filter;
  3.  
  4. use Ice\Exception;
  5.  
  6. /**
  7.  * Minify js string.
  8.  *
  9.  * @package     Ice/Filter
  10.  * @category    Minification
  11.  * @author      Ice Team
  12.  * @copyright   (c) 2014-2025 Ice Team
  13.  * @license     http://iceframework.org/license
  14.  * @uses        jsmin.c www.crockford.com
  15.  */
  16. class Js
  17. {
  18.     const ORD_LF = 10;
  19.     const ORD_SPACE = 32;
  20.     const ACTION_KEEP_A = 1;
  21.     const ACTION_DELETE_A = 2;
  22.     const ACTION_DELETE_A_B = 3;
  23.     protected a = "";
  24.     protected b = "";
  25.     protected input = "";
  26.     protected inputIndex = 0;
  27.     protected inputLength = 0;
  28.     protected lookAhead = null;
  29.     protected output = "" { get };
  30.  
  31.     /**
  32.      * Minify the js.
  33.      *
  34.      * @param string js JS code to minify
  35.      * @return string
  36.      */
  37.     public function sanitize(string js)
  38.     {
  39.         let this->a = "",
  40.             this->b = "",
  41.             this->input = str_replace("\r\n", "\n", js),
  42.             this->inputLength = strlen(this->input),
  43.             this->inputIndex = 0,
  44.             this->lookAhead = null,
  45.             this->output = "";
  46.  
  47.         return this->min();
  48.     }
  49.  
  50.     /**
  51.      * Action -- do something! What to do is determined by the $command argument.
  52.      *
  53.      * action treats a string as a single character. Wow!
  54.      * action recognizes a regular expression if it is preceded by ( or , or =.
  55.      *
  56.      * @throws Exception If parser errors are found:
  57.      *         - Unterminated string literal
  58.      *         - Unterminated regular expression set in regex literal
  59.      *         - Unterminated regular expression literal
  60.      *
  61.      * @param int $command One of class constants:
  62.      *      ACTION_KEEP_A      Output A. Copy B to A. Get the next B.
  63.      *      ACTION_DELETE_A    Copy B to A. Get the next B. (Delete A).
  64.      *      ACTION_DELETE_A_B  Get the next B. (Delete B).
  65.      */
  66.     protected function action(int command)
  67.     {
  68.         //switch command {
  69.             //case self::ACTION_KEEP_A: //1
  70.             if command == self::ACTION_KEEP_A {
  71.                 let this->output = this->output . this->a;
  72.             }
  73.  
  74.             //case self::ACTION_DELETE_A: //1, 2
  75.             if command == self::ACTION_KEEP_A || command == self::ACTION_DELETE_A {
  76.                 let this->a = this->b;
  77.  
  78.                 if this->a === "'" || this->a === "\"" {
  79.                     while 1 {
  80.                         let this->output = this->output . this->a,
  81.                             this->a = this->get();
  82.  
  83.                         if this->a === this->b {
  84.                             break;
  85.                         }
  86.  
  87.                         if ord(this->a) <= self::ORD_LF {
  88.                             throw new Exception("Unterminated string literal.");
  89.                         }
  90.  
  91.                         if this->a === "\\" {
  92.                             let this->output = this->output . this->a,
  93.                                 this->a = this->get();
  94.                         }
  95.                     }
  96.                 }
  97.             }
  98.  
  99.             //case self::ACTION_DELETE_A_B: //1, 2, 3
  100.             if command == self::ACTION_KEEP_A || command == self::ACTION_DELETE_A || command == self::ACTION_DELETE_A_B {
  101.                 let this->b = this->next();
  102.  
  103.                 if this->b === "/" && (
  104.                     this->a === "(" || this->a === "," || this->a === "=" ||
  105.                     this->a === ":" || this->a === "[" || this->a === "!" ||
  106.                     this->a === "&" || this->a === "|" || this->a === "?" ||
  107.                     this->a === "{" || this->a === "}" || this->a === ";" ||
  108.                     this->a === "\n" ) {
  109.                     let this->output = this->output . this->a . this->b;
  110.  
  111.                     while 1 {
  112.                         let this->a = this->get();
  113.                         if this->a === "[" {
  114.                             /*
  115.                             inside a regex [...] set, which MAY contain a "/" itself. Example: mootools Form.Validator near line 460:
  116.                             return Form.Validator.getValidator("IsEmpty").test(element) || (/^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]\.?){0,63}[a-z0-9!#$%&'*+/=?^_`{|}~-]@(?:(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\])$/i).test(element.get("value"));
  117.                             */
  118.                             while 1 {
  119.                                 let this->output = this->output . this->a,
  120.                                     this->a = this->get();
  121.  
  122.                                 if this->a === "]" {
  123.                                     break;
  124.                                 } elseif this->a === "\\" {
  125.                                     let this->output = this->output . this->a,
  126.                                         this->a = this->get();
  127.                                 } elseif ord(this->a) <= self::ORD_LF {
  128.                                     throw new Exception("Unterminated regular expression set in regex literal.");
  129.                                 }
  130.                             }
  131.                         } elseif this->a === "/" {
  132.                             break;
  133.                         } elseif this->a === "\\" {
  134.                             let this->output = this->output . this->a,
  135.                                 this->a = this->get();
  136.                         } elseif ord(this->a) <= self::ORD_LF {
  137.                             throw new Exception("Unterminated regular expression literal.");
  138.                         }
  139.  
  140.                         let this->output = this->output . this->a;
  141.                     }
  142.  
  143.                     let this->b = this->next();
  144.                 }
  145.             }
  146.         //}
  147.     }
  148.  
  149.     /**
  150.      * Get next char. Convert ctrl char to space.
  151.      *
  152.      * @return string|null
  153.      */
  154.     protected function get()
  155.     {
  156.         var c, i;
  157.  
  158.         let c = this->lookAhead,
  159.             this->lookAhead = null;
  160.  
  161.         if c === null {
  162.             if this->inputIndex < this->inputLength {
  163.                 let c = substr(this->input, this->inputIndex, 1),
  164.                     i = this->inputIndex,
  165.                     this->inputIndex = i + 1;
  166.             } else {
  167.                 let c = null;
  168.             }
  169.         }
  170.  
  171.         if c === "\r" {
  172.             return "\n";
  173.         }
  174.  
  175.         if c === null || c === "\n" || ord(c) >= self::ORD_SPACE {
  176.             return c;
  177.         }
  178.  
  179.         return " ";
  180.     }
  181.  
  182.     /**
  183.      * Is $c a letter, digit, underscore, dollar sign, or non-ASCII character.
  184.      *
  185.      * @return bool
  186.      */
  187.     protected function isAlphaNum(c)
  188.     {
  189.         return ord(c) > 126 || c === "\\" || preg_match("/^[\\w\\$]$/", c) === 1;
  190.     }
  191.  
  192.     /**
  193.      * Perform minification, return result
  194.      *
  195.      * @return string
  196.      */
  197.     protected function min()
  198.     {
  199.         if 0 == strncmp(this->peek(), "\xef", 1) {
  200.             this->get();
  201.             this->get();
  202.             this->get();
  203.         }
  204.  
  205.         let this->a = "\n";
  206.         this->action(self::ACTION_DELETE_A_B);
  207.  
  208.         while this->a !== null {
  209.             switch this->a {
  210.                 case " ":
  211.                     if this->isAlphaNum(this->b) {
  212.                         this->action(self::ACTION_KEEP_A);
  213.                     } else {
  214.                         this->action(self::ACTION_DELETE_A);
  215.                     }
  216.                 break;
  217.                 case "\n":
  218.                     switch this->b {
  219.                         case "{":
  220.                         case "[":
  221.                         case "(":
  222.                         case "+":
  223.                         case "-":
  224.                         case "!":
  225.                         case "~":
  226.                             this->action(self::ACTION_KEEP_A);
  227.                         break;
  228.                         case " ":
  229.                             this->action(self::ACTION_DELETE_A_B);
  230.                         break;
  231.                         default:
  232.                             if this->isAlphaNum(this->b) {
  233.                                 this->action(self::ACTION_KEEP_A);
  234.                             } else {
  235.                                 this->action(self::ACTION_DELETE_A);
  236.                             }
  237.                     }
  238.                 break;
  239.                 default:
  240.                     switch this->b {
  241.                         case " ":
  242.                             if this->isAlphaNum(this->a) {
  243.                                 this->action(self::ACTION_KEEP_A);
  244.                                 break;
  245.                             }
  246.                             this->action(self::ACTION_DELETE_A_B);
  247.                         break;
  248.                         case "\n":
  249.                             switch this->a {
  250.                                 case "}":
  251.                                 case "]":
  252.                                 case ")":
  253.                                 case "+":
  254.                                 case "-":
  255.                                 case "\"":
  256.                                 case "'":
  257.                                     this->action(self::ACTION_KEEP_A);
  258.                                 break;
  259.                                 default:
  260.                                     if this->isAlphaNum(this->a) {
  261.                                         this->action(self::ACTION_KEEP_A);
  262.                                     } else {
  263.                                         this->action(self::ACTION_DELETE_A_B);
  264.                                     }
  265.                             }
  266.                         break;
  267.                         default:
  268.                             this->action(self::ACTION_KEEP_A);
  269.                         break;
  270.                     }
  271.             }
  272.         }
  273.  
  274.         return this->output;
  275.     }
  276.  
  277.     /**
  278.      * Get the next character, skipping over comments. peek() is used to see
  279.      *  if a "/" is followed by a "/" or "*".
  280.      *
  281.      * @throws Exception On unterminated comment.
  282.      * @return string
  283.      */
  284.     protected function next()
  285.     {
  286.         var c;
  287.  
  288.         let c = this->get();
  289.  
  290.         if c === "/" {
  291.             switch this->peek() {
  292.                 case "/":
  293.                     while 1 {
  294.                         let c = this->get();
  295.                         if ord((string) c) <= self::ORD_LF {
  296.                             return c;
  297.                         }
  298.                     }
  299.                 case "*":
  300.                     this->get();
  301.  
  302.                     while 1 {
  303.                         switch this->get() {
  304.                             case "*":
  305.                                 if this->peek() === "/" {
  306.                                     this->get();
  307.                                     return " ";
  308.                                 }
  309.                             break;
  310.                             case null:
  311.                                 throw new Exception("Unterminated comment.");
  312.                         }
  313.                     }
  314.                 default:
  315.                     return c;
  316.             }
  317.         }
  318.         return c;
  319.     }
  320.  
  321.     /**
  322.      * Get next char. If is ctrl character, translate to a space or newline.
  323.      *
  324.      * @return string|null
  325.      */
  326.     protected function peek()
  327.     {
  328.         let this->lookAhead = this->get();
  329.         return this->lookAhead;
  330.     }
  331. }