terser 5.0.0 → 5.3.0

package/lib/ast.js

@@ -527,7 +527,7 @@ var AST_PrefixedTemplateString = DEFNODE("PrefixedTemplateString", "template_str
     $documentation: "A templatestring with a prefix, such as String.raw`foobarbaz`",
     $propdoc: {
         template_string: "[AST_TemplateString] The template string",
-        prefix: "[AST_SymbolRef|AST_PropAccess] The prefix, which can be a symbol such as `foo` or a dotted expression such as `String.raw`."
+        prefix: "[AST_Node] The prefix, which will get called."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function () {
@@ -864,6 +864,10 @@ var AST_Import = DEFNODE("Import", "imported_name imported_names module_name", {
     },
 });
 
+var AST_ImportMeta = DEFNODE("ImportMeta", null, {
+    $documentation: "A reference to import.meta",
+});
+
 var AST_Export = DEFNODE("Export", "exported_definition exported_value is_default exported_names module_name", {
     $documentation: "An `export` statement",
     $propdoc: {
@@ -904,11 +908,12 @@ var AST_Export = DEFNODE("Export", "exported_definition exported_value is_defaul
 
 /* -----[ OTHER ]----- */
 
-var AST_Call = DEFNODE("Call", "expression args _annotations", {
+var AST_Call = DEFNODE("Call", "expression args optional _annotations", {
     $documentation: "A function call expression",
     $propdoc: {
         expression: "[AST_Node] expression to invoke as function",
         args: "[AST_Node*] array of arguments",
+        optional: "[boolean] whether this is an optional call (IE ?.() )",
         _annotations: "[number] bitfield containing information about the call"
     },
     initialize() {
@@ -952,11 +957,13 @@ var AST_Sequence = DEFNODE("Sequence", "expressions", {
     },
 });
 
-var AST_PropAccess = DEFNODE("PropAccess", "expression property", {
+var AST_PropAccess = DEFNODE("PropAccess", "expression property optional", {
     $documentation: "Base class for property access expressions, i.e. `a.foo` or `a[\"foo\"]`",
     $propdoc: {
         expression: "[AST_Node] the “container” expression",
-        property: "[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node"
+        property: "[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node",
+
+        optional: "[boolean] whether this is an optional property access (IE ?.)"
     }
 });
 
@@ -989,6 +996,21 @@ var AST_Sub = DEFNODE("Sub", null, {
     },
 }, AST_PropAccess);
 
+var AST_Chain = DEFNODE("Chain", "expression", {
+    $documentation: "A chain expression like a?.b?.(c)?.[d]",
+    $propdoc: {
+        expression: "[AST_Call|AST_Dot|AST_Sub] chain element."
+    },
+    _walk: function (visitor) {
+        return visitor._visit(this, function() {
+            this.expression._walk(visitor);
+        });
+    },
+    _children_backwards(push) {
+        push(this.expression);
+    },
+});
+
 var AST_Unary = DEFNODE("Unary", "operator expression", {
     $documentation: "Base class for unary expressions",
     $propdoc: {
@@ -1610,6 +1632,7 @@ export {
     AST_Call,
     AST_Case,
     AST_Catch,
+    AST_Chain,
     AST_Class,
     AST_ClassExpression,
     AST_ClassProperty,
@@ -1642,6 +1665,7 @@ export {
     AST_Hole,
     AST_If,
     AST_Import,
+    AST_ImportMeta,
     AST_Infinity,
     AST_IterationStatement,
     AST_Jump,

package/lib/compress/index.js

@@ -78,6 +78,7 @@ import {
     AST_Call,
     AST_Case,
     AST_Catch,
+    AST_Chain,
     AST_Class,
     AST_ClassExpression,
     AST_ClassProperty,
@@ -216,7 +217,7 @@ const set_flag = (node, flag) => { node.flags |= flag; };
 const clear_flag = (node, flag) => { node.flags &= ~flag; };
 
 class Compressor extends TreeWalker {
-    constructor(options, false_by_default) {
+    constructor(options, { false_by_default = false, mangle_options = false }) {
         super();
         if (options.defaults !== undefined && !options.defaults) false_by_default = true;
         this.options = defaults(options, {
@@ -274,7 +275,7 @@ class Compressor extends TreeWalker {
             unsafe_regexp : false,
             unsafe_undefined: false,
             unused        : !false_by_default,
-            warnings      : false,  // legacy
+            warnings      : false  // legacy
         }, true);
         var global_defs = this.options["global_defs"];
         if (typeof global_defs == "object") for (var key in global_defs) {
@@ -324,6 +325,7 @@ class Compressor extends TreeWalker {
         this.sequences_limit = sequences == 1 ? 800 : sequences | 0;
         this.evaluated_regexps = new Map();
         this._toplevel = undefined;
+        this.mangle_options = mangle_options;
     }
 
     option(key) {
@@ -792,13 +794,53 @@ function is_modified(compressor, tw, node, value, level, immutable) {
         pop(tw);
         return true;
     });
+
+    def_reduce_vars(AST_Chain, function(tw, descend) {
+        // Chains' conditions apply left-to-right, cumulatively.
+        // If we walk normally we don't go in that order because we would pop before pushing again
+        // Solution: AST_PropAccess and AST_Call push when they are optional, and never pop.
+        // Then we pop everything when they are done being walked.
+        const safe_ids = tw.safe_ids;
+
+        descend();
+
+        // Unroll back to start
+        tw.safe_ids = safe_ids;
+        return true;
+    });
+    def_reduce_vars(AST_Call, function (tw) {
+        // TODO this block should just be { return } but
+        // for some reason the _walk function of AST_Call walks the callee last
+
+        this.expression.walk(tw);
+
+        if (this.optional) {
+            // Never pop -- it's popped at AST_Chain above
+            push(tw);
+        }
+
+        for (const arg of this.args) arg.walk(tw);
+
+        return true;
+    });
+    def_reduce_vars(AST_PropAccess, function (tw) {
+        if (!this.optional) return;
+
+        this.expression.walk(tw);
+
+        // Never pop -- it's popped at AST_Chain above
+        push(tw);
+
+        if (this.property instanceof AST_Node) this.property.walk(tw);
+
+        return true;
+    });
     def_reduce_vars(AST_Default, function(tw, descend) {
         push(tw);
         descend();
         pop(tw);
         return true;
     });
-
     function mark_lambda(tw, descend, compressor) {
         clear_flag(this, INLINED);
         push(tw);
@@ -2480,6 +2522,9 @@ function is_undefined(node, compressor) {
         if (this.expression instanceof AST_Function && this.property == "prototype") return false;
         return true;
     });
+    def_may_throw_on_access(AST_Chain, function(compressor) {
+        return this.expression._dot_throw(compressor);
+    });
     def_may_throw_on_access(AST_Sequence, function(compressor) {
         return this.tail_node()._dot_throw(compressor);
     });
@@ -2630,6 +2675,9 @@ function is_lhs(node, parent) {
         }));
     });
     def_find_defs(AST_Node, noop);
+    def_find_defs(AST_Chain, function(compressor, suffix) {
+        return this.expression._find_defs(compressor, suffix);
+    });
     def_find_defs(AST_Dot, function(compressor, suffix) {
         return this.expression._find_defs(compressor, "." + this.property + suffix);
     });
@@ -2963,16 +3011,13 @@ var static_fns = convert_to_predicate({
 
         var fixed = this.fixed_value();
         if (!fixed) return this;
-        var value;
-        if (HOP(fixed, "_eval")) {
-            value = fixed._eval();
-        } else {
-            reentrant_ref_eval.add(this);
-            value = fixed._eval(compressor, depth);
-            reentrant_ref_eval.delete(this);
 
-            if (value === fixed) return this;
-        }
+        reentrant_ref_eval.add(this);
+        const value = fixed._eval(compressor, depth);
+        reentrant_ref_eval.delete(this);
+
+        if (value === fixed) return this;
+
         if (value && typeof value == "object") {
             var escaped = this.definition().escaped;
             if (escaped && depth > escaped) return this;
@@ -3000,6 +3045,10 @@ var static_fns = convert_to_predicate({
         ],
     });
     def_eval(AST_PropAccess, function(compressor, depth) {
+        if (this.optional) {
+            const obj = this.expression._eval(compressor, depth);
+            if (obj == null) return undefined;
+        }
         if (compressor.option("unsafe")) {
             var key = this.property;
             if (key instanceof AST_Node) {
@@ -3041,8 +3090,16 @@ var static_fns = convert_to_predicate({
         }
         return this;
     });
+    def_eval(AST_Chain, function(compressor, depth) {
+        const evaluated = this.expression._eval(compressor, depth);
+        return evaluated === this.expression ? this : evaluated;
+    });
     def_eval(AST_Call, function(compressor, depth) {
         var exp = this.expression;
+        if (this.optional) {
+            const callee = this.expression._eval(compressor, depth);
+            if (callee == null) return undefined;
+        }
         if (compressor.option("unsafe") && exp instanceof AST_PropAccess) {
             var key = exp.property;
             if (key instanceof AST_Node) {
@@ -3244,9 +3301,11 @@ const pure_prop_access_globals = new Set([
         return any(this.body, compressor);
     });
     def_has_side_effects(AST_Call, function(compressor) {
-        if (!this.is_expr_pure(compressor)
+        if (
+            !this.is_expr_pure(compressor)
             && (!this.expression.is_call_pure(compressor)
-                || this.expression.has_side_effects(compressor))) {
+                || this.expression.has_side_effects(compressor))
+        ) {
             return true;
         }
         return any(this.args, compressor);
@@ -3329,14 +3388,21 @@ const pure_prop_access_globals = new Set([
         return any(this.elements, compressor);
     });
     def_has_side_effects(AST_Dot, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
+        return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.has_side_effects(compressor);
     });
     def_has_side_effects(AST_Sub, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
+        if (this.optional && is_nullish(this.expression)) {
+            return false;
+        }
+
+        return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.has_side_effects(compressor)
             || this.property.has_side_effects(compressor);
     });
+    def_has_side_effects(AST_Chain, function (compressor) {
+        return this.expression.has_side_effects(compressor);
+    });
     def_has_side_effects(AST_Sequence, function(compressor) {
         return any(this.expressions, compressor);
     });
@@ -3396,6 +3462,7 @@ const pure_prop_access_globals = new Set([
         return any(this.body, compressor);
     });
     def_may_throw(AST_Call, function(compressor) {
+        if (this.optional && is_nullish(this.expression)) return false;
         if (any(this.args, compressor)) return true;
         if (this.is_expr_pure(compressor)) return false;
         if (this.expression.may_throw(compressor)) return true;
@@ -3414,10 +3481,6 @@ const pure_prop_access_globals = new Set([
     def_may_throw(AST_Definitions, function(compressor) {
         return any(this.definitions, compressor);
     });
-    def_may_throw(AST_Dot, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
-            || this.expression.may_throw(compressor);
-    });
     def_may_throw(AST_If, function(compressor) {
         return this.condition.may_throw(compressor)
             || this.body && this.body.may_throw(compressor)
@@ -3457,11 +3520,20 @@ const pure_prop_access_globals = new Set([
     def_may_throw(AST_SimpleStatement, function(compressor) {
         return this.body.may_throw(compressor);
     });
+    def_may_throw(AST_Dot, function(compressor) {
+        return !this.optional && this.expression.may_throw_on_access(compressor)
+            || this.expression.may_throw(compressor);
+    });
     def_may_throw(AST_Sub, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
+        if (this.optional && is_nullish(this.expression)) return false;
+
+        return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.may_throw(compressor)
             || this.property.may_throw(compressor);
     });
+    def_may_throw(AST_Chain, function(compressor) {
+        return this.expression.may_throw(compressor);
+    });
     def_may_throw(AST_Switch, function(compressor) {
         return this.expression.may_throw(compressor)
             || any(this.body, compressor);
@@ -3619,9 +3691,9 @@ def_optimize(AST_Block, function(self, compressor) {
 
 function can_be_extracted_from_if_block(node) {
     return !(
-        node instanceof AST_Const ||
-        node instanceof AST_Let ||
-        node instanceof AST_Class
+        node instanceof AST_Const
+        || node instanceof AST_Let
+        || node instanceof AST_Class
     );
 }
 
@@ -4188,7 +4260,9 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
                 && !top_retain(def)
                 && (value = sym.fixed_value()) === node.value
                 && value instanceof AST_Object
-                && !value.properties.some(prop => prop.computed_key())
+                && !value.properties.some(prop =>
+                    prop instanceof AST_Expansion || prop.computed_key()
+                )
             ) {
                 descend(node, this);
                 const defs = new Map();
@@ -4255,6 +4329,10 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     def_drop_side_effect_free(AST_Constant, return_null);
     def_drop_side_effect_free(AST_This, return_null);
     def_drop_side_effect_free(AST_Call, function(compressor, first_in_statement) {
+        if (this.optional && is_nullish(this.expression)) {
+            return make_node(AST_Undefined, this);
+        }
+
         if (!this.is_expr_pure(compressor)) {
             if (this.expression.is_call_pure(compressor)) {
                 var exprs = this.args.slice();
@@ -4395,17 +4473,28 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
         return values && make_sequence(this, values);
     });
     def_drop_side_effect_free(AST_Dot, function(compressor, first_in_statement) {
+        if (this.optional) {
+            return is_nullish(this.expression) ? make_node(AST_Undefined, this) : this;
+        }
         if (this.expression.may_throw_on_access(compressor)) return this;
+
         return this.expression.drop_side_effect_free(compressor, first_in_statement);
     });
     def_drop_side_effect_free(AST_Sub, function(compressor, first_in_statement) {
+        if (this.optional) {
+            return is_nullish(this.expression) ? make_node(AST_Undefined, this): this;
+        }
         if (this.expression.may_throw_on_access(compressor)) return this;
+
         var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
         if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement);
         var property = this.property.drop_side_effect_free(compressor);
         if (!property) return expression;
         return make_sequence(this, [ expression, property ]);
     });
+    def_drop_side_effect_free(AST_Chain, function (compressor, first_in_statement) {
+        return this.expression.drop_side_effect_free(compressor, first_in_statement);
+    });
     def_drop_side_effect_free(AST_Sequence, function(compressor) {
         var last = this.tail_node();
         var expr = last.drop_side_effect_free(compressor);
@@ -4946,6 +5035,10 @@ def_optimize(AST_Call, function(self, compressor) {
         }
     }
 
+    if (self.optional && is_nullish(fn)) {
+        return make_node(AST_Undefined, self);
+    }
+
     var is_func = fn instanceof AST_Lambda;
 
     if (is_func && fn.pinned()) return self;
@@ -5157,6 +5250,7 @@ def_optimize(AST_Call, function(self, compressor) {
                 return make_node(AST_Call, self, {
                     expression: make_node(AST_Dot, exp, {
                         expression: exp.expression,
+                        optional: false,
                         property: "call"
                     }),
                     args: args
@@ -5203,7 +5297,9 @@ def_optimize(AST_Call, function(self, compressor) {
                 var ast = parse(code);
                 var mangle = { ie8: compressor.option("ie8") };
                 ast.figure_out_scope(mangle);
-                var comp = new Compressor(compressor.options);
+                var comp = new Compressor(compressor.options, {
+                    mangle_options: compressor.mangle_options
+                });
                 ast = ast.transform(comp);
                 ast.figure_out_scope(mangle);
                 base54.reset();
@@ -6285,7 +6381,8 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
         let single_use = def.single_use
             && !(parent instanceof AST_Call
                 && (parent.is_expr_pure(compressor))
-                    || has_annotation(parent, _NOINLINE));
+                    || has_annotation(parent, _NOINLINE))
+            && !(fixed instanceof AST_Defun && parent instanceof AST_Export);
 
         if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
             if (retain_top_func(fixed, compressor)) {
@@ -6386,8 +6483,8 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
             }
 
             if (replace) {
-                const name_length = def.name.length;
-                const replace_size = replace.size();
+                const name_length = self.size(compressor);
+                const replace_size = replace.size(compressor);
 
                 let overhead = 0;
                 if (compressor.option("unused") && !compressor.exposed(def)) {
@@ -6592,6 +6689,10 @@ function is_nullish(node) {
             && (fixed = node.definition().fixed) instanceof AST_Node
             && is_nullish(fixed)
         )
+        // Recurse into those optional chains!
+        || node instanceof AST_PropAccess && node.optional && is_nullish(node.expression)
+        || node instanceof AST_Call && node.optional && is_nullish(node.expression)
+        || node instanceof AST_Chain && is_nullish(node.expression)
     );
 }
 
@@ -6974,6 +7075,41 @@ function safe_to_flatten(value, compressor) {
     return compressor.parent() instanceof AST_New;
 }
 
+AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
+    if (!compressor.option("properties")) return;
+    var arrows = compressor.option("unsafe_arrows") && compressor.option("ecma") >= 2015;
+    var expr = this.expression;
+    if (expr instanceof AST_Object) {
+        var props = expr.properties;
+        for (var i = props.length; --i >= 0;) {
+            var prop = props[i];
+            if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
+                if (!props.every((prop) => {
+                    return prop instanceof AST_ObjectKeyVal
+                        || arrows && prop instanceof AST_ConciseMethod && !prop.is_generator;
+                })) break;
+                if (!safe_to_flatten(prop.value, compressor)) break;
+                return make_node(AST_Sub, this, {
+                    expression: make_node(AST_Array, expr, {
+                        elements: props.map(function(prop) {
+                            var v = prop.value;
+                            if (v instanceof AST_Accessor) v = make_node(AST_Function, v, v);
+                            var k = prop.key;
+                            if (k instanceof AST_Node && !(k instanceof AST_SymbolMethod)) {
+                                return make_sequence(prop, [ k, v ]);
+                            }
+                            return v;
+                        })
+                    }),
+                    property: make_node(AST_Number, this, {
+                        value: i
+                    })
+                });
+            }
+        }
+    }
+});
+
 def_optimize(AST_Sub, function(self, compressor) {
     var expr = self.expression;
     var prop = self.property;
@@ -6996,6 +7132,7 @@ def_optimize(AST_Sub, function(self, compressor) {
                 && property.length <= prop.size() + 1) {
                 return make_node(AST_Dot, self, {
                     expression: expr,
+                    optional: self.optional,
                     property: property,
                     quote: prop.quote,
                 }).optimize(compressor);
@@ -7098,6 +7235,14 @@ def_optimize(AST_Sub, function(self, compressor) {
         ev = make_node_from_constant(ev, self).optimize(compressor);
         return best_of(compressor, ev, self);
     }
+    if (self.optional && is_nullish(self.expression)) {
+        return make_node(AST_Undefined, self);
+    }
+    return self;
+});
+
+def_optimize(AST_Chain, function (self, compressor) {
+    self.expression = self.expression.optimize(compressor);
     return self;
 });
 
@@ -7114,41 +7259,6 @@ AST_Lambda.DEFMETHOD("contains_this", function() {
     });
 });
 
-AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
-    if (!compressor.option("properties")) return;
-    var arrows = compressor.option("unsafe_arrows") && compressor.option("ecma") >= 2015;
-    var expr = this.expression;
-    if (expr instanceof AST_Object) {
-        var props = expr.properties;
-        for (var i = props.length; --i >= 0;) {
-            var prop = props[i];
-            if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
-                if (!props.every((prop) => {
-                    return prop instanceof AST_ObjectKeyVal
-                        || arrows && prop instanceof AST_ConciseMethod && !prop.is_generator;
-                })) break;
-                if (!safe_to_flatten(prop.value, compressor)) break;
-                return make_node(AST_Sub, this, {
-                    expression: make_node(AST_Array, expr, {
-                        elements: props.map(function(prop) {
-                            var v = prop.value;
-                            if (v instanceof AST_Accessor) v = make_node(AST_Function, v, v);
-                            var k = prop.key;
-                            if (k instanceof AST_Node && !(k instanceof AST_SymbolMethod)) {
-                                return make_sequence(prop, [ k, v ]);
-                            }
-                            return v;
-                        })
-                    }),
-                    property: make_node(AST_Number, this, {
-                        value: i
-                    })
-                });
-            }
-        }
-    }
-});
-
 def_optimize(AST_Dot, function(self, compressor) {
     const parent = compressor.parent();
     if (is_lhs(self, parent)) return self;
@@ -7199,6 +7309,9 @@ def_optimize(AST_Dot, function(self, compressor) {
         ev = make_node_from_constant(ev, self).optimize(compressor);
         return best_of(compressor, ev, self);
     }
+    if (self.optional && is_nullish(self.expression)) {
+        return make_node(AST_Undefined, self);
+    }
     return self;
 });
 
@@ -7282,10 +7395,10 @@ def_optimize(AST_Function, function(self, compressor) {
         && !self.is_generator
         && !self.uses_arguments
         && !self.pinned()) {
-        const has_special_symbol = walk(self, node => {
+        const uses_this = walk(self, node => {
             if (node instanceof AST_This) return walk_abort;
         });
-        if (!has_special_symbol) return make_node(AST_Arrow, self, self).optimize(compressor);
+        if (!uses_this) return make_node(AST_Arrow, self, self).optimize(compressor);
     }
     return self;
 });

package/lib/equivalent-to.js

@@ -26,6 +26,7 @@ import {
     AST_ForOf,
     AST_If,
     AST_Import,
+    AST_ImportMeta,
     AST_Jump,
     AST_LabeledStatement,
     AST_Lambda,
@@ -209,6 +210,8 @@ AST_Import.prototype.shallow_cmp = mkshallow({
     imported_names: "exist"
 });
 
+AST_ImportMeta.prototype.shallow_cmp = pass_through;
+
 AST_Export.prototype.shallow_cmp = mkshallow({
     exported_definition: "exist",
     exported_value: "exist",

package/lib/minify.js

@@ -181,7 +181,11 @@ async function minify(files, options) {
         toplevel.expand_names(options.mangle);
     }
     if (timings) timings.compress = Date.now();
-    if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+    if (options.compress) {
+        toplevel = new Compressor(options.compress, {
+            mangle_options: options.mangle
+        }).compress(toplevel);
+    }
     if (timings) timings.scope = Date.now();
     if (options.mangle) toplevel.figure_out_scope(options.mangle);
     if (timings) timings.mangle = Date.now();

package/lib/mozilla-ast.js

@@ -59,6 +59,7 @@ import {
     AST_Call,
     AST_Case,
     AST_Catch,
+    AST_Chain,
     AST_Class,
     AST_ClassExpression,
     AST_ClassProperty,
@@ -89,6 +90,7 @@ import {
     AST_Hole,
     AST_If,
     AST_Import,
+    AST_ImportMeta,
     AST_Label,
     AST_LabeledStatement,
     AST_LabelRef,
@@ -418,7 +420,15 @@ import {
                 start      : my_start_token(M),
                 end        : my_end_token(M),
                 property   : M.computed ? from_moz(M.property) : M.property.name,
-                expression : from_moz(M.object)
+                expression : from_moz(M.object),
+                optional   : M.optional || false
+            });
+        },
+        ChainExpression: function(M) {
+            return new AST_Chain({
+                start      : my_start_token(M),
+                end        : my_end_token(M),
+                expression : from_moz(M.expression)
             });
         },
         SwitchCase: function(M) {
@@ -545,6 +555,11 @@ import {
                     start: my_start_token(M),
                     end: my_end_token(M)
                 });
+            } else if (M.meta.name === "import" && M.property.name === "meta") {
+                return new AST_ImportMeta({
+                    start: my_start_token(M),
+                    end: my_end_token(M)
+                });
             }
         },
         Identifier: function(M) {
@@ -629,7 +644,7 @@ import {
     map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
     map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative");
     map("NewExpression", AST_New, "callee>expression, arguments@args");
-    map("CallExpression", AST_Call, "callee>expression, arguments@args");
+    map("CallExpression", AST_Call, "callee>expression, optional=optional, arguments@args");
 
     def_to_moz(AST_Toplevel, function To_Moz_Program(M) {
         return to_moz_scope("Program", M);
@@ -836,6 +851,20 @@ import {
         };
     });
 
+    def_to_moz(AST_ImportMeta, function To_Moz_MetaProperty() {
+        return {
+            type: "MetaProperty",
+            meta: {
+                type: "Identifier",
+                name: "import"
+            },
+            property: {
+                type: "Identifier",
+                name: "meta"
+            }
+        };
+    });
+
     def_to_moz(AST_Sequence, function To_Moz_SequenceExpression(M) {
         return {
             type: "SequenceExpression",
@@ -849,7 +878,15 @@ import {
             type: "MemberExpression",
             object: to_moz(M.expression),
             computed: isComputed,
-            property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property}
+            property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property},
+            optional: M.optional
+        };
+    });
+
+    def_to_moz(AST_Chain, function To_Moz_ChainExpression(M) {
+        return {
+            type: "ChainExpression",
+            expression: to_moz(M.expression)
         };
     });