cloudstructs 0.9.12 → 0.9.14

package/node_modules/is-stream/readme.md

@@ -1,15 +1,13 @@
-# is-stream [![Build Status](https://travis-ci.org/sindresorhus/is-stream.svg?branch=master)](https://travis-ci.org/sindresorhus/is-stream)
+# is-stream
 
 > Check if something is a [Node.js stream](https://nodejs.org/api/stream.html)
 
-
 ## Install
 
 ```
-$ npm install --save is-stream
+$ npm install is-stream
 ```
 
-
 ## Usage
 
 ```js
@@ -23,20 +21,40 @@ isStream({});
 //=> false
 ```
 
-
 ## API
 
 ### isStream(stream)
 
+Returns a `boolean` for whether it's a [`Stream`](https://nodejs.org/api/stream.html#stream_stream).
+
 #### isStream.writable(stream)
 
+Returns a `boolean` for whether it's a [`stream.Writable`](https://nodejs.org/api/stream.html#stream_class_stream_writable).
+
 #### isStream.readable(stream)
 
+Returns a `boolean` for whether it's a [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+
 #### isStream.duplex(stream)
 
+Returns a `boolean` for whether it's a [`stream.Duplex`](https://nodejs.org/api/stream.html#stream_class_stream_duplex).
+
 #### isStream.transform(stream)
 
+Returns a `boolean` for whether it's a [`stream.Transform`](https://nodejs.org/api/stream.html#stream_class_stream_transform).
+
+## Related
+
+- [is-file-stream](https://github.com/jamestalmage/is-file-stream) - Detect if a stream is a file stream
 
-## License
+---
 
-MIT © [Sindre Sorhus](https://sindresorhus.com)
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-is-stream?utm_source=npm-is-stream&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>

package/node_modules/juice/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juice",
-  "version": "10.0.0",
+  "version": "10.0.1",
   "description": "Inlines css into html source",
   "bin": "bin/juice",
   "main": "index.js",
@@ -35,14 +35,14 @@
     "node": ">=10.0.0"
   },
   "dependencies": {
-    "cheerio": "^1.0.0-rc.12",
+    "cheerio": "1.0.0-rc.12",
     "commander": "^6.1.0",
     "mensch": "^0.3.4",
     "slick": "^1.12.2",
     "web-resource-inliner": "^6.0.1"
   },
   "devDependencies": {
-    "@types/node": "^18.15.3",
+    "@types/node": "^22.2.0",
     "batch": "0.6.1",
     "browserify": "^17.0.0",
     "cross-spawn": "^7.0.3",

package/node_modules/uglify-js/bin/uglifyjs

@@ -467,11 +467,14 @@ function run() {
     } else if (output) {
         var code;
         if (result.ast) {
-            var opts = {};
+            var output_options = {};
+            for (var name in UglifyJS.default_options("output")) {
+                if (name in options) output_options[name] = options[name];
+            }
             for (var name in options.output) {
-                if (!/^ast|code$/.test(name)) opts[name] = options.output[name];
+                if (!/^ast|code$/.test(name)) output_options[name] = options.output[name];
             }
-            code = UglifyJS.AST_Node.from_mozilla_ast(result.ast.to_mozilla_ast()).print_to_string(opts);
+            code = UglifyJS.AST_Node.from_mozilla_ast(result.ast.to_mozilla_ast()).print_to_string(output_options);
         } else {
             code = result.code;
         }

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;
@@ -637,14 +646,12 @@ 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 = {};
             tw.safe_ids = safe_ids;
         }
 
@@ -654,18 +661,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 +853,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;
@@ -1029,7 +1040,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 +1125,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 +1134,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 +1164,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 +1249,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 +1282,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 +1347,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);
             }
@@ -1376,11 +1394,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 +1418,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 +1524,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 +1565,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;
@@ -3281,7 +3304,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 +3321,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);
@@ -4090,7 +4123,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 +6481,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);
@@ -8042,6 +8052,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 +9342,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 +11080,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 +11097,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 +11122,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 +12118,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 +12142,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 +12653,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 +14230,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 +14330,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 +14401,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 +14415,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.2",
   "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 };