terser 5.31.6 → 5.33.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## v5.33.0
+
+ - `reduce_vars` improved when dealing with hoisted function definitions (#1544)
+
+## v5.32.0
+
+ - `import("module")` can now be input and output from ESTree AST (#1557)
+ - `BigInt` literals can now be input and output from ESTree AST (#1555)
+ - `typeof` an object or array (`typeof {}` and `typeof []`) can now be statically evaluated. (#1546)
+
 ## v5.31.6
  - Retain side effects in a `case` when the expression is a sequence (comma) expression
 

package/dist/bundle.min.js

@@ -7571,6 +7571,19 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             });
         },
 
+        ImportExpression: function(M) {
+            return new AST_Call({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                expression: from_moz({
+                    type: "Identifier",
+                    name: "import"
+                }),
+                optional: false,
+                args: [from_moz(M.source)]
+            });
+        },
+
         ExportAllDeclaration: function(M) {
             var foreign_name = M.exported == null ? 
                 new AST_SymbolExportForeign({ name: "*" }) :
@@ -7638,6 +7651,11 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 args.value = { source, flags };
                 return new AST_RegExp(args);
             }
+            const bi = typeof M.value === "bigint" ? M.value.toString() : M.bigint;
+            if (typeof bi === "string") {
+                args.value = bi;
+                return new AST_BigInt(args);
+            }
             if (val === null) return new AST_Null(args);
             switch (typeof val) {
               case "string":
@@ -7705,14 +7723,6 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                         });
         },
 
-        BigIntLiteral(M) {
-            return new AST_BigInt({
-                start : my_start_token(M),
-                end   : my_end_token(M),
-                value : M.value
-            });
-        },
-
         EmptyStatement: function(M) {
             return new AST_EmptyStatement({
                 start: my_start_token(M),
@@ -8185,6 +8195,14 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         };
     });
     def_to_moz(AST_Call, function To_Moz_CallExpression(M) {
+        if (M.expression instanceof AST_SymbolRef && M.expression.name === "import") {
+            const [source] = M.args.map(to_moz);
+            return {
+                type: "ImportExpression",
+                source,
+            };
+        }
+
         return {
             type: "CallExpression",
             callee: to_moz(M.expression),
@@ -8730,8 +8748,13 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
     });
 
     def_to_moz(AST_BigInt, M => ({
-        type: "BigIntLiteral",
-        value: M.value
+        type: "Literal",
+        // value cannot be represented natively
+        // see: https://github.com/estree/estree/blob/master/es2020.md#bigintliteral
+        value: null,
+        // `M.value` is a string that may be a hex number representation.
+        // but "bigint" property should have only decimal digits
+        bigint: typeof BigInt === "function" ? BigInt(M.value).toString() : M.value,
     }));
 
     AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
@@ -13268,9 +13291,9 @@ function is_reachable(scope_node, defs) {
 }
 
 /** Check if a ref refers to the name of a function/class it's defined within */
-function is_recursive_ref(compressor, def) {
+function is_recursive_ref(tw, def) {
     var node;
-    for (var i = 0; node = compressor.parent(i); i++) {
+    for (var i = 0; node = tw.parent(i); i++) {
         if (node instanceof AST_Lambda || node instanceof AST_Class) {
             var name = node.name;
             if (name && name.definition() === def) {
@@ -14579,14 +14602,25 @@ def_eval(AST_Object, function (compressor, depth) {
 var non_converting_unary = makePredicate("! typeof void");
 def_eval(AST_UnaryPrefix, function (compressor, depth) {
     var e = this.expression;
-    // Function would be evaluated to an array and so typeof would
-    // incorrectly return 'object'. Hence making is a special case.
     if (compressor.option("typeofs")
-        && this.operator == "typeof"
-        && (e instanceof AST_Lambda
+        && this.operator == "typeof") {
+        // Function would be evaluated to an array and so typeof would
+        // incorrectly return 'object'. Hence making is a special case.
+        if (e instanceof AST_Lambda
             || e instanceof AST_SymbolRef
-            && e.fixed_value() instanceof AST_Lambda)) {
-        return typeof function () { };
+            && e.fixed_value() instanceof AST_Lambda) {
+            return typeof function () { };
+        }
+        if (
+            (e instanceof AST_Object
+                || e instanceof AST_Array
+                || (e instanceof AST_SymbolRef
+                    && (e.fixed_value() instanceof AST_Object
+                        || e.fixed_value() instanceof AST_Array)))
+            && !e.has_side_effects(compressor)
+        ) {
+            return typeof {};
+        }
     }
     if (!non_converting_unary.has(this.operator))
         depth++;
@@ -16113,28 +16147,50 @@ function mark_lambda(tw, descend, compressor) {
  *   // use defined_after
  * }
  *
- * This function is called on the parent to handle this issue.
+ * Or even indirectly:
+ *
+ * B();
+ * var defined_after = true;
+ * function A() {
+ *   // use defined_after
+ * }
+ * function B() {
+ *   A();
+ * }
+ *
+ * Access a variable before declaration will either throw a ReferenceError
+ * (if the variable is declared with `let` or `const`),
+ * or get an `undefined` (if the variable is declared with `var`).
+ *
+ * If the variable is inlined into the function, the behavior will change.
+ *
+ * This function is called on the parent to disallow inlining of such variables,
  */
 function handle_defined_after_hoist(parent) {
     const defuns = [];
     walk(parent, node => {
         if (node === parent) return;
-        if (node instanceof AST_Defun) defuns.push(node);
+        if (node instanceof AST_Defun) {
+            defuns.push(node);
+            return true;
+        }
         if (
             node instanceof AST_Scope
             || node instanceof AST_SimpleStatement
         ) return true;
     });
 
+    // `defun` id to array of `defun` it uses
+    const defun_dependencies_map = new Map();
+    // `defun` id to array of enclosing `def` that are used by the function
+    const dependencies_map = new Map();
+    // all symbol ids that will be tracked for read/write
     const symbols_of_interest = new Set();
     const defuns_of_interest = new Set();
-    const potential_conflicts = [];
 
     for (const defun of defuns) {
         const fname_def = defun.name.definition();
-        const found_self_ref_in_other_defuns = defuns.some(
-            d => d !== defun && d.enclosed.indexOf(fname_def) !== -1
-        );
+        const enclosing_defs = [];
 
         for (const def of defun.enclosed) {
             if (
@@ -16145,93 +16201,107 @@ function handle_defined_after_hoist(parent) {
                 continue;
             }
 
-            // defun is hoisted, so always safe
+            symbols_of_interest.add(def.id);
+
+            // found a reference to another function
             if (
                 def.assignments === 0
                 && def.orig.length === 1
                 && def.orig[0] instanceof AST_SymbolDefun
             ) {
-                continue;
-            }
+                defuns_of_interest.add(def.id);
+                symbols_of_interest.add(def.id);
+
+                defuns_of_interest.add(fname_def.id);
+                symbols_of_interest.add(fname_def.id);
+
+                if (!defun_dependencies_map.has(fname_def.id)) {
+                    defun_dependencies_map.set(fname_def.id, []);
+                }
+                defun_dependencies_map.get(fname_def.id).push(def.id);
 
-            if (found_self_ref_in_other_defuns) {
-                def.fixed = false;
                 continue;
             }
 
-            // for the slower checks below this loop
-            potential_conflicts.push({ defun, def, fname_def });
-            symbols_of_interest.add(def.id);
+            enclosing_defs.push(def);
+        }
+
+        if (enclosing_defs.length) {
+            dependencies_map.set(fname_def.id, enclosing_defs);
+            defuns_of_interest.add(fname_def.id);
             symbols_of_interest.add(fname_def.id);
-            defuns_of_interest.add(defun);
         }
     }
 
-    // linearize all symbols, and locate defs that are read after the defun
-    if (potential_conflicts.length) {
-        // All "symbols of interest", that is, defuns or defs, that we found.
-        // These are placed in order so we can check which is after which.
-        const found_symbols = [];
-        // Indices of `found_symbols` which are writes
-        const found_symbol_writes = new Set();
-        // Defun ranges are recorded because we don't care if a function uses the def internally
-        const defun_ranges = new Map();
+    // No defuns use outside constants
+    if (!dependencies_map.size) {
+        return;
+    }
+
+    // Increment to count "symbols of interest" (defuns or defs) that we found.
+    // These are tracked in AST order so we can check which is after which.
+    let symbol_index = 1;
+    // Map a defun ID to its first read (a `symbol_index`)
+    const defun_first_read_map = new Map();
+    // Map a symbol ID to its last write (a `symbol_index`)
+    const symbol_last_write_map = new Map();
 
-        let tw;
-        parent.walk((tw = new TreeWalker((node, descend) => {
-            if (node instanceof AST_Defun && defuns_of_interest.has(node)) {
-                const start = found_symbols.length;
-                descend();
-                const end = found_symbols.length;
+    walk_parent(parent, (node, walk_info) => {
+        if (node instanceof AST_Symbol && node.thedef) {
+            const id = node.definition().id;
 
-                defun_ranges.set(node, { start, end });
-                return true;
-            }
-            // if we found a defun on the list, mark IN_DEFUN=id and descend
+            symbol_index++;
 
-            if (node instanceof AST_Symbol && node.thedef) {
-                const id = node.definition().id;
-                if (symbols_of_interest.has(id)) {
-                    if (node instanceof AST_SymbolDeclaration || is_lhs(node, tw)) {
-                        found_symbol_writes.add(found_symbols.length);
-                    }
-                    found_symbols.push(id);
+            // Track last-writes to symbols
+            if (symbols_of_interest.has(id)) {
+                if (node instanceof AST_SymbolDeclaration || is_lhs(node, walk_info.parent())) {
+                    symbol_last_write_map.set(id, symbol_index);
                 }
             }
-        })));
 
-        for (const { def, defun, fname_def } of potential_conflicts) {
-            const defun_range = defun_ranges.get(defun);
+            // Track first-reads of defuns (refined later)
+            if (defuns_of_interest.has(id)) {
+                if (!defun_first_read_map.has(id) && !is_recursive_ref(walk_info, id)) {
+                    defun_first_read_map.set(id, symbol_index);
+                }
+            }
+        }
+    });
 
-            // find the index in `found_symbols`, with some special rules:
-            const find = (sym_id, starting_at = 0, must_be_write = false) => {
-                let index = starting_at;
+    // Refine `defun_first_read_map` to be as high as possible
+    for (const [defun, defun_first_read] of defun_first_read_map) {
+        // Update all depdencies of `defun`
+        const queue = new Set(defun_dependencies_map.get(defun));
+        for (const enclosed_defun of queue) {
+            let enclosed_defun_first_read = defun_first_read_map.get(enclosed_defun);
+            if (enclosed_defun_first_read != null && enclosed_defun_first_read < defun_first_read) {
+                continue;
+            }
 
-                for (;;) {
-                    index = found_symbols.indexOf(sym_id, index);
+            defun_first_read_map.set(enclosed_defun, defun_first_read);
 
-                    if (index === -1) {
-                        break;
-                    } else if (index >= defun_range.start && index < defun_range.end) {
-                        index = defun_range.end;
-                        continue;
-                    } else if (must_be_write && !found_symbol_writes.has(index)) {
-                        index++;
-                        continue;
-                    } else {
-                        break;
-                    }
-                }
+            for (const enclosed_enclosed_defun of defun_dependencies_map.get(enclosed_defun) || []) {
+                queue.add(enclosed_enclosed_defun);
+            }
+        }
+    }
 
-                return index;
-            };
+    // ensure write-then-read order, otherwise clear `fixed`
+    // This is safe because last-writes (found_symbol_writes) are assumed to be as late as possible, and first-reads (defun_first_read_map) are assumed to be as early as possible.
+    for (const [defun, defs] of dependencies_map) {
+        const defun_first_read = defun_first_read_map.get(defun);
+        if (defun_first_read === undefined) {
+            continue;
+        }
 
-            const read_defun_at = find(fname_def.id);
-            const wrote_def_at = find(def.id, read_defun_at + 1, true);
+        for (const def of defs) {
+            if (def.fixed === false) {
+                continue;
+            }
 
-            const wrote_def_after_reading_defun = read_defun_at != -1 && wrote_def_at != -1 && wrote_def_at > read_defun_at;
+            let def_last_write = symbol_last_write_map.get(def.id) || 0;
 
-            if (wrote_def_after_reading_defun) {
+            if (defun_first_read < def_last_write) {
                 def.fixed = false;
             }
         }

package/lib/compress/common.js

@@ -333,9 +333,9 @@ export function is_reachable(scope_node, defs) {
 }
 
 /** Check if a ref refers to the name of a function/class it's defined within */
-export function is_recursive_ref(compressor, def) {
+export function is_recursive_ref(tw, def) {
     var node;
-    for (var i = 0; node = compressor.parent(i); i++) {
+    for (var i = 0; node = tw.parent(i); i++) {
         if (node instanceof AST_Lambda || node instanceof AST_Class) {
             var name = node.name;
             if (name && name.definition() === def) {

package/lib/compress/evaluate.js

@@ -218,14 +218,25 @@ def_eval(AST_Object, function (compressor, depth) {
 var non_converting_unary = makePredicate("! typeof void");
 def_eval(AST_UnaryPrefix, function (compressor, depth) {
     var e = this.expression;
-    // Function would be evaluated to an array and so typeof would
-    // incorrectly return 'object'. Hence making is a special case.
     if (compressor.option("typeofs")
-        && this.operator == "typeof"
-        && (e instanceof AST_Lambda
+        && this.operator == "typeof") {
+        // Function would be evaluated to an array and so typeof would
+        // incorrectly return 'object'. Hence making is a special case.
+        if (e instanceof AST_Lambda
             || e instanceof AST_SymbolRef
-            && e.fixed_value() instanceof AST_Lambda)) {
-        return typeof function () { };
+            && e.fixed_value() instanceof AST_Lambda) {
+            return typeof function () { };
+        }
+        if (
+            (e instanceof AST_Object
+                || e instanceof AST_Array
+                || (e instanceof AST_SymbolRef
+                    && (e.fixed_value() instanceof AST_Object
+                        || e.fixed_value() instanceof AST_Array)))
+            && !e.has_side_effects(compressor)
+        ) {
+            return typeof {};
+        }
     }
     if (!non_converting_unary.has(this.operator))
         depth++;

package/lib/compress/reduce-vars.js

@@ -94,8 +94,7 @@ import {
 
     walk,
     walk_body,
-
-    TreeWalker,
+    walk_parent,
 } from "../ast.js";
 import { HOP, make_node, noop } from "../utils/index.js";
 
@@ -496,28 +495,50 @@ function mark_lambda(tw, descend, compressor) {
  *   // use defined_after
  * }
  *
- * This function is called on the parent to handle this issue.
+ * Or even indirectly:
+ *
+ * B();
+ * var defined_after = true;
+ * function A() {
+ *   // use defined_after
+ * }
+ * function B() {
+ *   A();
+ * }
+ *
+ * Access a variable before declaration will either throw a ReferenceError
+ * (if the variable is declared with `let` or `const`),
+ * or get an `undefined` (if the variable is declared with `var`).
+ *
+ * If the variable is inlined into the function, the behavior will change.
+ *
+ * This function is called on the parent to disallow inlining of such variables,
  */
 function handle_defined_after_hoist(parent) {
     const defuns = [];
     walk(parent, node => {
         if (node === parent) return;
-        if (node instanceof AST_Defun) defuns.push(node);
+        if (node instanceof AST_Defun) {
+            defuns.push(node);
+            return true;
+        }
         if (
             node instanceof AST_Scope
             || node instanceof AST_SimpleStatement
         ) return true;
     });
 
+    // `defun` id to array of `defun` it uses
+    const defun_dependencies_map = new Map();
+    // `defun` id to array of enclosing `def` that are used by the function
+    const dependencies_map = new Map();
+    // all symbol ids that will be tracked for read/write
     const symbols_of_interest = new Set();
     const defuns_of_interest = new Set();
-    const potential_conflicts = [];
 
     for (const defun of defuns) {
         const fname_def = defun.name.definition();
-        const found_self_ref_in_other_defuns = defuns.some(
-            d => d !== defun && d.enclosed.indexOf(fname_def) !== -1
-        );
+        const enclosing_defs = [];
 
         for (const def of defun.enclosed) {
             if (
@@ -528,93 +549,107 @@ function handle_defined_after_hoist(parent) {
                 continue;
             }
 
-            // defun is hoisted, so always safe
+            symbols_of_interest.add(def.id);
+
+            // found a reference to another function
             if (
                 def.assignments === 0
                 && def.orig.length === 1
                 && def.orig[0] instanceof AST_SymbolDefun
             ) {
-                continue;
-            }
+                defuns_of_interest.add(def.id);
+                symbols_of_interest.add(def.id);
+
+                defuns_of_interest.add(fname_def.id);
+                symbols_of_interest.add(fname_def.id);
+
+                if (!defun_dependencies_map.has(fname_def.id)) {
+                    defun_dependencies_map.set(fname_def.id, []);
+                }
+                defun_dependencies_map.get(fname_def.id).push(def.id);
 
-            if (found_self_ref_in_other_defuns) {
-                def.fixed = false;
                 continue;
             }
 
-            // for the slower checks below this loop
-            potential_conflicts.push({ defun, def, fname_def });
-            symbols_of_interest.add(def.id);
+            enclosing_defs.push(def);
+        }
+
+        if (enclosing_defs.length) {
+            dependencies_map.set(fname_def.id, enclosing_defs);
+            defuns_of_interest.add(fname_def.id);
             symbols_of_interest.add(fname_def.id);
-            defuns_of_interest.add(defun);
         }
     }
 
-    // linearize all symbols, and locate defs that are read after the defun
-    if (potential_conflicts.length) {
-        // All "symbols of interest", that is, defuns or defs, that we found.
-        // These are placed in order so we can check which is after which.
-        const found_symbols = [];
-        // Indices of `found_symbols` which are writes
-        const found_symbol_writes = new Set();
-        // Defun ranges are recorded because we don't care if a function uses the def internally
-        const defun_ranges = new Map();
-
-        let tw;
-        parent.walk((tw = new TreeWalker((node, descend) => {
-            if (node instanceof AST_Defun && defuns_of_interest.has(node)) {
-                const start = found_symbols.length;
-                descend();
-                const end = found_symbols.length;
-
-                defun_ranges.set(node, { start, end });
-                return true;
-            }
-            // if we found a defun on the list, mark IN_DEFUN=id and descend
-
-            if (node instanceof AST_Symbol && node.thedef) {
-                const id = node.definition().id;
-                if (symbols_of_interest.has(id)) {
-                    if (node instanceof AST_SymbolDeclaration || is_lhs(node, tw)) {
-                        found_symbol_writes.add(found_symbols.length);
-                    }
-                    found_symbols.push(id);
+    // No defuns use outside constants
+    if (!dependencies_map.size) {
+        return;
+    }
+
+    // Increment to count "symbols of interest" (defuns or defs) that we found.
+    // These are tracked in AST order so we can check which is after which.
+    let symbol_index = 1;
+    // Map a defun ID to its first read (a `symbol_index`)
+    const defun_first_read_map = new Map();
+    // Map a symbol ID to its last write (a `symbol_index`)
+    const symbol_last_write_map = new Map();
+
+    walk_parent(parent, (node, walk_info) => {
+        if (node instanceof AST_Symbol && node.thedef) {
+            const id = node.definition().id;
+
+            symbol_index++;
+
+            // Track last-writes to symbols
+            if (symbols_of_interest.has(id)) {
+                if (node instanceof AST_SymbolDeclaration || is_lhs(node, walk_info.parent())) {
+                    symbol_last_write_map.set(id, symbol_index);
                 }
             }
-        })));
-
-        for (const { def, defun, fname_def } of potential_conflicts) {
-            const defun_range = defun_ranges.get(defun);
-
-            // find the index in `found_symbols`, with some special rules:
-            const find = (sym_id, starting_at = 0, must_be_write = false) => {
-                let index = starting_at;
-
-                for (;;) {
-                    index = found_symbols.indexOf(sym_id, index);
-
-                    if (index === -1) {
-                        break;
-                    } else if (index >= defun_range.start && index < defun_range.end) {
-                        index = defun_range.end;
-                        continue;
-                    } else if (must_be_write && !found_symbol_writes.has(index)) {
-                        index++;
-                        continue;
-                    } else {
-                        break;
-                    }
+
+            // Track first-reads of defuns (refined later)
+            if (defuns_of_interest.has(id)) {
+                if (!defun_first_read_map.has(id) && !is_recursive_ref(walk_info, id)) {
+                    defun_first_read_map.set(id, symbol_index);
                 }
+            }
+        }
+    });
 
-                return index;
-            };
+    // Refine `defun_first_read_map` to be as high as possible
+    for (const [defun, defun_first_read] of defun_first_read_map) {
+        // Update all depdencies of `defun`
+        const queue = new Set(defun_dependencies_map.get(defun));
+        for (const enclosed_defun of queue) {
+            let enclosed_defun_first_read = defun_first_read_map.get(enclosed_defun);
+            if (enclosed_defun_first_read != null && enclosed_defun_first_read < defun_first_read) {
+                continue;
+            }
+
+            defun_first_read_map.set(enclosed_defun, defun_first_read);
 
-            const read_defun_at = find(fname_def.id);
-            const wrote_def_at = find(def.id, read_defun_at + 1, true);
+            for (const enclosed_enclosed_defun of defun_dependencies_map.get(enclosed_defun) || []) {
+                queue.add(enclosed_enclosed_defun);
+            }
+        }
+    }
+
+    // ensure write-then-read order, otherwise clear `fixed`
+    // This is safe because last-writes (found_symbol_writes) are assumed to be as late as possible, and first-reads (defun_first_read_map) are assumed to be as early as possible.
+    for (const [defun, defs] of dependencies_map) {
+        const defun_first_read = defun_first_read_map.get(defun);
+        if (defun_first_read === undefined) {
+            continue;
+        }
+
+        for (const def of defs) {
+            if (def.fixed === false) {
+                continue;
+            }
 
-            const wrote_def_after_reading_defun = read_defun_at != -1 && wrote_def_at != -1 && wrote_def_at > read_defun_at;
+            let def_last_write = symbol_last_write_map.get(def.id) || 0;
 
-            if (wrote_def_after_reading_defun) {
+            if (defun_first_read < def_last_write) {
                 def.fixed = false;
             }
         }

package/lib/mozilla-ast.js

@@ -595,6 +595,19 @@ import { is_basic_identifier_string } from "./parse.js";
             });
         },
 
+        ImportExpression: function(M) {
+            return new AST_Call({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                expression: from_moz({
+                    type: "Identifier",
+                    name: "import"
+                }),
+                optional: false,
+                args: [from_moz(M.source)]
+            });
+        },
+
         ExportAllDeclaration: function(M) {
             var foreign_name = M.exported == null ? 
                 new AST_SymbolExportForeign({ name: "*" }) :
@@ -662,6 +675,11 @@ import { is_basic_identifier_string } from "./parse.js";
                 args.value = { source, flags };
                 return new AST_RegExp(args);
             }
+            const bi = typeof M.value === "bigint" ? M.value.toString() : M.bigint;
+            if (typeof bi === "string") {
+                args.value = bi;
+                return new AST_BigInt(args);
+            }
             if (val === null) return new AST_Null(args);
             switch (typeof val) {
               case "string":
@@ -729,14 +747,6 @@ import { is_basic_identifier_string } from "./parse.js";
                         });
         },
 
-        BigIntLiteral(M) {
-            return new AST_BigInt({
-                start : my_start_token(M),
-                end   : my_end_token(M),
-                value : M.value
-            });
-        },
-
         EmptyStatement: function(M) {
             return new AST_EmptyStatement({
                 start: my_start_token(M),
@@ -1209,6 +1219,14 @@ import { is_basic_identifier_string } from "./parse.js";
         };
     });
     def_to_moz(AST_Call, function To_Moz_CallExpression(M) {
+        if (M.expression instanceof AST_SymbolRef && M.expression.name === "import") {
+            const [source] = M.args.map(to_moz);
+            return {
+                type: "ImportExpression",
+                source,
+            };
+        }
+
         return {
             type: "CallExpression",
             callee: to_moz(M.expression),
@@ -1754,8 +1772,13 @@ import { is_basic_identifier_string } from "./parse.js";
     });
 
     def_to_moz(AST_BigInt, M => ({
-        type: "BigIntLiteral",
-        value: M.value
+        type: "Literal",
+        // value cannot be represented natively
+        // see: https://github.com/estree/estree/blob/master/es2020.md#bigintliteral
+        value: null,
+        // `M.value` is a string that may be a hex number representation.
+        // but "bigint" property should have only decimal digits
+        bigint: typeof BigInt === "function" ? BigInt(M.value).toString() : M.value,
     }));
 
     AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);

package/package.json

@@ -4,7 +4,7 @@
   "homepage": "https://terser.org",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "5.31.6",
+  "version": "5.33.0",
   "engines": {
     "node": ">=10"
   },