cloudstructs 0.9.13 → 0.9.15

package/node_modules/uglify-js/lib/compress.js

@@ -210,10 +210,19 @@ Compressor.prototype = new TreeTransformer(function(node, descend) {
     // output and performance.
     descend(node, this);
     var opt = node.optimize(this);
-    if (is_scope && opt === node && !this.has_directive("use asm") && !opt.pinned()) {
-        opt.drop_unused(this);
-        if (opt.merge_variables(this)) opt.drop_unused(this);
-        descend(opt, this);
+    if (is_scope) {
+        if (opt === node && !this.has_directive("use asm") && !opt.pinned()) {
+            opt.drop_unused(this);
+            if (opt.merge_variables(this)) opt.drop_unused(this);
+            descend(opt, this);
+        }
+        if (this.option("arrows") && is_arrow(opt) && opt.body.length == 1) {
+            var stat = opt.body[0];
+            if (stat instanceof AST_Return) {
+                opt.body.length = 0;
+                opt.value = stat.value;
+            }
+        }
     }
     if (opt === node) opt._squeezed = true;
     return opt;
@@ -595,7 +604,16 @@ Compressor.prototype.compress = function(node) {
                 d.single_use = false;
                 var fixed = d.fixed;
                 if (typeof fixed == "function") fixed = fixed();
-                if (fixed instanceof AST_Lambda && fixed.safe_ids !== undefined) return;
+                if (fixed instanceof AST_Lambda) {
+                    var safe_ids = fixed.safe_ids;
+                    switch (safe_ids) {
+                      case null:
+                      case false:
+                        return;
+                      default:
+                        if (safe_ids && safe_ids.seq !== tw.safe_ids.seq) return;
+                    }
+                }
                 d.fixed = false;
             });
         }
@@ -637,14 +655,13 @@ Compressor.prototype.compress = function(node) {
             scope.may_call_this = undefined;
         }
 
-        function push(tw, sequential) {
+        function push(tw, sequential, conditional) {
             var defined_ids = Object.create(tw.defined_ids);
-            var safe_ids = Object.create(tw.safe_ids);
-            if (!sequential) {
-                defined_ids.seq = {};
-                safe_ids.seq = {};
-            }
+            if (!sequential || conditional) defined_ids.seq = Object.create(null);
             tw.defined_ids = defined_ids;
+            var safe_ids = Object.create(tw.safe_ids);
+            if (!sequential) safe_ids.seq = {};
+            if (conditional) safe_ids.cond = true;
             tw.safe_ids = safe_ids;
         }
 
@@ -654,18 +671,22 @@ Compressor.prototype.compress = function(node) {
         }
 
         function access(tw, def) {
-            tw.defined_ids[def.id] = tw.defined_ids.seq;
+            var seq = tw.defined_ids.seq;
+            tw.defined_ids[def.id] = seq;
+            seq[def.id] = true;
         }
 
         function assign(tw, def) {
-            tw.assigned_ids[def.id] = tw.defined_ids.seq;
-            tw.defined_ids[def.id] = false;
+            var seq = tw.defined_ids.seq;
+            tw.assigned_ids[def.id] = seq;
+            seq[def.id] = false;
         }
 
         function safe_to_access(tw, def) {
             var seq = tw.defined_ids.seq;
             var defined = tw.defined_ids[def.id];
             if (defined !== seq) return false;
+            if (!defined[def.id]) return false;
             var assigned = tw.assigned_ids[def.id];
             return !assigned || assigned === seq;
         }
@@ -842,7 +863,7 @@ Compressor.prototype.compress = function(node) {
             var scanner = new TreeWalker(function(node) {
                 if (node instanceof AST_DefaultValue) {
                     reset_flags(node);
-                    push(tw, true);
+                    push(tw, true, true);
                     node.value.walk(tw);
                     pop(tw);
                     var save = fixed;
@@ -1002,7 +1023,7 @@ Compressor.prototype.compress = function(node) {
                     walk_assign();
                     right.parent_scope.resolve().fn_defs.push(right);
                     right.safe_ids = null;
-                    if (!ld.fixed || !node.write_only) mark_fn_def(tw, ld, right);
+                    if (!ld.fixed || !node.write_only || tw.safe_ids.cond) mark_fn_def(tw, ld, right);
                     return true;
                 }
                 if (scan) {
@@ -1029,7 +1050,7 @@ Compressor.prototype.compress = function(node) {
                     return walk_lazy();
                 }
                 var safe = safe_to_read(tw, ld);
-                if (lazy) push(tw, true);
+                if (lazy) push(tw, true, true);
                 right.walk(tw);
                 if (lazy) pop(tw);
                 if (safe && !left.in_arg && safe_to_assign(tw, ld)) {
@@ -1114,7 +1135,7 @@ Compressor.prototype.compress = function(node) {
             function walk_lazy() {
                 if (!lazy) return;
                 left.walk(tw);
-                push(tw, true);
+                push(tw, true, true);
                 right.walk(tw);
                 pop(tw);
                 return true;
@@ -1123,7 +1144,7 @@ Compressor.prototype.compress = function(node) {
         def(AST_Binary, function(tw) {
             if (!lazy_op[this.operator]) return;
             this.left.walk(tw);
-            push(tw, true);
+            push(tw, true, true);
             this.right.walk(tw);
             pop(tw);
             return true;
@@ -1153,7 +1174,7 @@ Compressor.prototype.compress = function(node) {
             }
             exp.walk(tw);
             var optional = node.optional;
-            if (optional) push(tw, true);
+            if (optional) push(tw, true, true);
             node.args.forEach(function(arg) {
                 arg.walk(tw);
             });
@@ -1238,16 +1259,16 @@ Compressor.prototype.compress = function(node) {
         });
         def(AST_Conditional, function(tw) {
             this.condition.walk(tw);
-            push(tw, true);
+            push(tw, true, true);
             this.consequent.walk(tw);
             pop(tw);
-            push(tw, true);
+            push(tw, true, true);
             this.alternative.walk(tw);
             pop(tw);
             return true;
         });
         def(AST_DefaultValue, function(tw) {
-            push(tw, true);
+            push(tw, true, true);
             this.value.walk(tw);
             pop(tw);
             this.name.walk(tw);
@@ -1271,7 +1292,14 @@ Compressor.prototype.compress = function(node) {
             descend();
             var node = this;
             var expr = node.expression;
-            if (!node.optional && expr instanceof AST_SymbolRef) access(tw, expr.definition());
+            if (!node.optional) {
+                while (expr instanceof AST_Assign && expr.operator == "=") {
+                    var lhs = expr.left;
+                    if (lhs instanceof AST_SymbolRef) access(tw, lhs.definition());
+                    expr = expr.right;
+                }
+                if (expr instanceof AST_SymbolRef) access(tw, expr.definition());
+            }
             return true;
         });
         def(AST_For, function(tw, descend, compressor) {
@@ -1329,11 +1357,11 @@ Compressor.prototype.compress = function(node) {
         });
         def(AST_If, function(tw) {
             this.condition.walk(tw);
-            push(tw, true);
+            push(tw, true, true);
             this.body.walk(tw);
             pop(tw);
             if (this.alternative) {
-                push(tw, true);
+                push(tw, true, true);
                 this.alternative.walk(tw);
                 pop(tw);
             }
@@ -1360,6 +1388,7 @@ Compressor.prototype.compress = function(node) {
         def(AST_LambdaDefinition, function(tw, descend, compressor) {
             var fn = this;
             var def = fn.name.definition();
+            if (!safe_to_trim(fn)) def.fixed = false;
             var parent = tw.parent();
             if (parent instanceof AST_ExportDeclaration || parent instanceof AST_ExportDefault) def.single_use = false;
             if (!safe_to_visit(tw, fn)) return true;
@@ -1376,11 +1405,16 @@ Compressor.prototype.compress = function(node) {
             var expr = node.expression;
             if (node.optional) {
                 expr.walk(tw);
-                push(tw, true);
+                push(tw, true, true);
                 node.property.walk(tw);
                 pop(tw);
             } else {
                 descend();
+                while (expr instanceof AST_Assign && expr.operator == "=") {
+                    var lhs = expr.left;
+                    if (lhs instanceof AST_SymbolRef) access(tw, lhs.definition());
+                    expr = expr.right;
+                }
                 if (expr instanceof AST_SymbolRef) access(tw, expr.definition());
             }
             return true;
@@ -1395,15 +1429,15 @@ Compressor.prototype.compress = function(node) {
                 branch.expression.walk(tw);
                 if (first) {
                     first = false;
-                    push(tw, true);
+                    push(tw, true, true);
                 }
-            })
+            });
             if (!first) pop(tw);
             walk_body(node, tw);
             return true;
         });
         def(AST_SwitchBranch, function(tw) {
-            push(tw, true);
+            push(tw, true, true);
             walk_body(this, tw);
             pop(tw);
             return true;
@@ -1501,7 +1535,7 @@ Compressor.prototype.compress = function(node) {
             }
             mark_fn_def(tw, d, value);
         });
-        def(AST_Template, function(tw, descend) {
+        def(AST_Template, function(tw) {
             var node = this;
             var tag = node.tag;
             if (!tag) return;
@@ -1542,14 +1576,14 @@ Compressor.prototype.compress = function(node) {
             walk_body(node, tw);
             pop(tw);
             if (node.bcatch) {
-                push(tw, true);
+                push(tw, true, true);
                 node.bcatch.walk(tw);
                 pop(tw);
             }
             if (node.bfinally) node.bfinally.walk(tw);
             return true;
         });
-        def(AST_Unary, function(tw, descend) {
+        def(AST_Unary, function(tw) {
             var node = this;
             if (!UNARY_POSTFIX[node.operator]) return;
             var exp = node.expression;
@@ -2700,7 +2734,7 @@ Compressor.prototype.compress = function(node) {
                 if (node instanceof AST_Function) {
                     return compressor.option("ie") && node.name && lvalues.has(node.name.name);
                 }
-                if (node instanceof AST_ObjectIdentity) return symbol_in_lvalues(node, parent);
+                if (node instanceof AST_ObjectIdentity) return symbol_in_lvalues(node);
                 if (node instanceof AST_PropAccess) {
                     var exp = node.expression;
                     if (compressor.option("unsafe")) {
@@ -2717,8 +2751,9 @@ Compressor.prototype.compress = function(node) {
                 }
                 if (node instanceof AST_Spread) return true;
                 if (node instanceof AST_SymbolRef) {
+                    var assign_direct = symbol_in_lvalues(node);
                     if (is_undeclared_ref(node) && node.is_declared(compressor)) return false;
-                    if (symbol_in_lvalues(node, parent)) return !is_direct_assignment(node, parent);
+                    if (assign_direct) return !is_direct_assignment(node, parent);
                     if (side_effects && may_modify(node)) return true;
                     var def = node.definition();
                     return (in_try || def.scope.resolve() !== scope) && !can_drop_symbol(node);
@@ -3281,7 +3316,16 @@ Compressor.prototype.compress = function(node) {
                 if (expr instanceof AST_Assign && expr.right.single_use) return;
                 var lhs_ids = Object.create(null);
                 var marker = new TreeWalker(function(node) {
-                    if (node instanceof AST_SymbolRef) lhs_ids[node.definition().id] = true;
+                    if (!(node instanceof AST_SymbolRef)) return;
+                    for (var level = 0, parent, child = node; parent = marker.parent(level++); child = parent) {
+                        if (is_direct_assignment(child, parent)) {
+                            if (parent instanceof AST_DestructuredKeyVal) parent = marker.parent(level++);
+                            continue;
+                        }
+                        lhs_ids[node.definition().id] = true;
+                        return;
+                    }
+                    lhs_ids[node.definition().id] = "a";
                 });
                 while (expr instanceof AST_Assign && expr.operator == "=") {
                     expr.left.walk(marker);
@@ -3289,6 +3333,7 @@ Compressor.prototype.compress = function(node) {
                 }
                 if (expr instanceof AST_ObjectIdentity) return rhs_exact_match;
                 if (expr instanceof AST_SymbolRef) {
+                    if (lhs_ids[expr.definition().id] === "a") return;
                     var value = expr.evaluate(compressor);
                     if (value === expr) return rhs_exact_match;
                     return rhs_fuzzy_match(value, rhs_exact_match);
@@ -3365,6 +3410,7 @@ Compressor.prototype.compress = function(node) {
                 var find_arguments = scope.uses_arguments && !compressor.has_directive("use strict");
                 var scan_toplevel = scope instanceof AST_Toplevel;
                 var tw = new TreeWalker(function(node) {
+                    if (node.inlined_node) node.inlined_node.walk(tw);
                     var value;
                     if (node instanceof AST_SymbolRef) {
                         value = node.fixed_value();
@@ -3512,17 +3558,10 @@ Compressor.prototype.compress = function(node) {
                     if (node instanceof AST_Symbol) {
                         var def = node.definition();
                         var scope = def.scope.resolve();
-                        var found = false;
-                        var avoid = def.orig.reduce(function(scopes, sym) {
+                        def.orig.forEach(function(sym) {
                             if (sym instanceof AST_SymbolDefun) {
                                 if (sym.scope !== scope) push_uniq(scopes, sym.scope);
-                            } else {
-                                found = true;
                             }
-                            return scopes;
-                        }, []);
-                        if (found) avoid.forEach(function(scope) {
-                            push_uniq(scopes, scope);
                         });
                     }
                 });
@@ -3580,7 +3619,7 @@ Compressor.prototype.compress = function(node) {
                 return true;
             }
 
-            function symbol_in_lvalues(sym, parent) {
+            function symbol_in_lvalues(sym) {
                 var lvalue = lvalues.get(sym.name);
                 if (!lvalue || all(lvalue, function(lhs) {
                     return !lhs;
@@ -4090,7 +4129,7 @@ Compressor.prototype.compress = function(node) {
                     changed = true;
                 }
             }
-            var loop = in_loop && in_try && in_try.bfinally ? "try" : in_loop;
+            var loop = in_loop && in_try ? "try" : in_loop;
             for (; index >= 0; index--) {
                 var inlined = statements[index].try_inline(compressor, block_scope, true, loop);
                 if (!inlined) continue;
@@ -6448,29 +6487,6 @@ Compressor.prototype.compress = function(node) {
         return self;
     });
 
-    function opt_arrow(self, compressor) {
-        if (!compressor.option("arrows")) return self;
-        drop_rest_farg(self, compressor);
-        if (self.value) self.body = [ self.first_statement() ];
-        var body = tighten_body(self.body, compressor);
-        switch (body.length) {
-          case 1:
-            var stat = body[0];
-            if (stat instanceof AST_Return) {
-                self.body.length = 0;
-                self.value = stat.value;
-                break;
-            }
-          default:
-            self.body = body;
-            self.value = null;
-            break;
-        }
-        return self;
-    }
-    OPT(AST_Arrow, opt_arrow);
-    OPT(AST_AsyncArrow, opt_arrow);
-
     OPT(AST_Function, function(self, compressor) {
         drop_rest_farg(self, compressor);
         self.body = tighten_body(self.body, compressor);
@@ -7253,6 +7269,10 @@ Compressor.prototype.compress = function(node) {
                     var def = node.definition();
                     var_defs[def.id] = (var_defs[def.id] || 0) + 1;
                     assignments.add(def.id, node);
+                    var fixed = node.fixed_value(true);
+                    if (fixed && fixed.tail_node().operator == "=") {
+                        verify_safe_usage(def, node, value_modified[def.id]);
+                    }
                     return true;
                 }
                 if (node instanceof AST_SymbolImport) {
@@ -8042,6 +8062,7 @@ Compressor.prototype.compress = function(node) {
                 if (node.write_only === "p" && node.right.may_throw_on_access(compressor, true)) return;
                 var assign = props.assign;
                 if (assign) {
+                    initializations.add(node_def.id, assign.left);
                     assign.write_only = true;
                     assign.walk(tw);
                 }
@@ -9331,14 +9352,22 @@ Compressor.prototype.compress = function(node) {
             return expressions === this.expressions ? this : make_sequence(this, expressions);
         });
         def(AST_Sub, function(compressor, first_in_statement) {
-            var expr = this.expression;
-            if (expr.may_throw_on_access(compressor)) return this;
-            var prop = this.property;
+            var self = this;
+            var expr = self.expression;
+            if (expr.may_throw_on_access(compressor)) return self;
+            var prop = self.property;
+            if (self.optional) {
+                prop = prop.drop_side_effect_free(compressor);
+                if (!prop) return expr.drop_side_effect_free(compressor, first_in_statement);
+                self = self.clone();
+                self.property = prop;
+                return self;
+            }
             expr = expr.drop_side_effect_free(compressor, first_in_statement);
             if (!expr) return prop.drop_side_effect_free(compressor, first_in_statement);
             prop = prop.drop_side_effect_free(compressor);
             if (!prop) return expr;
-            return make_sequence(this, [ expr, prop ]);
+            return make_sequence(self, [ expr, prop ]);
         });
         def(AST_SymbolRef, function(compressor) {
             return this.is_declared(compressor) && can_drop_symbol(this, compressor) ? null : this;
@@ -11061,6 +11090,7 @@ Compressor.prototype.compress = function(node) {
                     var node = make_sequence(self, exprs).optimize(compressor);
                     fn.inlined = save_inlined;
                     node = maintain_this_binding(parent, current, node);
+                    self.inlined_node = node;
                     if (replacing || best_of_expression(node, self) === node) {
                         refs.forEach(function(ref) {
                             ref.scope = exp === fn ? fn.parent_scope : exp.scope;
@@ -11077,6 +11107,12 @@ Compressor.prototype.compress = function(node) {
                             exprs.unshift(self.expression);
                             return make_sequence(self, exprs).drop_side_effect_free(compressor, first_in_statement);
                         };
+                        self.has_side_effects = function(compressor) {
+                            var self = this;
+                            var exprs = self.args.slice();
+                            exprs.unshift(self.expression);
+                            return make_sequence(self, exprs).has_side_effects(compressor);
+                        };
                     }
                 }
                 var arg_used, insert, in_loop, scope;
@@ -11096,6 +11132,19 @@ Compressor.prototype.compress = function(node) {
                 return make_sequence(self, convert_args()).optimize(compressor);
             }
         }
+        if (compressor.option("arrows")
+            && compressor.option("module")
+            && (exp instanceof AST_AsyncFunction || exp instanceof AST_Function)
+            && !exp.name
+            && !exp.uses_arguments
+            && !exp.pinned()
+            && !exp.contains_this()) {
+            var arrow = make_node(is_async(exp) ? AST_AsyncArrow : AST_Arrow, exp, exp);
+            arrow.init_vars(exp.parent_scope, exp);
+            arrow.variables.del("arguments");
+            self.expression = arrow.transform(compressor);
+            return self;
+        }
         if (compressor.option("drop_console")) {
             if (exp instanceof AST_PropAccess) {
                 var name = exp.expression;
@@ -12079,18 +12128,20 @@ Compressor.prototype.compress = function(node) {
           case "&&":
           case "||":
             // void 0 !== x && null !== x ---> null != x
-            // void 0 === x || null === x ---> null == x
+            // void 0 === x.a || null === x.a ---> null == x.a
             var left = self.left;
+            if (left.inlined_node) left = left.inlined_node;
             if (!(left instanceof AST_Binary)) break;
             if (left.operator != (self.operator == "&&" ? "!==" : "===")) break;
-            if (!(self.right instanceof AST_Binary)) break;
-            if (left.operator != self.right.operator) break;
-            if (is_undefined(left.left, compressor) && self.right.left instanceof AST_Null
-                || left.left instanceof AST_Null && is_undefined(self.right.left, compressor)) {
-                var expr = left.right;
-                if (expr instanceof AST_Assign && expr.operator == "=") expr = expr.left;
-                if (expr.has_side_effects(compressor)) break;
-                if (!expr.equals(self.right.right)) break;
+            var right = self.right;
+            if (right.inlined_node) right = right.inlined_node;
+            if (!(right instanceof AST_Binary)) break;
+            if (left.operator != right.operator) break;
+            if (is_undefined(left.left, compressor) && right.left instanceof AST_Null
+                || left.left instanceof AST_Null && is_undefined(right.left, compressor)) {
+                var expr = extract_lhs(left.right, compressor);
+                if (!repeatable(compressor, expr)) break;
+                if (!expr.equals(right.right)) break;
                 left.operator = left.operator.slice(0, -1);
                 left.left = make_node(AST_Null, self);
                 return left;
@@ -12101,7 +12152,7 @@ Compressor.prototype.compress = function(node) {
         var parent = compressor.parent();
         if (compressor.option("booleans")) {
             var lhs = extract_lhs(self.left, compressor);
-            if (lazy_op[self.operator] && !lhs.has_side_effects(compressor)) {
+            if (lazy_op[self.operator] && repeatable(compressor, lhs)) {
                 // a || a ---> a
                 // (a = x) && a --> a = x
                 if (lhs.equals(self.right)) {
@@ -12612,6 +12663,7 @@ Compressor.prototype.compress = function(node) {
         }
 
         function is_indexFn(node) {
+            while (node instanceof AST_Assign && node.operator == "=") node = node.right;
             return node.TYPE == "Call"
                 && node.expression instanceof AST_Dot
                 && indexFns[node.expression.property];
@@ -14188,8 +14240,8 @@ Compressor.prototype.compress = function(node) {
             if (fn.pinned()) return;
             if (is_generator(fn)) return;
             var arrow = is_arrow(fn);
-            if (arrow && fn.value) return;
-            if (fn.body[0] instanceof AST_Directive) return;
+            var fn_body = arrow && fn.value ? [ fn.first_statement() ] : fn.body;
+            if (fn_body[0] instanceof AST_Directive) return;
             if (fn.contains_this()) return;
             if (!scope) scope = find_scope(compressor);
             var defined = new Dictionary();
@@ -14288,7 +14340,7 @@ Compressor.prototype.compress = function(node) {
                     return !abort;
                 };
             }
-            if (verify_body && !all(fn.body, verify_body)) return;
+            if (verify_body && !all(fn_body, verify_body)) return;
             if (!safe_from_await_yield(fn, avoid_await_yield(compressor, scope))) return;
             fn.functions.each(function(def, name) {
                 scope.functions.set(name, def);
@@ -14359,7 +14411,7 @@ Compressor.prototype.compress = function(node) {
                 [].unshift.apply(def.orig, orig);
                 def.eliminated += orig.length;
             });
-            [].push.apply(body, in_loop ? fn.body.filter(function(stat) {
+            [].push.apply(body, in_loop ? fn_body.filter(function(stat) {
                 if (!(stat instanceof AST_LambdaDefinition)) return true;
                 var name = make_node(AST_SymbolVar, flatten_var(stat.name));
                 var def = name.definition();
@@ -14373,7 +14425,7 @@ Compressor.prototype.compress = function(node) {
                     }) ],
                 }));
                 return false;
-            }) : fn.body);
+            }) : fn_body);
             var inlined = make_node(AST_BlockStatement, call, { body: body });
             if (!no_return) {
                 if (async) scan_local_returns(inlined, function(node) {

package/node_modules/uglify-js/lib/minify.js

@@ -49,8 +49,9 @@ function parse_source_map(content) {
 function set_shorthand(name, options, keys) {
     keys.forEach(function(key) {
         if (options[key]) {
-            if (typeof options[key] != "object") options[key] = {};
-            if (!(name in options[key])) options[key][name] = options[name];
+            var defs = {};
+            defs[name] = options[name];
+            options[key] = defaults(options[key], defs);
         }
     });
 }
@@ -105,7 +106,7 @@ function minify(files, options) {
         if (options.keep_fargs) set_shorthand("keep_fargs", options, [ "compress", "mangle", "rename" ]);
         if (options.keep_fnames) set_shorthand("keep_fnames", options, [ "compress", "mangle", "rename" ]);
         if (options.module === undefined && !options.ie) options.module = true;
-        if (options.module) set_shorthand("module", options, [ "compress", "parse" ]);
+        if (options.module) set_shorthand("module", options, [ "compress", "output", "parse" ]);
         if (options.toplevel !== undefined) set_shorthand("toplevel", options, [ "compress", "mangle", "rename" ]);
         if (options.v8) set_shorthand("v8", options, [ "mangle", "output", "rename" ]);
         if (options.webkit) set_shorthand("webkit", options, [ "compress", "mangle", "output", "rename" ]);

package/node_modules/uglify-js/lib/output.js

@@ -63,6 +63,7 @@ function OutputStream(options) {
         inline_script    : true,
         keep_quoted_props: false,
         max_line_len     : false,
+        module           : false,
         preamble         : null,
         preserve_line    : false,
         quote_keys       : false,
@@ -140,12 +141,22 @@ function OutputStream(options) {
 
     reset();
     var to_utf8 = options.ascii_only ? function(str, identifier) {
-        if (identifier) str = str.replace(/[\ud800-\udbff][\udc00-\udfff]/g, function(ch) {
+        if (identifier || options.module) str = str.replace(/[\ud800-\udbff][\udc00-\udfff]/g, function(ch) {
             return "\\u{" + (ch.charCodeAt(0) - 0xd7c0 << 10 | ch.charCodeAt(1) - 0xdc00).toString(16) + "}";
         });
-        return str.replace(/[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
-            var code = ch.charCodeAt(0).toString(16);
+        return str.replace(/[\u0000-\u001f\u007f-\uffff]/g, function(s, i) {
+            var code = s.charCodeAt(0).toString(16);
             if (code.length <= 2 && !identifier) {
+                switch (s) {
+                  case "\n": return "\\n";
+                  case "\r": return "\\r";
+                  case "\t": return "\\t";
+                  case "\b": return "\\b";
+                  case "\f": return "\\f";
+                  case "\x0B": return options.ie ? "\\x0B" : "\\v";
+                  case "\0":
+                    return /[0-9]/.test(str.charAt(i+1)) ? "\\x00" : "\\0";
+                }
                 while (code.length < 2) code = "0" + code;
                 return "\\x" + code;
             } else {
@@ -1788,12 +1799,12 @@ function OutputStream(options) {
         if (self.tag) self.tag.print(output);
         output.print("`");
         for (var i = 0; i < self.expressions.length; i++) {
-            output.print(self.strings[i]);
+            output.print(output.to_utf8(self.strings[i]));
             output.print("${");
             self.expressions[i].print(output);
             output.print("}");
         }
-        output.print(self.strings[i]);
+        output.print(output.to_utf8(self.strings[i]));
         output.print("`");
     });
     DEFPRINT(AST_BigInt, function(output) {

package/node_modules/uglify-js/package.json

@@ -3,7 +3,7 @@
   "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.19.0",
+  "version": "3.19.3",
   "engines": {
     "node": ">=0.8.0"
   },

package/node_modules/uglify-js/tools/node.js

@@ -97,7 +97,12 @@ function infer_options(options) {
     return result.error && result.error.defs;
 }
 
-exports.default_options = function() {
+exports.default_options = function(component) {
+    if (component) {
+        var options = { module: false };
+        options[component] = { 0: 0 };
+        return infer_options(options);
+    }
     var defs = infer_options({ 0: 0 });
     Object.keys(defs).forEach(function(component) {
         var options = { module: false };