| /*********************************************************************** |
| |
| A JavaScript tokenizer / parser / beautifier / compressor. |
| https://github.com/mishoo/UglifyJS2 |
| |
| -------------------------------- (C) --------------------------------- |
| |
| Author: Mihai Bazon |
| <mihai.bazon@gmail.com> |
| http://mihai.bazon.net/blog |
| |
| Distributed under the BSD license: |
| |
| Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com> |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions |
| are met: |
| |
| * Redistributions of source code must retain the above |
| copyright notice, this list of conditions and the following |
| disclaimer. |
| |
| * Redistributions in binary form must reproduce the above |
| copyright notice, this list of conditions and the following |
| disclaimer in the documentation and/or other materials |
| provided with the distribution. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY |
| EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, |
| OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR |
| TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF |
| THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| SUCH DAMAGE. |
| |
| ***********************************************************************/ |
| |
| "use strict"; |
| |
| function array_to_hash(a) { |
| var ret = Object.create(null); |
| for (var i = 0; i < a.length; ++i) |
| ret[a[i]] = true; |
| return ret; |
| }; |
| |
| function slice(a, start) { |
| return Array.prototype.slice.call(a, start || 0); |
| }; |
| |
| function characters(str) { |
| return str.split(""); |
| }; |
| |
| function member(name, array) { |
| return array.indexOf(name) >= 0; |
| }; |
| |
| function find_if(func, array) { |
| for (var i = 0, n = array.length; i < n; ++i) { |
| if (func(array[i])) |
| return array[i]; |
| } |
| }; |
| |
| function repeat_string(str, i) { |
| if (i <= 0) return ""; |
| if (i == 1) return str; |
| var d = repeat_string(str, i >> 1); |
| d += d; |
| if (i & 1) d += str; |
| return d; |
| }; |
| |
| function configure_error_stack(fn) { |
| Object.defineProperty(fn.prototype, "stack", { |
| get: function() { |
| var err = new Error(this.message); |
| err.name = this.name; |
| try { |
| throw err; |
| } catch(e) { |
| return e.stack; |
| } |
| } |
| }); |
| } |
| |
| function DefaultsError(msg, defs) { |
| this.message = msg; |
| this.defs = defs; |
| }; |
| DefaultsError.prototype = Object.create(Error.prototype); |
| DefaultsError.prototype.constructor = DefaultsError; |
| DefaultsError.prototype.name = "DefaultsError"; |
| configure_error_stack(DefaultsError); |
| |
| DefaultsError.croak = function(msg, defs) { |
| throw new DefaultsError(msg, defs); |
| }; |
| |
| function defaults(args, defs, croak) { |
| if (args === true) |
| args = {}; |
| var ret = args || {}; |
| if (croak) for (var i in ret) if (HOP(ret, i) && !HOP(defs, i)) |
| DefaultsError.croak("`" + i + "` is not a supported option", defs); |
| for (var i in defs) if (HOP(defs, i)) { |
| ret[i] = (args && HOP(args, i)) ? args[i] : defs[i]; |
| } |
| return ret; |
| }; |
| |
| function merge(obj, ext) { |
| var count = 0; |
| for (var i in ext) if (HOP(ext, i)) { |
| obj[i] = ext[i]; |
| count++; |
| } |
| return count; |
| }; |
| |
| function noop() {} |
| function return_false() { return false; } |
| function return_true() { return true; } |
| function return_this() { return this; } |
| function return_null() { return null; } |
| |
| var MAP = (function(){ |
| function MAP(a, f, backwards) { |
| var ret = [], top = [], i; |
| function doit() { |
| var val = f(a[i], i); |
| var is_last = val instanceof Last; |
| if (is_last) val = val.v; |
| if (val instanceof AtTop) { |
| val = val.v; |
| if (val instanceof Splice) { |
| top.push.apply(top, backwards ? val.v.slice().reverse() : val.v); |
| } else { |
| top.push(val); |
| } |
| } |
| else if (val !== skip) { |
| if (val instanceof Splice) { |
| ret.push.apply(ret, backwards ? val.v.slice().reverse() : val.v); |
| } else { |
| ret.push(val); |
| } |
| } |
| return is_last; |
| }; |
| if (a instanceof Array) { |
| if (backwards) { |
| for (i = a.length; --i >= 0;) if (doit()) break; |
| ret.reverse(); |
| top.reverse(); |
| } else { |
| for (i = 0; i < a.length; ++i) if (doit()) break; |
| } |
| } |
| else { |
| for (i in a) if (HOP(a, i)) if (doit()) break; |
| } |
| return top.concat(ret); |
| }; |
| MAP.at_top = function(val) { return new AtTop(val) }; |
| MAP.splice = function(val) { return new Splice(val) }; |
| MAP.last = function(val) { return new Last(val) }; |
| var skip = MAP.skip = {}; |
| function AtTop(val) { this.v = val }; |
| function Splice(val) { this.v = val }; |
| function Last(val) { this.v = val }; |
| return MAP; |
| })(); |
| |
| function push_uniq(array, el) { |
| if (array.indexOf(el) < 0) |
| array.push(el); |
| }; |
| |
| function string_template(text, props) { |
| return text.replace(/\{(.+?)\}/g, function(str, p){ |
| return props && props[p]; |
| }); |
| }; |
| |
| function remove(array, el) { |
| for (var i = array.length; --i >= 0;) { |
| if (array[i] === el) array.splice(i, 1); |
| } |
| }; |
| |
| function mergeSort(array, cmp) { |
| if (array.length < 2) return array.slice(); |
| function merge(a, b) { |
| var r = [], ai = 0, bi = 0, i = 0; |
| while (ai < a.length && bi < b.length) { |
| cmp(a[ai], b[bi]) <= 0 |
| ? r[i++] = a[ai++] |
| : r[i++] = b[bi++]; |
| } |
| if (ai < a.length) r.push.apply(r, a.slice(ai)); |
| if (bi < b.length) r.push.apply(r, b.slice(bi)); |
| return r; |
| }; |
| function _ms(a) { |
| if (a.length <= 1) |
| return a; |
| var m = Math.floor(a.length / 2), left = a.slice(0, m), right = a.slice(m); |
| left = _ms(left); |
| right = _ms(right); |
| return merge(left, right); |
| }; |
| return _ms(array); |
| }; |
| |
| function set_difference(a, b) { |
| return a.filter(function(el){ |
| return b.indexOf(el) < 0; |
| }); |
| }; |
| |
| function set_intersection(a, b) { |
| return a.filter(function(el){ |
| return b.indexOf(el) >= 0; |
| }); |
| }; |
| |
| // this function is taken from Acorn [1], written by Marijn Haverbeke |
| // [1] https://github.com/marijnh/acorn |
| function makePredicate(words) { |
| if (!(words instanceof Array)) words = words.split(" "); |
| var f = "", cats = []; |
| out: for (var i = 0; i < words.length; ++i) { |
| for (var j = 0; j < cats.length; ++j) |
| if (cats[j][0].length == words[i].length) { |
| cats[j].push(words[i]); |
| continue out; |
| } |
| cats.push([words[i]]); |
| } |
| function quote(word) { |
| return JSON.stringify(word).replace(/[\u2028\u2029]/g, function(s) { |
| switch (s) { |
| case "\u2028": return "\\u2028"; |
| case "\u2029": return "\\u2029"; |
| } |
| return s; |
| }); |
| } |
| function compareTo(arr) { |
| if (arr.length == 1) return f += "return str === " + quote(arr[0]) + ";"; |
| f += "switch(str){"; |
| for (var i = 0; i < arr.length; ++i) f += "case " + quote(arr[i]) + ":"; |
| f += "return true}return false;"; |
| } |
| // When there are more than three length categories, an outer |
| // switch first dispatches on the lengths, to save on comparisons. |
| if (cats.length > 3) { |
| cats.sort(function(a, b) {return b.length - a.length;}); |
| f += "switch(str.length){"; |
| for (var i = 0; i < cats.length; ++i) { |
| var cat = cats[i]; |
| f += "case " + cat[0].length + ":"; |
| compareTo(cat); |
| } |
| f += "}"; |
| // Otherwise, simply generate a flat `switch` statement. |
| } else { |
| compareTo(words); |
| } |
| return new Function("str", f); |
| }; |
| |
| function all(array, predicate) { |
| for (var i = array.length; --i >= 0;) |
| if (!predicate(array[i])) |
| return false; |
| return true; |
| }; |
| |
| function Dictionary() { |
| this._values = Object.create(null); |
| this._size = 0; |
| }; |
| Dictionary.prototype = { |
| set: function(key, val) { |
| if (!this.has(key)) ++this._size; |
| this._values["$" + key] = val; |
| return this; |
| }, |
| add: function(key, val) { |
| if (this.has(key)) { |
| this.get(key).push(val); |
| } else { |
| this.set(key, [ val ]); |
| } |
| return this; |
| }, |
| get: function(key) { return this._values["$" + key] }, |
| del: function(key) { |
| if (this.has(key)) { |
| --this._size; |
| delete this._values["$" + key]; |
| } |
| return this; |
| }, |
| has: function(key) { return ("$" + key) in this._values }, |
| each: function(f) { |
| for (var i in this._values) |
| f(this._values[i], i.substr(1)); |
| }, |
| size: function() { |
| return this._size; |
| }, |
| map: function(f) { |
| var ret = []; |
| for (var i in this._values) |
| ret.push(f(this._values[i], i.substr(1))); |
| return ret; |
| }, |
| toObject: function() { return this._values } |
| }; |
| Dictionary.fromObject = function(obj) { |
| var dict = new Dictionary(); |
| dict._size = merge(dict._values, obj); |
| return dict; |
| }; |
| |
| function HOP(obj, prop) { |
| return Object.prototype.hasOwnProperty.call(obj, prop); |
| } |
| |
| // return true if the node at the top of the stack (that means the |
| // innermost node in the current output) is lexically the first in |
| // a statement. |
| function first_in_statement(stack) { |
| var node = stack.parent(-1); |
| for (var i = 0, p; p = stack.parent(i); i++) { |
| if (p instanceof AST_Statement && p.body === node) |
| return true; |
| if ((p instanceof AST_Seq && p.car === node ) || |
| (p instanceof AST_Call && p.expression === node && !(p instanceof AST_New) ) || |
| (p instanceof AST_Dot && p.expression === node ) || |
| (p instanceof AST_Sub && p.expression === node ) || |
| (p instanceof AST_Conditional && p.condition === node ) || |
| (p instanceof AST_Binary && p.left === node ) || |
| (p instanceof AST_UnaryPostfix && p.expression === node )) |
| { |
| node = p; |
| } else { |
| return false; |
| } |
| } |
| } |