enhance inline (#5871)

fixes #5869

.github/workflows/build.yml

@@ -9,11 +9,11 @@ jobs:
       fail-fast: false
       matrix:
         options:
-          - '-mb braces'
           - '--ie -c'
-          - '-mc'
-          - '-p acorn --toplevel -mco spidermonkey'
-          - '--toplevel -mc passes=3,pure_getters,unsafe'
+          - '-mb braces'
+          - '--toplevel -mc'
+          - '-p acorn -mco spidermonkey'
+          - '-mc passes=3,pure_getters,unsafe'
         script:
           - acorn.sh
           - bootstrap.sh
@@ -50,7 +50,7 @@ jobs:
       OPTIONS: ${{ matrix.options }}
       SCRIPT: ${{ matrix.script }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Perform uglify, build & test
         shell: bash
         run: |

.github/workflows/ci.yml

@@ -7,7 +7,7 @@ jobs:
   test:
     strategy:
       matrix:
-        node: [ '0.10', '0.12', '4', '6', '8', '10', '12', '14', '16', latest ]
+        node: [ '0.10', '0.12', '4', '6', '8', '10', '12', '14', '16', '18', '20' ]
         os: [ ubuntu-latest, windows-latest ]
         script: [ compress, mocha, release/benchmark, release/jetstream ]
     name: ${{ matrix.node }} ${{ matrix.os }} ${{ matrix.script }}
@@ -15,9 +15,10 @@ jobs:
     env:
       NODE: ${{ matrix.node }}
       TYPE: ${{ matrix.script }}
+      UGLIFY_GITHUB_LAG: 10000
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/cache@v2
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
         with:
           path: tmp
           key: tmp ${{ matrix.script }}

.github/workflows/moz.yml

@@ -0,0 +1,18 @@
+name: ESTree
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+jobs:
+  test:
+    name: fuzzing
+    runs-on: ubuntu-latest
+    env:
+      NODE: latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Perform tests
+        shell: bash
+        run: |
+          . ./test/release/install.sh
+          node test/mozilla-ast.js 5000

.github/workflows/ufuzz.yml

@@ -17,13 +17,13 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - node: latest
+          - node: '16'
             os: macos-latest
-          - node: '8'
+          - node: '12'
             os: ubuntu-latest
           - node: '8'
             os: ubuntu-latest
-          - node: '8'
+          - node: '12'
             os: windows-latest
           - node: '8'
             os: windows-latest
@@ -32,7 +32,7 @@ jobs:
     env:
       NODE: ${{ matrix.node }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Perform fuzzing
         shell: bash
         run: |

CONTRIBUTING.md

@@ -3,7 +3,7 @@ Contributing
 
 ## Documentation
 
-Every new feature and API change should be accompanied by a README additon.
+Every new feature and API change should be accompanied by a README addition.
 
 ## Testing
 

LICENSE

@@ -1,6 +1,6 @@
 UglifyJS is released under the BSD license:
 
-Copyright 2012-2019 (c) Mihai Bazon <mihai.bazon@gmail.com>
+Copyright 2012-2024 (c) Mihai Bazon <mihai.bazon@gmail.com>
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

README.md

@@ -54,8 +54,6 @@ a double dash to prevent input files being used as option arguments:
                                                 modules and Userscripts that may
                                                 be anonymous function wrapped (IIFE)
                                                 by the .user.js engine `caller`.
-                                `expression`  Parse a single expression, rather than
-                                              a program (for parsing JSON).
                                 `spidermonkey`  Assume input files are SpiderMonkey
                                                 AST format (as JSON).
     -c, --compress [options]    Enable compressor/specify compressor options:
@@ -111,12 +109,18 @@ a double dash to prevent input files being used as option arguments:
     -d, --define <expr>[=value] Global definitions.
     -e, --enclose [arg[:value]] Embed everything in a big function, with configurable
                                 argument(s) & value(s).
+    --expression                Parse a single expression, rather than a program
+                                (for parsing JSON).
     --ie                        Support non-standard Internet Explorer.
                                 Equivalent to setting `ie: true` in `minify()`
                                 for `compress`, `mangle` and `output` options.
                                 By default UglifyJS will not try to be IE-proof.
+    --keep-fargs                Do not mangle/drop function arguments.
     --keep-fnames               Do not mangle/drop function names.  Useful for
                                 code relying on Function.prototype.name.
+    --module                    Process input as ES module (implies --toplevel)
+    --no-module                 Avoid optimizations which may alter runtime behavior
+                                under prior versions of JavaScript.
     --name-cache <file>         File to hold mangled name mappings.
     --self                      Build UglifyJS as a library (implies --wrap UglifyJS)
     --source-map [options]      Enable source map/specify source map options:
@@ -145,7 +149,7 @@ a double dash to prevent input files being used as option arguments:
     --warn                      Print warning messages.
     --webkit                    Support non-standard Safari/Webkit.
                                 Equivalent to setting `webkit: true` in `minify()`
-                                for `mangle` and `output` options.
+                                for `compress`, `mangle` and `output` options.
                                 By default UglifyJS will not try to be Safari-proof.
     --wrap <name>               Embed everything in a big function, making the
                                 “exports” and “global” variables available. You
@@ -325,7 +329,7 @@ unquoted style (`o.foo`). Example:
 // stuff.js
 var o = {
     "foo": 1,
-    bar: 3
+    bar: 3,
 };
 o.foo += o.bar;
 console.log(o.foo);
@@ -337,6 +341,16 @@ $ uglifyjs stuff.js --mangle-props keep_quoted -c -m
 var o={foo:1,o:3};o.foo+=o.o,console.log(o.foo);
 ```
 
+If the minified output will be processed again by UglifyJS, consider specifying
+`keep_quoted_props` so the same property names are preserved:
+
+```bash
+$ uglifyjs stuff.js --mangle-props keep_quoted -c -m -O keep_quoted_props
+```
+```javascript
+var o={"foo":1,o:3};o.foo+=o.o,console.log(o.foo);
+```
+
 ### Debugging property name mangling
 
 You can also pass `--mangle-props debug` in order to mangle property names
@@ -502,8 +516,13 @@ if (result.error) throw result.error;
 - `compress` (default: `{}`) — pass `false` to skip compressing entirely.
   Pass an object to specify custom [compress options](#compress-options).
 
+- `expression` (default: `false`) — parse as a single expression, e.g. JSON.
+
 - `ie` (default: `false`) — enable workarounds for Internet Explorer bugs.
 
+- `keep_fargs` (default: `false`) — pass `true` to prevent discarding or mangling
+  of function arguments.
+
 - `keep_fnames` (default: `false`) — pass `true` to prevent discarding or mangling
   of function names.  Useful for code relying on `Function.prototype.name`.
 
@@ -513,6 +532,10 @@ if (result.error) throw result.error;
   - `mangle.properties` (default: `false`) — a subcategory of the mangle option.
     Pass an object to specify custom [mangle property options](#mangle-properties-options).
 
+- `module` (default: `true`) — process input as ES module, i.e. implicit
+  `"use strict";` and support for top-level `await`. When explicitly specified,
+  also enables `toplevel`.
+
 - `nameCache` (default: `null`) — pass an empty object `{}` or a previously
   used `nameCache` object if you wish to cache mangled variable and
   property names across multiple invocations of `minify()`. Note: this is
@@ -624,7 +647,11 @@ to be `false` and all symbol names will be omitted.
 
 - `bare_returns` (default: `false`) — support top level `return` statements
 
-- `html5_comments` (default: `true`)
+- `html5_comments` (default: `true`) — process HTML comment as workaround for
+  browsers which do not recognize `<script>` tags
+
+- `module` (default: `false`) — set to `true` if you wish to process input as
+  ES module, i.e. implicit `"use strict";` and support for top-level `await`.
 
 - `shebang` (default: `true`) — support `#!command` as the first line
 
@@ -707,7 +734,8 @@ to be `false` and all symbol names will be omitted.
   - `1` — inline simple functions
   - `2` — inline functions with arguments
   - `3` — inline functions with arguments and variables
-  - `true` — same as `3`
+  - `4` — inline functions with arguments, variables and statements
+  - `true` — same as `4`
 
 - `join_vars` (default: `true`) — join consecutive `var` statements
 
@@ -723,8 +751,11 @@ to be `false` and all symbol names will be omitted.
 
 - `merge_vars` (default: `true`) — combine and reuse variables.
 
+- `module` (default: `false`) — set to `true` if you wish to process input as
+  ES module, i.e. implicit `"use strict";`.
+
 - `negate_iife` (default: `true`) — negate "Immediately-Called Function Expressions"
-  where the return value is discarded, to avoid the parens that the
+  where the return value is discarded, to avoid the parentheses that the
   code generator would insert.
 
 - `objects` (default: `true`) — compact duplicate keys in object literals.
@@ -748,11 +779,11 @@ to be `false` and all symbol names will be omitted.
   overhead (compression will be slower). Make sure symbols under `pure_funcs`
   are also under `mangle.reserved` to avoid mangling.
 
-- `pure_getters` (default: `"strict"`) — If you pass `true` for
-  this, UglifyJS will assume that object property access
-  (e.g. `foo.bar` or `foo["bar"]`) doesn't have any side effects.
-  Specify `"strict"` to treat `foo.bar` as side-effect-free only when
-  `foo` is certain to not throw, i.e. not `null` or `undefined`.
+- `pure_getters` (default: `"strict"`) — Pass `true` for UglifyJS to assume that
+  object property access (e.g. `foo.bar` or `a[42]`) does not throw exception or
+  alter program states via getter function. Pass `"strict"` to allow dropping or
+  reordering `foo.bar` only if `foo` is not `null` or `undefined` and is safe to
+  access as a variable. Pass `false` to retain all property accesses.
 
 - `reduce_funcs` (default: `true`) — Allows single-use functions to be
   inlined as function expressions when permissible allowing further
@@ -799,8 +830,9 @@ to be `false` and all symbol names will be omitted.
 
 - `unsafe` (default: `false`) — apply "unsafe" transformations (discussion below)
 
-- `unsafe_comps` (default: `false`) — compress expressions like `a <= b` assuming
-  none of the operands can be (coerced to) `NaN`.
+- `unsafe_comps` (default: `false`) — assume operands cannot be (coerced to) `NaN`
+  in numeric comparisons, e.g. `a <= b`. In addition, expressions involving `in`
+  or `instanceof` would never throw.
 
 - `unsafe_Function` (default: `false`) — compress and mangle `Function(args, code)`
   when both `args` and `code` are string literals.
@@ -821,7 +853,7 @@ to be `false` and all symbol names will be omitted.
 - `unused` (default: `true`) — drop unreferenced functions and variables (simple
   direct variable assignments do not count as references unless set to `"keep_assign"`)
 
-- `varify` (default: `true`) — convert block-scoped declaractions into `var`
+- `varify` (default: `true`) — convert block-scoped declarations into `var`
   whenever safe to do so
 
 - `yields` (default: `true`) — apply optimizations to `yield` expressions
@@ -861,12 +893,18 @@ UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
 
 ### Mangle properties options
 
-- `builtins` (default: `false`) — Use `true` to allow the mangling of builtin
-  DOM properties. Not recommended to override this setting.
+- `builtins` (default: `false`) — Use `true` to allow the mangling of built-in
+  properties of JavaScript API. Not recommended to override this setting.
 
 - `debug` (default: `false`) — Mangle names with the original name still present.
   Pass an empty string `""` to enable, or a non-empty string to set the debug suffix.
 
+- `domprops` (default: `false`) — Use `true` to allow the mangling of properties
+  commonly found in Document Object Model. Not recommended to override this setting.
+
+- `keep_fargs` (default: `false`) — Use `true` to prevent mangling of function
+  arguments.
+
 - `keep_quoted` (default: `false`) — Only mangle unquoted property names.
 
 - `regex` (default: `null`) — Pass a RegExp literal to only mangle property
@@ -889,9 +927,8 @@ can pass additional arguments that control the code output:
   regexps (affects directives with non-ascii characters becoming invalid)
 
 - `beautify` (default: `true`) — whether to actually beautify the output.
-  Passing `-b` will set this to true, but you might need to pass `-b` even
-  when you want to generate minified code, in order to specify additional
-  arguments, so you can use `-b beautify=false` to override it.
+  Passing `-b` will set this to true. Use `-O` if you want to generate minified
+  code and specify additional arguments.
 
 - `braces` (default: `false`) — always insert braces in `if`, `for`,
   `do`, `while` or `with` statements, even if their body is a single
@@ -907,11 +944,16 @@ can pass additional arguments that control the code output:
   }
   ```
 
+- `extendscript` (default: `false`) — enable workarounds for Adobe ExtendScript
+  bugs
+
 - `galio` (default: `false`) — enable workarounds for ANT Galio bugs
 
-- `indent_level` (default: `4`)
+- `indent_level` (default: `4`) — indent by specified number of spaces or the
+  exact whitespace sequence supplied, e.g. `"\t"`.
 
-- `indent_start` (default: `0`) — prefix all lines by that many spaces
+- `indent_start` (default: `0`) — prefix all lines by whitespace sequence
+  specified in the same format as `indent_level`.
 
 - `inline_script` (default: `true`) — escape HTML comments and the slash in
   occurrences of `</script>` in strings
@@ -1321,11 +1363,9 @@ To allow for better optimizations, the compiler makes various assumptions:
 - Later versions of JavaScript will throw `SyntaxError` with the following:
   ```javascript
   var await;
-  async function f() {
   class A {
       static p = await;
   }
-  }
   // SyntaxError: Unexpected reserved word
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
@@ -1336,7 +1376,7 @@ To allow for better optimizations, the compiler makes various assumptions:
   // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
-- Later versions of Chrome and Node.js will give incorrect results with the
+- Some versions of Chrome and Node.js will give incorrect results with the
   following:
   ```javascript
   console.log({
@@ -1345,9 +1385,15 @@ To allow for better optimizations, the compiler makes various assumptions:
           return "FAIL";
       },
       [42]: "PASS",
+  }[42], {
+      ...console,
+      get 42() {
+          return "FAIL";
+      },
+      42: "PASS",
   }[42]);
-  // Expected: "PASS"
-  // Actual:   "FAIL"
+  // Expected: "PASS PASS"
+  // Actual:   "PASS FAIL"
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
 - Earlier versions of JavaScript will throw `TypeError` with the following:
@@ -1363,3 +1409,71 @@ To allow for better optimizations, the compiler makes various assumptions:
   // TypeError: const 'a' has already been declared
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  try {
+      class A {
+          static 42;
+          static get 42() {}
+      }
+      console.log("PASS");
+  } catch (e) {
+      console.log("FAIL");
+  }
+  // Expected: "PASS"
+  // Actual:   "FAIL"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  (async function(a) {
+      (function() {
+          var b = await => console.log("PASS");
+          b();
+      })();
+  })().catch(console.error);
+  // Expected: "PASS"
+  // Actual:   SyntaxError: Unexpected reserved word
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  try {
+      f();
+      function f() {
+          throw 42;
+      }
+  } catch (e) {
+      console.log(typeof f, e);
+  }
+  // Expected: "function 42"
+  // Actual:   "undefined 42"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  "use strict";
+  console.log(function f() {
+      return f = "PASS";
+  }());
+  // Expected: "PASS"
+  // Actual:   TypeError: invalid assignment to const 'f'
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Adobe ExtendScript will give incorrect results with the following:
+  ```javascript
+  alert(true ? "PASS" : false ? "FAIL" : null);
+  // Expected: "PASS"
+  // Actual:   "FAIL"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Adobe ExtendScript will give incorrect results with the following:
+  ```javascript
+  alert(42 ? null ? "FAIL" : "PASS" : "FAIL");
+  // Expected: "PASS"
+  // Actual:   SyntaxError: Expected: :
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.

bin/uglifyjs

@@ -10,7 +10,9 @@ var info = require("../package.json");
 var path = require("path");
 var UglifyJS = require("../tools/node");
 
-var skip_keys = [ "cname", "fixed", "inlined", "parent_scope", "scope", "uses_eval", "uses_with" ];
+var skip_keys = [ "cname", "fixed", "in_arg", "inlined", "length_read", "parent_scope", "redef", "scope", "unused" ];
+var truthy_keys = [ "optional", "pure", "terminal", "uses_arguments", "uses_eval", "uses_with" ];
+
 var files = {};
 var options = {};
 var short_forms = {
@@ -70,6 +72,7 @@ function process_option(name, no_value) {
                 } else {
                     if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
                     toplevels.push([ {
+                        keep_fargs: "keep-fargs",
                         keep_fnames: "keep-fnames",
                         nameCache: "name-cache",
                     }[name] || name, option ]);
@@ -101,8 +104,12 @@ function process_option(name, no_value) {
                 "  --config-file <file>                     Read minify() options from JSON file.",
                 "  -d, --define <expr>[=value]              Global definitions.",
                 "  -e, --enclose [arg[,...][:value[,...]]]  Embed everything in a big function, with configurable argument(s) & value(s).",
+                "  --expression                             Parse a single expression, rather than a program.",
                 "  --ie                                     Support non-standard Internet Explorer.",
+                "  --keep-fargs                             Do not mangle/drop function arguments.",
                 "  --keep-fnames                            Do not mangle/drop function names. Useful for code relying on Function.prototype.name.",
+                "  --module                                 Process input as ES module (implies --toplevel).",
+                "  --no-module                              Process input with improved JavaScript compatibility.",
                 "  --name-cache <file>                      File to hold mangled name mappings.",
                 "  --rename                                 Force symbol expansion.",
                 "  --no-rename                              Disable symbol expansion.",
@@ -146,6 +153,7 @@ function process_option(name, no_value) {
         options[name] = read_value();
         break;
       case "annotations":
+      case "expression":
       case "ie":
       case "ie8":
       case "timings":
@@ -158,6 +166,9 @@ function process_option(name, no_value) {
       case "no-annotations":
         options.annotations = false;
         break;
+      case "keep-fargs":
+        options.keep_fargs = true;
+        break;
       case "keep-fnames":
         options.keep_fnames = true;
         break;
@@ -190,6 +201,12 @@ function process_option(name, no_value) {
         if (typeof options.mangle != "object") options.mangle = {};
         options.mangle.properties = parse_js(read_value(), options.mangle.properties);
         break;
+      case "module":
+        options.module = true;
+        break;
+      case "no-module":
+        options.module = false;
+        break;
       case "name-cache":
         nameCache = read_value(true);
         options.nameCache = JSON.parse(read_file(nameCache, "{}"));
@@ -227,17 +244,6 @@ if (specified["beautify"] && specified["output-opts"]) fatal("--beautify cannot
 [ "compress", "mangle" ].forEach(function(name) {
     if (!(name in options)) options[name] = false;
 });
-if (options.mangle && options.mangle.properties) {
-    if (options.mangle.properties.domprops) {
-        delete options.mangle.properties.domprops;
-    } else {
-        if (typeof options.mangle.properties != "object") options.mangle.properties = {};
-        if (!Array.isArray(options.mangle.properties.reserved)) options.mangle.properties.reserved = [];
-        require("../tools/domprops").forEach(function(name) {
-            UglifyJS.push_uniq(options.mangle.properties.reserved, name);
-        });
-    }
-}
 if (/^ast|spidermonkey$/.test(output)) {
     if (typeof options.output != "object") options.output = {};
     options.output.ast = true;
@@ -267,6 +273,8 @@ if (specified["self"]) {
     if (paths.length) UglifyJS.AST_Node.warn("Ignoring input files since --self was passed");
     if (!options.wrap) options.wrap = "UglifyJS";
     paths = UglifyJS.FILES;
+} else if (paths.length) {
+    paths = simple_glob(paths);
 }
 if (specified["in-situ"]) {
     if (output && output != "spidermonkey" || specified["reduce-test"] || specified["self"]) {
@@ -281,7 +289,7 @@ if (specified["in-situ"]) {
         run();
     });
 } else if (paths.length) {
-    simple_glob(paths).forEach(function(name) {
+    paths.forEach(function(name) {
         files[convert_path(name)] = read_file(name);
     });
     run();
@@ -293,9 +301,19 @@ if (specified["in-situ"]) {
     process.stdin.setEncoding("utf8");
     process.stdin.once("data", function() {
         clearTimeout(timerId);
-    }).on("data", function(chunk) {
+    }).on("data", process.stdin.isTTY ? function(chunk) {
+        // emulate console input termination via Ctrl+D / Ctrl+Z
+        var match = /[\x04\x1a]\r?\n?$/.exec(chunk);
+        if (match) {
+            chunks.push(chunk.slice(0, -match[0].length));
+            process.stdin.pause();
+            process.stdin.emit("end");
+        } else {
             chunks.push(chunk);
-    }).on("end", function() {
+        }
+    } : function(chunk) {
+        chunks.push(chunk);
+    }).once("end", function() {
         files = { STDIN: chunks.join("") };
         run();
     });
@@ -430,7 +448,7 @@ function run() {
               case "thedef":
                 return symdef(value);
             }
-            if (skip_key(key)) return;
+            if (skip_property(key, value)) return;
             if (value instanceof UglifyJS.AST_Token) return;
             if (value instanceof UglifyJS.Dictionary) return;
             if (value instanceof UglifyJS.AST_Node) {
@@ -480,16 +498,20 @@ function fatal(message) {
 
 // A file glob function that only supports "*" and "?" wildcards in the basename.
 // Example: "foo/bar/*baz??.*.js"
-// Argument `glob` may be a string or an array of strings.
+// Argument `paths` must be an array of strings.
 // Returns an array of strings. Garbage in, garbage out.
-function simple_glob(glob) {
-    if (Array.isArray(glob)) {
-        return [].concat.apply([], glob.map(simple_glob));
-    }
-    if (glob.match(/\*|\?/)) {
+function simple_glob(paths) {
+    return paths.reduce(function(paths, glob) {
+        if (/\*|\?/.test(glob)) {
             var dir = path.dirname(glob);
             try {
-            var entries = fs.readdirSync(dir);
+                var entries = fs.readdirSync(dir).filter(function(name) {
+                    try {
+                        return fs.statSync(path.join(dir, name)).isFile();
+                    } catch (ex) {
+                        return false;
+                    }
+                });
             } catch (ex) {}
             if (entries) {
                 var pattern = "^" + path.basename(glob)
@@ -498,15 +520,20 @@ function simple_glob(glob) {
                     .replace(/\?/g, "[^/\\\\]") + "$";
                 var mod = process.platform === "win32" ? "i" : "";
                 var rx = new RegExp(pattern, mod);
-            var results = entries.sort().filter(function(name) {
+                var results = entries.filter(function(name) {
                     return rx.test(name);
-            }).map(function(name) {
+                }).sort().map(function(name) {
                     return path.join(dir, name);
                 });
-            if (results.length) return results;
+                if (results.length) {
+                    [].push.apply(paths, results);
+                    return paths;
                 }
             }
-    return [ glob ];
+        }
+        paths.push(glob);
+        return paths;
+    }, []);
 }
 
 function read_file(path, default_value) {
@@ -519,7 +546,7 @@ function read_file(path, default_value) {
 }
 
 function parse_js(value, options, flag) {
-    if (!options || typeof options != "object") options = {};
+    if (!options || typeof options != "object") options = Object.create(null);
     if (typeof value == "string") try {
         UglifyJS.parse(value, {
             expression: true
@@ -559,8 +586,10 @@ function parse_js(value, options, flag) {
     return options;
 }
 
-function skip_key(key) {
-    return skip_keys.indexOf(key) >= 0;
+function skip_property(key, value) {
+    return skip_keys.indexOf(key) >= 0
+        // only skip truthy_keys if their value is falsy
+        || truthy_keys.indexOf(key) >= 0 && !value;
 }
 
 function symdef(def) {

lib/ast.js

@@ -50,6 +50,8 @@ function DEFNODE(type, props, methods, base) {
     if (base && base.PROPS) props = props.concat(base.PROPS);
     var code = [
         "return function AST_", type, "(props){",
+        // not essential, but speeds up compress by a few percent
+        "this._bits=0;",
         "if(props){",
     ];
     props.forEach(function(prop) {
@@ -107,6 +109,9 @@ var AST_Node = DEFNODE("Node", "start end", {
         start: "[AST_Token] The first token of this node",
         end: "[AST_Token] The last token of this node"
     },
+    equals: function(node) {
+        return this.TYPE == node.TYPE && this._equals(node);
+    },
     walk: function(visitor) {
         visitor.visit(this);
     },
@@ -123,18 +128,61 @@ var AST_Node = DEFNODE("Node", "start end", {
         var marker = {};
         this.walk(new TreeWalker(function(node) {
             if (node.validate_visited === marker) {
-                throw new Error(string_template("cannot reuse {type} from [{file}:{line},{col}]", {
-                    type: "AST_" + node.TYPE,
-                    file: node.start.file,
-                    line: node.start.line,
-                    col: node.start.col,
-                }));
+                throw new Error(string_template("cannot reuse AST_{TYPE} from [{start}]", node));
             }
             node.validate_visited = marker;
         }));
     },
 }, null);
 
+DEF_BITPROPS(AST_Node, [
+    // AST_Node
+    "_optimized",
+    "_squeezed",
+    // AST_Call
+    "call_only",
+    // AST_Lambda
+    "collapse_scanning",
+    // AST_SymbolRef
+    "defined",
+    "evaluating",
+    "falsy",
+    // AST_SymbolRef
+    "in_arg",
+    // AST_Return
+    "in_bool",
+    // AST_SymbolRef
+    "is_undefined",
+    // AST_LambdaExpression
+    // AST_LambdaDefinition
+    "inlined",
+    // AST_Lambda
+    "length_read",
+    // AST_Yield
+    "nested",
+    // AST_Lambda
+    "new",
+    // AST_Call
+    // AST_PropAccess
+    "optional",
+    // AST_ClassProperty
+    "private",
+    // AST_Call
+    "pure",
+    // AST_Node
+    "single_use",
+    // AST_ClassProperty
+    "static",
+    // AST_Call
+    // AST_PropAccess
+    "terminal",
+    "truthy",
+    // AST_Scope
+    "uses_eval",
+    // AST_Scope
+    "uses_with",
+]);
+
 (AST_Node.log_function = function(fn, verbose) {
     if (typeof fn != "function") {
         AST_Node.info = AST_Node.warn = noop;
@@ -182,6 +230,24 @@ AST_Node.disable_validation = function() {
     while (restore = restore_transforms.pop()) restore();
 };
 
+function all_equals(k, l) {
+    return k.length == l.length && all(k, function(m, i) {
+        return m.equals(l[i]);
+    });
+}
+
+function list_equals(s, t) {
+    return s.length == t.length && all(s, function(u, i) {
+        return u == t[i];
+    });
+}
+
+function prop_equals(u, v) {
+    if (u === v) return true;
+    if (u == null) return v == null;
+    return u instanceof AST_Node && v instanceof AST_Node && u.equals(v);
+}
+
 /* -----[ statements ]----- */
 
 var AST_Statement = DEFNODE("Statement", null, {
@@ -193,6 +259,7 @@ var AST_Statement = DEFNODE("Statement", null, {
 
 var AST_Debugger = DEFNODE("Debugger", null, {
     $documentation: "Represents a debugger statement",
+    _equals: return_true,
 }, AST_Statement);
 
 var AST_Directive = DEFNODE("Directive", "quote value", {
@@ -201,6 +268,9 @@ var AST_Directive = DEFNODE("Directive", "quote value", {
         quote: "[string?] the original quote character",
         value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
     },
+    _equals: function(node) {
+        return this.value == node.value;
+    },
     _validate: function() {
         if (this.quote != null) {
             if (typeof this.quote != "string") throw new Error("quote must be string");
@@ -211,7 +281,8 @@ var AST_Directive = DEFNODE("Directive", "quote value", {
 }, AST_Statement);
 
 var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
-    $documentation: "The empty statement (empty block or simply a semicolon)"
+    $documentation: "The empty statement (empty block or simply a semicolon)",
+    _equals: return_true,
 }, AST_Statement);
 
 function is_statement(node) {
@@ -242,6 +313,9 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
     $propdoc: {
         body: "[AST_Node] an expression node (should not be instanceof AST_Statement)",
     },
+    _equals: function(node) {
+        return this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -253,10 +327,10 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
     },
 }, AST_Statement);
 
-var AST_BlockScope = DEFNODE("BlockScope", "enclosed functions make_def parent_scope variables", {
+var AST_BlockScope = DEFNODE("BlockScope", "_var_names enclosed functions make_def parent_scope variables", {
     $documentation: "Base class for all statements introducing a lexical scope",
     $propdoc: {
-        enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
+        enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any inner scopes",
         functions: "[Dictionary/S] like `variables`, but only lists function declarations",
         parent_scope: "[AST_Scope?/S] link to the parent scope",
         variables: "[Dictionary/S] a map of name ---> SymbolDef for all variables/functions defined in this scope",
@@ -293,6 +367,9 @@ var AST_Block = DEFNODE("Block", "body", {
     $propdoc: {
         body: "[AST_Statement*] an array of statements"
     },
+    _equals: function(node) {
+        return all_equals(this.body, node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -327,6 +404,10 @@ var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
     $propdoc: {
         label: "[AST_Label] a label definition"
     },
+    _equals: function(node) {
+        return this.label.equals(node.label)
+            && this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -368,6 +449,10 @@ var AST_DWLoop = DEFNODE("DWLoop", "condition", {
     $propdoc: {
         condition: "[AST_Node] the loop condition.  Should not be instanceof AST_Statement"
     },
+    _equals: function(node) {
+        return this.body.equals(node.body)
+            && this.condition.equals(node.condition);
+    },
     _validate: function() {
         if (this.TYPE == "DWLoop") throw new Error("should not instantiate AST_DWLoop");
         must_be_expression(this, "condition");
@@ -382,7 +467,7 @@ var AST_Do = DEFNODE("Do", null, {
             node.body.walk(visitor);
             node.condition.walk(visitor);
         });
-    }
+    },
 }, AST_DWLoop);
 
 var AST_While = DEFNODE("While", null, {
@@ -393,7 +478,7 @@ var AST_While = DEFNODE("While", null, {
             node.condition.walk(visitor);
             node.body.walk(visitor);
         });
-    }
+    },
 }, AST_DWLoop);
 
 var AST_For = DEFNODE("For", "init condition step", {
@@ -403,6 +488,12 @@ var AST_For = DEFNODE("For", "init condition step", {
         condition: "[AST_Node?] the `for` termination clause, or null if empty",
         step: "[AST_Node?] the `for` update clause, or null if empty"
     },
+    _equals: function(node) {
+        return prop_equals(this.init, node.init)
+            && prop_equals(this.condition, node.condition)
+            && prop_equals(this.step, node.step)
+            && this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -430,6 +521,11 @@ var AST_ForEnumeration = DEFNODE("ForEnumeration", "init object", {
         init: "[AST_Node] the assignment target during iteration",
         object: "[AST_Node] the object to iterate over"
     },
+    _equals: function(node) {
+        return this.init.equals(node.init)
+            && this.object.equals(node.object)
+            && this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -470,6 +566,10 @@ var AST_With = DEFNODE("With", "expression", {
     $propdoc: {
         expression: "[AST_Node] the `with` expression"
     },
+    _equals: function(node) {
+        return this.expression.equals(node.expression)
+            && this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -484,8 +584,8 @@ var AST_With = DEFNODE("With", "expression", {
 
 /* -----[ scope and functions ]----- */
 
-var AST_Scope = DEFNODE("Scope", "uses_eval uses_with", {
-    $documentation: "Base class for all statements introducing a lexical scope",
+var AST_Scope = DEFNODE("Scope", "fn_defs may_call_this uses_eval uses_with", {
+    $documentation: "Base class for all statements introducing a lambda scope",
     $propdoc: {
         uses_eval: "[boolean/S] tells whether this scope contains a direct call to the global `eval`",
         uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
@@ -543,13 +643,17 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
     }
 }, AST_Scope);
 
-var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest uses_arguments", {
+var AST_ClassInitBlock = DEFNODE("ClassInitBlock", null, {
+    $documentation: "Value for `class` static initialization blocks",
+}, AST_Scope);
+
+var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest safe_ids uses_arguments", {
     $documentation: "Base class for functions",
     $propdoc: {
         argnames: "[(AST_DefaultValue|AST_Destructured|AST_SymbolFunarg)*] array of function arguments and/or destructured literals",
         length_read: "[boolean/S] whether length property of this function is accessed",
         rest: "[(AST_Destructured|AST_SymbolFunarg)?] rest parameter, or null if absent",
-        uses_arguments: "[boolean/S] whether this function accesses the arguments array",
+        uses_arguments: "[boolean|number/S] whether this function accesses the arguments array",
     },
     each_argname: function(visit) {
         var tw = new TreeWalker(function(node) {
@@ -568,6 +672,13 @@ var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest uses_arguments", {
         });
         if (this.rest) this.rest.walk(tw);
     },
+    _equals: function(node) {
+        return prop_equals(this.rest, node.rest)
+            && prop_equals(this.name, node.name)
+            && prop_equals(this.value, node.value)
+            && all_equals(this.argnames, node.argnames)
+            && all_equals(this.body, node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -778,6 +889,14 @@ var AST_Class = DEFNODE("Class", "extends name properties", {
         extends: "[AST_Node?] the super class, or null if not specified",
         properties: "[AST_ClassProperty*] array of class properties",
     },
+    _equals: function(node) {
+        return prop_equals(this.name, node.name)
+            && prop_equals(this.extends, node.extends)
+            && all_equals(this.properties, node.properties);
+    },
+    resolve: function(def_class) {
+        return def_class ? this : this.parent_scope.resolve();
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -822,11 +941,17 @@ var AST_ClassExpression = DEFNODE("ClassExpression", null, {
 var AST_ClassProperty = DEFNODE("ClassProperty", "key private static value", {
     $documentation: "Base class for `class` properties",
     $propdoc: {
-        key: "[string|AST_Node] property name (AST_Node for computed property)",
+        key: "[string|AST_Node?] property name (AST_Node for computed property, null for initialization block)",
         private: "[boolean] whether this is a private property",
         static: "[boolean] whether this is a static property",
         value: "[AST_Node?] property value (AST_Accessor for getters/setters, AST_LambdaExpression for methods, null if not specified for fields)",
     },
+    _equals: function(node) {
+        return !this.private == !node.private
+            && !this.static == !node.static
+            && prop_equals(this.key, node.key)
+            && prop_equals(this.value, node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -836,7 +961,9 @@ var AST_ClassProperty = DEFNODE("ClassProperty", "key private static value", {
     },
     _validate: function() {
         if (this.TYPE == "ClassProperty") throw new Error("should not instantiate AST_ClassProperty");
-        if (typeof this.key != "string") {
+        if (this instanceof AST_ClassInit) {
+            if (this.key != null) throw new Error("key must be null");
+        } else if (typeof this.key != "string") {
             if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
             must_be_expression(this, "key");
         }
@@ -876,6 +1003,17 @@ var AST_ClassMethod = DEFNODE("ClassMethod", null, {
     },
 }, AST_ClassProperty);
 
+var AST_ClassInit = DEFNODE("ClassInit", null, {
+    $documentation: "A `class` static initialization block",
+    _validate: function() {
+        if (!this.static) throw new Error("static must be true");
+        if (!(this.value instanceof AST_ClassInitBlock)) throw new Error("value must be AST_ClassInitBlock");
+    },
+    initialize: function() {
+        this.static = true;
+    },
+}, AST_ClassProperty);
+
 /* -----[ JUMPS ]----- */
 
 var AST_Jump = DEFNODE("Jump", null, {
@@ -890,6 +1028,9 @@ var AST_Exit = DEFNODE("Exit", "value", {
     $propdoc: {
         value: "[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return"
     },
+    _equals: function(node) {
+        return prop_equals(this.value, node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -920,6 +1061,9 @@ var AST_LoopControl = DEFNODE("LoopControl", "label", {
     $propdoc: {
         label: "[AST_LabelRef?] the label, or null if none",
     },
+    _equals: function(node) {
+        return prop_equals(this.label, node.label);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -950,6 +1094,11 @@ var AST_If = DEFNODE("If", "condition alternative", {
         condition: "[AST_Node] the `if` condition",
         alternative: "[AST_Statement?] the `else` part, or null if not present"
     },
+    _equals: function(node) {
+        return this.body.equals(node.body)
+            && this.condition.equals(node.condition)
+            && prop_equals(this.alternative, node.alternative);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -973,6 +1122,10 @@ var AST_Switch = DEFNODE("Switch", "expression", {
     $propdoc: {
         expression: "[AST_Node] the `switch` “discriminant”"
     },
+    _equals: function(node) {
+        return this.expression.equals(node.expression)
+            && all_equals(this.body, node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1004,6 +1157,10 @@ var AST_Case = DEFNODE("Case", "expression", {
     $propdoc: {
         expression: "[AST_Node] the `case` expression"
     },
+    _equals: function(node) {
+        return this.expression.equals(node.expression)
+            && all_equals(this.body, node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1024,6 +1181,11 @@ var AST_Try = DEFNODE("Try", "bcatch bfinally", {
         bcatch: "[AST_Catch?] the catch block, or null if not present",
         bfinally: "[AST_Finally?] the finally block, or null if not present"
     },
+    _equals: function(node) {
+        return all_equals(this.body, node.body)
+            && prop_equals(this.bcatch, node.bcatch)
+            && prop_equals(this.bfinally, node.bfinally);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1047,6 +1209,10 @@ var AST_Catch = DEFNODE("Catch", "argname", {
     $propdoc: {
         argname: "[(AST_Destructured|AST_SymbolCatch)?] symbol for the exception, or null if not present",
     },
+    _equals: function(node) {
+        return prop_equals(this.argname, node.argname)
+            && all_equals(this.body, node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1072,6 +1238,9 @@ var AST_Definitions = DEFNODE("Definitions", "definitions", {
     $propdoc: {
         definitions: "[AST_VarDef*] array of variable definitions"
     },
+    _equals: function(node) {
+        return all_equals(this.definitions, node.definitions);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1128,6 +1297,10 @@ var AST_VarDef = DEFNODE("VarDef", "name value", {
         name: "[AST_Destructured|AST_SymbolVar] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer",
     },
+    _equals: function(node) {
+        return this.name.equals(node.name)
+            && prop_equals(this.value, node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1147,6 +1320,9 @@ var AST_ExportDeclaration = DEFNODE("ExportDeclaration", "body", {
     $propdoc: {
         body: "[AST_DefClass|AST_Definitions|AST_LambdaDefinition] the statement to export",
     },
+    _equals: function(node) {
+        return this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1167,6 +1343,9 @@ var AST_ExportDefault = DEFNODE("ExportDefault", "body", {
     $propdoc: {
         body: "[AST_Node] the default export",
     },
+    _equals: function(node) {
+        return this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1180,29 +1359,29 @@ var AST_ExportDefault = DEFNODE("ExportDefault", "body", {
     },
 }, AST_Statement);
 
-var AST_ExportForeign = DEFNODE("ExportForeign", "aliases keys path quote", {
+var AST_ExportForeign = DEFNODE("ExportForeign", "aliases keys path", {
     $documentation: "An `export ... from '...'` statement",
     $propdoc: {
-        aliases: "[string*] array of aliases to export",
-        keys: "[string*] array of keys to import",
-        path: "[string] the path to import module",
-        quote: "[string?] the original quote character",
+        aliases: "[AST_String*] array of aliases to export",
+        keys: "[AST_String*] array of keys to import",
+        path: "[AST_String] the path to import module",
+    },
+    _equals: function(node) {
+        return this.path.equals(node.path)
+            && all_equals(this.aliases, node.aliases)
+            && all_equals(this.keys, node.keys);
     },
     _validate: function() {
         if (this.aliases.length != this.keys.length) {
             throw new Error("aliases:key length mismatch: " + this.aliases.length + " != " + this.keys.length);
         }
         this.aliases.forEach(function(name) {
-            if (typeof name != "string") throw new Error("aliases must contain string");
+            if (!(name instanceof AST_String)) throw new Error("aliases must contain AST_String");
         });
         this.keys.forEach(function(name) {
-            if (typeof name != "string") throw new Error("keys must contain string");
+            if (!(name instanceof AST_String)) throw new Error("keys must contain AST_String");
         });
-        if (typeof this.path != "string") throw new Error("path must be string");
-        if (this.quote != null) {
-            if (typeof this.quote != "string") throw new Error("quote must be string");
-            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
-        }
+        if (!(this.path instanceof AST_String)) throw new Error("path must be AST_String");
     },
 }, AST_Statement);
 
@@ -1211,6 +1390,9 @@ var AST_ExportReferences = DEFNODE("ExportReferences", "properties", {
     $propdoc: {
         properties: "[AST_SymbolExport*] array of aliases to export",
     },
+    _equals: function(node) {
+        return all_equals(this.properties, node.properties);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1226,14 +1408,20 @@ var AST_ExportReferences = DEFNODE("ExportReferences", "properties", {
     },
 }, AST_Statement);
 
-var AST_Import = DEFNODE("Import", "all default path properties quote", {
+var AST_Import = DEFNODE("Import", "all default path properties", {
     $documentation: "An `import` statement",
     $propdoc: {
         all: "[AST_SymbolImport?] the imported namespace, or null if not specified",
         default: "[AST_SymbolImport?] the alias for default `export`, or null if not specified",
-        path: "[string] the path to import module",
+        path: "[AST_String] the path to import module",
         properties: "[(AST_SymbolImport*)?] array of aliases, or null if not specified",
-        quote: "[string?] the original quote character",
+    },
+    _equals: function(node) {
+        return this.path.equals(node.path)
+            && prop_equals(this.all, node.all)
+            && prop_equals(this.default, node.default)
+            && !this.properties == !node.properties
+            && (!this.properties || all_equals(this.properties, node.properties));
     },
     walk: function(visitor) {
         var node = this;
@@ -1252,16 +1440,12 @@ var AST_Import = DEFNODE("Import", "all default path properties quote", {
         }
         if (this.default != null) {
             if (!(this.default instanceof AST_SymbolImport)) throw new Error("default must be AST_SymbolImport");
-            if (this.default.key !== "") throw new Error("invalid default key: " + this.default.key);
+            if (this.default.key.value !== "") throw new Error("invalid default key: " + this.default.key.value);
         }
-        if (typeof this.path != "string") throw new Error("path must be string");
+        if (!(this.path instanceof AST_String)) throw new Error("path must be AST_String");
         if (this.properties != null) this.properties.forEach(function(node) {
             if (!(node instanceof AST_SymbolImport)) throw new Error("properties must contain AST_SymbolImport");
         });
-        if (this.quote != null) {
-            if (typeof this.quote != "string") throw new Error("quote must be string");
-            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
-        }
     },
 }, AST_Statement);
 
@@ -1271,6 +1455,10 @@ var AST_DefaultValue = DEFNODE("DefaultValue", "name value", {
         name: "[AST_Destructured|AST_SymbolDeclaration] name of the variable",
         value: "[AST_Node] value to assign if variable is `undefined`",
     },
+    _equals: function(node) {
+        return this.name.equals(node.name)
+            && this.value.equals(node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1295,9 +1483,14 @@ var AST_Call = DEFNODE("Call", "args expression optional pure terminal", {
         args: "[AST_Node*] array of arguments",
         expression: "[AST_Node] expression to invoke as function",
         optional: "[boolean] whether the expression is optional chaining",
-        pure: "[string/S] marker for side-effect-free call expression",
+        pure: "[boolean/S] marker for side-effect-free call expression",
         terminal: "[boolean] whether the chain has ended",
     },
+    _equals: function(node) {
+        return !this.optional == !node.optional
+            && this.expression.equals(node.expression)
+            && all_equals(this.args, node.args);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1324,7 +1517,10 @@ var AST_New = DEFNODE("New", null, {
 var AST_Sequence = DEFNODE("Sequence", "expressions", {
     $documentation: "A sequence expression (comma-separated expressions)",
     $propdoc: {
-        expressions: "[AST_Node*] array of expressions (at least two)"
+        expressions: "[AST_Node*] array of expressions (at least two)",
+    },
+    _equals: function(node) {
+        return all_equals(this.expressions, node.expressions);
     },
     walk: function(visitor) {
         var node = this;
@@ -1353,6 +1549,11 @@ var AST_PropAccess = DEFNODE("PropAccess", "expression optional property termina
         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",
         terminal: "[boolean] whether the chain has ended",
     },
+    _equals: function(node) {
+        return !this.optional == !node.optional
+            && prop_equals(this.property, node.property)
+            && this.expression.equals(node.expression);
+    },
     get_property: function() {
         var p = this.property;
         if (p instanceof AST_Constant) return p.value;
@@ -1365,8 +1566,11 @@ var AST_PropAccess = DEFNODE("PropAccess", "expression optional property termina
     },
 });
 
-var AST_Dot = DEFNODE("Dot", null, {
+var AST_Dot = DEFNODE("Dot", "quoted", {
     $documentation: "A dotted property access expression",
+    $propdoc: {
+        quoted: "[boolean] whether property is transformed from a quoted string",
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1397,6 +1601,9 @@ var AST_Spread = DEFNODE("Spread", "expression", {
     $propdoc: {
         expression: "[AST_Node] expression to be expanded",
     },
+    _equals: function(node) {
+        return this.expression.equals(node.expression);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1412,7 +1619,11 @@ var AST_Unary = DEFNODE("Unary", "operator expression", {
     $documentation: "Base class for unary expressions",
     $propdoc: {
         operator: "[string] the operator",
-        expression: "[AST_Node] expression that this unary operator applies to"
+        expression: "[AST_Node] expression that this unary operator applies to",
+    },
+    _equals: function(node) {
+        return this.operator == node.operator
+            && this.expression.equals(node.expression);
     },
     walk: function(visitor) {
         var node = this;
@@ -1442,6 +1653,11 @@ var AST_Binary = DEFNODE("Binary", "operator left right", {
         operator: "[string] the operator",
         right: "[AST_Node] right-hand side expression"
     },
+    _equals: function(node) {
+        return this.operator == node.operator
+            && this.left.equals(node.left)
+            && this.right.equals(node.right);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1463,6 +1679,11 @@ var AST_Conditional = DEFNODE("Conditional", "condition consequent alternative",
         consequent: "[AST_Node]",
         alternative: "[AST_Node]"
     },
+    _equals: function(node) {
+        return this.condition.equals(node.condition)
+            && this.consequent.equals(node.consequent)
+            && this.alternative.equals(node.alternative);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1489,6 +1710,12 @@ var AST_Assign = DEFNODE("Assign", null, {
                     throw new Error("left must be assignable: " + node.TYPE);
                 }
             });
+        } else if (!(this.left instanceof AST_Infinity
+            || this.left instanceof AST_NaN
+            || this.left instanceof AST_PropAccess && !this.left.optional
+            || this.left instanceof AST_SymbolRef
+            || this.left instanceof AST_Undefined)) {
+            throw new Error("left must be assignable");
         }
     },
 }, AST_Binary);
@@ -1498,6 +1725,9 @@ var AST_Await = DEFNODE("Await", "expression", {
     $propdoc: {
         expression: "[AST_Node] expression with Promise to resolve on",
     },
+    _equals: function(node) {
+        return this.expression.equals(node.expression);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1515,6 +1745,10 @@ var AST_Yield = DEFNODE("Yield", "expression nested", {
         expression: "[AST_Node?] return value for iterator, or null if undefined",
         nested: "[boolean] whether to iterate over expression as generator",
     },
+    _equals: function(node) {
+        return !this.nested == !node.nested
+            && prop_equals(this.expression, node.expression);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1537,6 +1771,9 @@ var AST_Array = DEFNODE("Array", "elements", {
     $propdoc: {
         elements: "[AST_Node*] array of elements"
     },
+    _equals: function(node) {
+        return all_equals(this.elements, node.elements);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1579,6 +1816,10 @@ var AST_DestructuredArray = DEFNODE("DestructuredArray", "elements", {
     $propdoc: {
         elements: "[(AST_DefaultValue|AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef)*] array of elements",
     },
+    _equals: function(node) {
+        return prop_equals(this.rest, node.rest)
+            && all_equals(this.elements, node.elements);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1596,6 +1837,10 @@ var AST_DestructuredKeyVal = DEFNODE("DestructuredKeyVal", "key value", {
         key: "[string|AST_Node] property name.  For computed property this is an AST_Node.",
         value: "[AST_DefaultValue|AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef] property value",
     },
+    _equals: function(node) {
+        return prop_equals(this.key, node.key)
+            && this.value.equals(node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1617,6 +1862,10 @@ var AST_DestructuredObject = DEFNODE("DestructuredObject", "properties", {
     $propdoc: {
         properties: "[AST_DestructuredKeyVal*] array of properties",
     },
+    _equals: function(node) {
+        return prop_equals(this.rest, node.rest)
+            && all_equals(this.properties, node.properties);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1638,6 +1887,9 @@ var AST_Object = DEFNODE("Object", "properties", {
     $propdoc: {
         properties: "[(AST_ObjectProperty|AST_Spread)*] array of properties"
     },
+    _equals: function(node) {
+        return all_equals(this.properties, node.properties);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1661,6 +1913,10 @@ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
         key: "[string|AST_Node] property name.  For computed property this is an AST_Node.",
         value: "[AST_Node] property value.  For getters and setters this is an AST_Accessor.",
     },
+    _equals: function(node) {
+        return prop_equals(this.key, node.key)
+            && this.value.equals(node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1715,6 +1971,9 @@ var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
         scope: "[AST_Scope/S] the current scope (not necessarily the definition scope)",
         thedef: "[SymbolDef/S] the definition of this symbol"
     },
+    _equals: function(node) {
+        return this.thedef ? this.thedef === node.thedef : this.name == node.name;
+    },
     _validate: function() {
         if (this.TYPE == "Symbol") throw new Error("should not instantiate AST_Symbol");
         if (typeof this.name != "string") throw new Error("name must be string");
@@ -1732,10 +1991,14 @@ var AST_SymbolConst = DEFNODE("SymbolConst", null, {
 var AST_SymbolImport = DEFNODE("SymbolImport", "key", {
     $documentation: "Symbol defined by an `import` statement",
     $propdoc: {
-        key: "[string] the original `export` name",
+        key: "[AST_String] the original `export` name",
+    },
+    _equals: function(node) {
+        return this.name == node.name
+            && this.key.equals(node.key);
     },
     _validate: function() {
-        if (typeof this.key != "string") throw new Error("key must be string");
+        if (!(this.key instanceof AST_String)) throw new Error("key must be AST_String");
     },
 }, AST_SymbolConst);
 
@@ -1747,7 +2010,7 @@ var AST_SymbolVar = DEFNODE("SymbolVar", null, {
     $documentation: "Symbol defining a variable",
 }, AST_SymbolDeclaration);
 
-var AST_SymbolFunarg = DEFNODE("SymbolFunarg", null, {
+var AST_SymbolFunarg = DEFNODE("SymbolFunarg", "unused", {
     $documentation: "Symbol naming a function argument",
 }, AST_SymbolVar);
 
@@ -1779,7 +2042,7 @@ var AST_Label = DEFNODE("Label", "references", {
     initialize: function() {
         this.references = [];
         this.thedef = this;
-    }
+    },
 }, AST_Symbol);
 
 var AST_SymbolRef = DEFNODE("SymbolRef", "fixed in_arg redef", {
@@ -1789,10 +2052,14 @@ var AST_SymbolRef = DEFNODE("SymbolRef", "fixed in_arg redef", {
 var AST_SymbolExport = DEFNODE("SymbolExport", "alias", {
     $documentation: "Reference in an `export` statement",
     $propdoc: {
-        alias: "[string] the `export` alias",
+        alias: "[AST_String] the `export` alias",
+    },
+    _equals: function(node) {
+        return this.name == node.name
+            && this.alias.equals(node.alias);
     },
     _validate: function() {
-        if (typeof this.alias != "string") throw new Error("alias must be string");
+        if (!(this.alias instanceof AST_String)) throw new Error("alias must be AST_String");
     },
 }, AST_SymbolRef);
 
@@ -1802,6 +2069,7 @@ var AST_LabelRef = DEFNODE("LabelRef", null, {
 
 var AST_ObjectIdentity = DEFNODE("ObjectIdentity", null, {
     $documentation: "Base class for `super` & `this`",
+    _equals: return_true,
     _validate: function() {
         if (this.TYPE == "ObjectIdentity") throw new Error("should not instantiate AST_ObjectIdentity");
     },
@@ -1836,7 +2104,12 @@ var AST_Template = DEFNODE("Template", "expressions strings tag", {
     $propdoc: {
         expressions: "[AST_Node*] the placeholder expressions",
         strings: "[string*] the raw text segments",
-        tag: "[AST_Node] tag function, or null if absent",
+        tag: "[AST_Node?] tag function, or null if absent",
+    },
+    _equals: function(node) {
+        return prop_equals(this.tag, node.tag)
+            && list_equals(this.strings, node.strings)
+            && all_equals(this.expressions, node.expressions);
     },
     walk: function(visitor) {
         var node = this;
@@ -1861,6 +2134,9 @@ var AST_Template = DEFNODE("Template", "expressions strings tag", {
 
 var AST_Constant = DEFNODE("Constant", null, {
     $documentation: "Base class for all constants",
+    _equals: function(node) {
+        return this.value === node.value;
+    },
     _validate: function() {
         if (this.TYPE == "Constant") throw new Error("should not instantiate AST_Constant");
     },
@@ -1909,6 +2185,9 @@ var AST_RegExp = DEFNODE("RegExp", "value", {
     $propdoc: {
         value: "[RegExp] the actual regexp"
     },
+    _equals: function(node) {
+        return "" + this.value == "" + node.value;
+    },
     _validate: function() {
         if (!(this.value instanceof RegExp)) throw new Error("value must be RegExp");
     },
@@ -1916,6 +2195,7 @@ var AST_RegExp = DEFNODE("RegExp", "value", {
 
 var AST_Atom = DEFNODE("Atom", null, {
     $documentation: "Base class for atoms",
+    _equals: return_true,
     _validate: function() {
         if (this.TYPE == "Atom") throw new Error("should not instantiate AST_Atom");
     },
@@ -1923,27 +2203,27 @@ var AST_Atom = DEFNODE("Atom", null, {
 
 var AST_Null = DEFNODE("Null", null, {
     $documentation: "The `null` atom",
-    value: null
+    value: null,
 }, AST_Atom);
 
 var AST_NaN = DEFNODE("NaN", null, {
     $documentation: "The impossible value",
-    value: 0/0
+    value: 0/0,
 }, AST_Atom);
 
 var AST_Undefined = DEFNODE("Undefined", null, {
     $documentation: "The `undefined` value",
-    value: function(){}()
+    value: function(){}(),
 }, AST_Atom);
 
 var AST_Hole = DEFNODE("Hole", null, {
     $documentation: "A hole in an array",
-    value: function(){}()
+    value: function(){}(),
 }, AST_Atom);
 
 var AST_Infinity = DEFNODE("Infinity", null, {
     $documentation: "The `Infinity` value",
-    value: 1/0
+    value: 1/0,
 }, AST_Atom);
 
 var AST_Boolean = DEFNODE("Boolean", null, {
@@ -1955,12 +2235,12 @@ var AST_Boolean = DEFNODE("Boolean", null, {
 
 var AST_False = DEFNODE("False", null, {
     $documentation: "The `false` atom",
-    value: false
+    value: false,
 }, AST_Boolean);
 
 var AST_True = DEFNODE("True", null, {
     $documentation: "The `true` atom",
-    value: true
+    value: true,
 }, AST_Boolean);
 
 /* -----[ TreeWalker ]----- */
@@ -1981,16 +2261,21 @@ TreeWalker.prototype = {
         return this.stack[this.stack.length - 2 - (n || 0)];
     },
     push: function(node) {
-        if (node instanceof AST_Lambda) {
+        var value;
+        if (node instanceof AST_Class) {
+            this.directives = Object.create(this.directives);
+            value = "use strict";
+        } else if (node instanceof AST_Directive) {
+            value = node.value;
+        } else if (node instanceof AST_Lambda) {
             this.directives = Object.create(this.directives);
-        } else if (node instanceof AST_Directive && !this.directives[node.value]) {
-            this.directives[node.value] = node;
         }
+        if (value && !this.directives[value]) this.directives[value] = node;
         this.stack.push(node);
     },
     pop: function() {
         var node = this.stack.pop();
-        if (node instanceof AST_Lambda) {
+        if (node instanceof AST_Class || node instanceof AST_Lambda) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
     },
@@ -2030,33 +2315,40 @@ TreeWalker.prototype = {
         }
     },
     in_boolean_context: function() {
-        var self = this.self();
-        for (var i = 0, p; p = this.parent(i); i++) {
-            if (p instanceof AST_Conditional && p.condition === self
-                || p instanceof AST_DWLoop && p.condition === self
-                || p instanceof AST_For && p.condition === self
-                || p instanceof AST_If && p.condition === self
-                || p instanceof AST_Return && p.in_bool
-                || p instanceof AST_Sequence && p.tail_node() !== self
-                || p instanceof AST_SimpleStatement
-                || p instanceof AST_UnaryPrefix && p.operator == "!" && p.expression === self) {
-                return true;
-            }
-            if (p instanceof AST_Binary && (p.operator == "&&" || p.operator == "||")
-                || p instanceof AST_Conditional
-                || p.tail_node() === self) {
-                self = p;
-            } else if (p instanceof AST_Return) {
-                for (var call, fn = p; call = this.parent(++i); fn = call) {
-                    if (call.TYPE == "Call") {
-                        if (!(fn instanceof AST_Lambda) || fn.name) return false;
-                    } else if (fn instanceof AST_Lambda) {
+        for (var drop = true, level = 0, parent, self = this.self(); parent = this.parent(level++); self = parent) {
+            if (parent instanceof AST_Binary) switch (parent.operator) {
+              case "&&":
+              case "||":
+                if (parent.left === self) drop = false;
+                continue;
+              default:
                 return false;
             }
+            if (parent instanceof AST_Conditional) {
+                if (parent.condition === self) return true;
+                continue;
             }
-            } else {
+            if (parent instanceof AST_DWLoop) return parent.condition === self;
+            if (parent instanceof AST_For) return parent.condition === self;
+            if (parent instanceof AST_If) return parent.condition === self;
+            if (parent instanceof AST_Return) {
+                if (parent.in_bool) return true;
+                while (parent = this.parent(level++)) {
+                    if (parent instanceof AST_Lambda) {
+                        if (parent.name) return false;
+                        parent = this.parent(level++);
+                        if (parent.TYPE != "Call") return false;
+                        break;
+                    }
+                }
+            }
+            if (parent instanceof AST_Sequence) {
+                if (parent.tail_node() === self) continue;
+                return drop ? "d" : true;
+            }
+            if (parent instanceof AST_SimpleStatement) return drop ? "d" : true;
+            if (parent instanceof AST_UnaryPrefix) return parent.operator == "!";
             return false;
         }
     }
-    }
 };

lib/minify.js

@@ -28,7 +28,7 @@ function read_source_map(name, toplevel) {
         var match = /^# ([^\s=]+)=(\S+)\s*$/.exec(comment.value);
         if (!match) break;
         if (match[1] == "sourceMappingURL") {
-            match = /^data:application\/json(;.*?)?;base64,(\S+)$/.exec(match[2]);
+            match = /^data:application\/json(;.*?)?;base64,([^,]+)$/.exec(match[2]);
             if (!match) break;
             return to_ascii(match[2]);
         }
@@ -76,17 +76,20 @@ function minify(files, options) {
             annotations: undefined,
             compress: {},
             enclose: false,
+            expression: false,
             ie: false,
             ie8: false,
+            keep_fargs: false,
             keep_fnames: false,
             mangle: {},
+            module: undefined,
             nameCache: null,
             output: {},
             parse: {},
             rename: undefined,
             sourceMap: false,
             timings: false,
-            toplevel: false,
+            toplevel: options && !options["expression"] && options["module"] ? true : undefined,
             v8: false,
             validate: false,
             warnings: false,
@@ -95,20 +98,24 @@ function minify(files, options) {
         }, true);
         if (options.validate) AST_Node.enable_validation();
         var timings = options.timings && { start: Date.now() };
-        if (options.rename === undefined) options.rename = options.compress && options.mangle;
         if (options.annotations !== undefined) set_shorthand("annotations", options, [ "compress", "output" ]);
+        if (options.expression) set_shorthand("expression", options, [ "compress", "parse" ]);
         if (options.ie8) options.ie = options.ie || options.ie8;
-        if (options.ie) set_shorthand("ie", options, [ "compress", "mangle", "output" ]);
-        if (options.keep_fnames) set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
-        if (options.toplevel) set_shorthand("toplevel", options, [ "compress", "mangle" ]);
-        if (options.v8) set_shorthand("v8", options, [ "mangle", "output" ]);
-        if (options.webkit) set_shorthand("webkit", options, [ "compress", "mangle", "output" ]);
+        if (options.ie) set_shorthand("ie", options, [ "compress", "mangle", "output", "rename" ]);
+        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.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" ]);
         var quoted_props;
         if (options.mangle) {
             options.mangle = defaults(options.mangle, {
                 cache: options.nameCache && (options.nameCache.vars || {}),
                 eval: false,
                 ie: false,
+                keep_fargs: false,
                 keep_fnames: false,
                 properties: false,
                 reserved: [],
@@ -132,6 +139,7 @@ function minify(files, options) {
             init_cache(options.mangle.cache);
             init_cache(options.mangle.properties.cache);
         }
+        if (options.rename === undefined) options.rename = options.compress && options.mangle;
         if (options.sourceMap) {
             options.sourceMap = defaults(options.sourceMap, {
                 content: null,
@@ -148,13 +156,11 @@ function minify(files, options) {
         }, options.warnings == "verbose");
         if (timings) timings.parse = Date.now();
         var toplevel;
-        if (files instanceof AST_Toplevel) {
+        options.parse = options.parse || {};
+        if (files instanceof AST_Node) {
             toplevel = files;
         } else {
-            if (typeof files == "string") {
-                files = [ files ];
-            }
-            options.parse = options.parse || {};
+            if (typeof files == "string") files = [ files ];
             options.parse.toplevel = null;
             var source_map_content = options.sourceMap && options.sourceMap.content;
             if (typeof source_map_content == "string" && source_map_content != "inline") {
@@ -166,17 +172,14 @@ function minify(files, options) {
                 options.parse.toplevel = toplevel = parse(files[name], options.parse);
                 if (source_map_content == "inline") {
                     var inlined_content = read_source_map(name, toplevel);
-                    if (inlined_content) {
-                        options.sourceMap.orig[name] = parse_source_map(inlined_content);
-                    }
+                    if (inlined_content) options.sourceMap.orig[name] = parse_source_map(inlined_content);
                 } else if (source_map_content) {
                     options.sourceMap.orig[name] = source_map_content;
                 }
             }
         }
-        if (quoted_props) {
-            reserve_quoted_keys(toplevel, quoted_props);
-        }
+        if (options.parse.expression) toplevel = toplevel.wrap_expression();
+        if (quoted_props) reserve_quoted_keys(toplevel, quoted_props);
         [ "enclose", "wrap" ].forEach(function(action) {
             var option = options[action];
             if (!option) return;
@@ -187,8 +190,8 @@ function minify(files, options) {
         if (options.validate) toplevel.validate_ast();
         if (timings) timings.rename = Date.now();
         if (options.rename) {
-            toplevel.figure_out_scope(options.mangle);
-            toplevel.expand_names(options.mangle);
+            toplevel.figure_out_scope(options.rename);
+            toplevel.expand_names(options.rename);
         }
         if (timings) timings.compress = Date.now();
         if (options.compress) {
@@ -203,7 +206,9 @@ function minify(files, options) {
             toplevel.mangle_names(options.mangle);
         }
         if (timings) timings.properties = Date.now();
+        if (quoted_props) reserve_quoted_keys(toplevel, quoted_props);
         if (options.mangle && options.mangle.properties) mangle_properties(toplevel, options.mangle.properties);
+        if (options.parse.expression) toplevel = toplevel.unwrap_expression();
         if (timings) timings.output = Date.now();
         var result = {};
         var output = defaults(options.output, {

lib/mozilla-ast.js

@@ -125,6 +125,16 @@
                 body: normalize_directives(from_moz(M.body).body),
             });
         },
+        CallExpression: function(M) {
+            return new AST_Call({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                expression: from_moz(M.callee),
+                args: M.arguments.map(from_moz),
+                optional: M.optional,
+                pure: M.pure,
+            });
+        },
         ClassDeclaration: function(M) {
             return new AST_DefClass({
                 start: my_start_token(M),
@@ -192,6 +202,19 @@
                 value: from_moz(M.value),
             });
         },
+        StaticBlock: function(M) {
+            var start = my_start_token(M);
+            var end = my_end_token(M);
+            return new AST_ClassInit({
+                start: start,
+                end: end,
+                value: new AST_ClassInitBlock({
+                    start: start,
+                    end: end,
+                    body: normalize_directives(M.body.map(from_moz)),
+                }),
+            });
+        },
         ForOfStatement: function(M) {
             return new (M.await ? AST_ForAwaitOf : AST_ForOf)({
                 start: my_start_token(M),
@@ -303,13 +326,22 @@
             });
         },
         ExportAllDeclaration: function(M) {
-            var alias = M.exported ? read_name(M.exported) : "*";
+            var start = my_start_token(M);
+            var end = my_end_token(M);
             return new AST_ExportForeign({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                aliases: [ alias ],
-                keys: [ "*" ],
-                path: M.source.value,
+                start: start,
+                end: end,
+                aliases: [ M.exported ? from_moz_alias(M.exported) : new AST_String({
+                    start: start,
+                    value: "*",
+                    end: end,
+                }) ],
+                keys: [ new AST_String({
+                    start: start,
+                    value: "*",
+                    end: end,
+                }) ],
+                path: from_moz(M.source),
             });
         },
         ExportDefaultDeclaration: function(M) {
@@ -346,15 +378,15 @@
             if (M.source) {
                 var aliases = [], keys = [];
                 M.specifiers.forEach(function(prop) {
-                    aliases.push(read_name(prop.exported));
-                    keys.push(read_name(prop.local));
+                    aliases.push(from_moz_alias(prop.exported));
+                    keys.push(from_moz_alias(prop.local));
                 });
                 return new AST_ExportForeign({
                     start: my_start_token(M),
                     end: my_end_token(M),
                     aliases: aliases,
                     keys: keys,
-                    path: M.source.value,
+                    path: from_moz(M.source),
                 });
             }
             return new AST_ExportReferences({
@@ -362,38 +394,48 @@
                 end: my_end_token(M),
                 properties: M.specifiers.map(function(prop) {
                     var sym = new AST_SymbolExport(from_moz(prop.local));
-                    sym.alias = read_name(prop.exported);
+                    sym.alias = from_moz_alias(prop.exported);
                     return sym;
                 }),
             });
         },
         ImportDeclaration: function(M) {
+            var start = my_start_token(M);
+            var end = my_end_token(M);
             var all = null, def = null, props = null;
             M.specifiers.forEach(function(prop) {
                 var sym = new AST_SymbolImport(from_moz(prop.local));
                 switch (prop.type) {
                   case "ImportDefaultSpecifier":
                     def = sym;
-                    def.key = "";
+                    def.key = new AST_String({
+                        start: start,
+                        value: "",
+                        end: end,
+                    });
                     break;
                   case "ImportNamespaceSpecifier":
                     all = sym;
-                    all.key = "*";
+                    all.key = new AST_String({
+                        start: start,
+                        value: "*",
+                        end: end,
+                    });
                     break;
                   default:
-                    sym.key = prop.imported.name || syn.name;
+                    sym.key = from_moz_alias(prop.imported);
                     if (!props) props = [];
                     props.push(sym);
                     break;
                 }
             });
             return new AST_Import({
-                start: my_start_token(M),
-                end: my_end_token(M),
+                start: start,
+                end: end,
                 all: all,
                 default: def,
                 properties: props,
-                path: M.source.value,
+                path: from_moz(M.source),
             });
         },
         ImportExpression: function(M) {
@@ -426,7 +468,7 @@
                 end: my_end_token(M),
             };
             if (M.bigint) {
-                args.value = M.bigint.toLowerCase() + "n";
+                args.value = M.bigint.toLowerCase();
                 return new AST_BigInt(args);
             }
             var val = M.value;
@@ -599,7 +641,6 @@
     map("AssignmentPattern", AST_DefaultValue, "left>name, right>value");
     map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative");
     map("NewExpression", AST_New, "callee>expression, arguments@args, pure=pure");
-    map("CallExpression", AST_Call, "callee>expression, arguments@args, optional=optional, pure=pure");
     map("SequenceExpression", AST_Sequence, "expressions@expressions");
     map("SpreadElement", AST_Spread, "argument>expression");
     map("ObjectExpression", AST_Object, "properties@properties");
@@ -636,6 +677,7 @@
             type: "ArrowFunctionExpression",
             async: is_async(M),
             params: params,
+            expression: !!M.value,
             body: M.value ? to_moz(M.value) : to_moz_scope("BlockStatement", M),
         };
         return {
@@ -648,6 +690,21 @@
         };
     });
 
+    def_to_moz(AST_Call, function To_Moz_CallExpression(M) {
+        var expr = M.expression;
+        if (M.args.length == 1 && expr instanceof AST_SymbolRef && expr.name == "import") return {
+            type: "ImportExpression",
+            source: to_moz(M.args[0]),
+        };
+        return {
+            type: "CallExpression",
+            callee: to_moz(expr),
+            arguments: M.args.map(to_moz),
+            optional: M.optional,
+            pure: M.pure,
+        };
+    });
+
     def_to_moz(AST_DefClass, function To_Moz_ClassDeclaration(M) {
         return {
             type: "ClassDeclaration",
@@ -714,6 +771,10 @@
         };
     });
 
+    def_to_moz(AST_ClassInit, function To_Moz_StaticBlock(M) {
+        return to_moz_scope("StaticBlock", M.value);
+    });
+
     function To_Moz_ForOfStatement(is_await) {
         return function(M) {
             return {
@@ -731,6 +792,7 @@
     def_to_moz(AST_Directive, function To_Moz_Directive(M) {
         return {
             type: "ExpressionStatement",
+            directive: M.value,
             expression: set_moz_loc(M, {
                 type: "Literal",
                 value: M.value,
@@ -751,7 +813,6 @@
             type: "TryStatement",
             block: to_moz_block(M),
             handler: to_moz(M.bcatch),
-            guardedHandlers: [],
             finalizer: to_moz(M.bfinally),
         };
     });
@@ -760,7 +821,6 @@
         return {
             type: "CatchClause",
             param: to_moz(M.argname),
-            guard: null,
             body: to_moz_block(M),
         };
     });
@@ -769,6 +829,7 @@
         return {
             type: "ExportNamedDeclaration",
             declaration: to_moz(M.body),
+            specifiers: [],
         };
     });
 
@@ -780,38 +841,26 @@
     });
 
     def_to_moz(AST_ExportForeign, function To_Moz_ExportAllDeclaration_ExportNamedDeclaration(M) {
-        if (M.keys[0] == "*") return {
+        if (M.keys[0].value == "*") return {
             type: "ExportAllDeclaration",
-            exported: M.aliases[0] == "*" ? null : {
-                type: "Identifier",
-                name: M.aliases[0],
-            },
-            source: {
-                type: "Literal",
-                value: M.path,
-            },
+            exported: M.aliases[0].value == "*" ? null : to_moz_alias(M.aliases[0]),
+            source: to_moz(M.path),
         };
         var specifiers = [];
         for (var i = 0; i < M.aliases.length; i++) {
-            specifiers.push({
+            specifiers.push(set_moz_loc({
+                start: M.keys[i].start,
+                end: M.aliases[i].end,
+            }, {
                 type: "ExportSpecifier",
-                exported: {
-                    type: "Identifier",
-                    name: M.aliases[i],
-                },
-                local: {
-                    type: "Identifier",
-                    name: M.keys[i],
-                },
-            });
+                local: to_moz_alias(M.keys[i]),
+                exported: to_moz_alias(M.aliases[i]),
+            }));
         }
         return {
             type: "ExportNamedDeclaration",
             specifiers: specifiers,
-            source: {
-                type: "Literal",
-                value: M.path,
-            },
+            source: to_moz(M.path),
         };
     });
 
@@ -819,44 +868,41 @@
         return {
             type: "ExportNamedDeclaration",
             specifiers: M.properties.map(function(prop) {
-                return {
+                return set_moz_loc({
+                    start: prop.start,
+                    end: prop.alias.end,
+                }, {
                     type: "ExportSpecifier",
                     local: to_moz(prop),
-                    exported: {
-                        type: "Identifier",
-                        name: prop.alias,
-                    },
-                };
+                    exported: to_moz_alias(prop.alias),
+                });
             }),
         };
     });
 
     def_to_moz(AST_Import, function To_Moz_ImportDeclaration(M) {
         var specifiers = M.properties ? M.properties.map(function(prop) {
-            return {
+            return set_moz_loc({
+                start: prop.key.start,
+                end: prop.end,
+            }, {
                 type: "ImportSpecifier",
                 local: to_moz(prop),
-                imported: {
-                    type: "Identifier",
-                    name: prop.key,
-                },
-            };
+                imported: to_moz_alias(prop.key),
+            });
         }) : [];
-        if (M.all) specifiers.unshift({
+        if (M.all) specifiers.unshift(set_moz_loc(M.all, {
             type: "ImportNamespaceSpecifier",
             local: to_moz(M.all),
-        });
-        if (M.default) specifiers.unshift({
+        }));
+        if (M.default) specifiers.unshift(set_moz_loc(M.default, {
             type: "ImportDefaultSpecifier",
             local: to_moz(M.default),
-        });
+        }));
         return {
             type: "ImportDeclaration",
             specifiers: specifiers,
-            source: {
-                type: "Literal",
-                value: M.path,
-            },
+            source: to_moz(M.path),
         };
     });
 
@@ -933,6 +979,8 @@
             type: "Property",
             kind: "init",
             computed: computed,
+            method: false,
+            shorthand: false,
             key: key,
             value: to_moz(M.value),
         };
@@ -969,6 +1017,7 @@
             kind: kind,
             computed: computed,
             method: M instanceof AST_ObjectMethod,
+            shorthand: false,
             key: key,
             value: to_moz(M.value),
         };
@@ -1005,7 +1054,7 @@
     });
 
     def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) {
-        var flags = M.value.toString().match(/[gimuy]*$/)[0];
+        var flags = M.value.toString().match(/\/([gimuy]*)$/)[1];
         var value = "/" + M.value.raw_source + "/" + flags;
         return {
             type: "Literal",
@@ -1013,8 +1062,8 @@
             raw: value,
             regex: {
                 pattern: M.value.raw_source,
-                flags: flags
-            }
+                flags: flags,
+            },
         };
     });
 
@@ -1022,8 +1071,8 @@
         var value = M.value;
         return {
             type: "Literal",
-            bigint: value.slice(0, -1),
-            raw: value,
+            bigint: value,
+            raw: value + "n",
         };
     });
 
@@ -1203,6 +1252,14 @@
         return node;
     }
 
+    function from_moz_alias(moz) {
+        return new AST_String({
+            start: my_start_token(moz),
+            value: read_name(moz),
+            end: my_end_token(moz),
+        });
+    }
+
     AST_Node.from_mozilla_ast = function(node) {
         var save_stack = FROM_MOZ_STACK;
         FROM_MOZ_STACK = [];
@@ -1254,6 +1311,13 @@
         return node != null ? node.to_mozilla_ast() : null;
     }
 
+    function to_moz_alias(alias) {
+        return is_identifier_string(alias.value) ? set_moz_loc(alias, {
+            type: "Identifier",
+            name: alias.value,
+        }) : to_moz(alias);
+    }
+
     function to_moz_block(node) {
         return {
             type: "BlockStatement",

lib/output.js

@@ -55,6 +55,7 @@ function OutputStream(options) {
         beautify         : false,
         braces           : false,
         comments         : false,
+        extendscript     : false,
         galio            : false,
         ie               : false,
         indent_level     : 4,
@@ -75,7 +76,7 @@ function OutputStream(options) {
         wrap_iife        : false,
     }, true);
 
-    // Convert comment option to RegExp if neccessary and set up comments filter
+    // Convert comment option to RegExp if necessary and set up comments filter
     var comment_filter = return_false; // Default case, throw all comments away
     if (options.comments) {
         var comments = options.comments;
@@ -101,10 +102,18 @@ function OutputStream(options) {
         }
     }
 
+    function make_indent(value) {
+        if (typeof value == "number") return new Array(value + 1).join(" ");
+        if (!value) return "";
+        if (!/^\s*$/.test(value)) throw new Error("unsupported indentation: " + JSON.stringify("" + value));
+        return value;
+    }
+
     var current_col = 0;
     var current_line = 1;
-    var current_pos = 0;
-    var indentation = options.indent_start;
+    var current_indent = make_indent(options.indent_start);
+    var full_indent = make_indent(options.indent_level);
+    var half_indent = full_indent.length + 1 >> 1;
     var last;
     var line_end = 0;
     var line_fixed = true;
@@ -115,17 +124,17 @@ function OutputStream(options) {
     var might_need_semicolon;
     var need_newline_indented = false;
     var need_space = false;
-    var newline_insert = -1;
+    var output;
     var stack;
-    var OUTPUT;
+    var stored = "";
 
     function reset() {
         last = "";
         might_need_space = false;
         might_need_semicolon = false;
         stack = [];
-        var str = OUTPUT;
-        OUTPUT = "";
+        var str = output;
+        output = "";
         return str;
     }
 
@@ -227,32 +236,39 @@ function OutputStream(options) {
     } : noop;
 
     function insert_newlines(count) {
-        var index = OUTPUT.lastIndexOf("\n");
-        if (line_end < index) line_end = index;
-        var left = OUTPUT.slice(0, line_end);
-        var right = OUTPUT.slice(line_end);
-        adjust_mappings(count, right.length - current_col);
+        stored += output.slice(0, line_end);
+        output = output.slice(line_end);
+        var new_col = output.length;
+        adjust_mappings(count, new_col - current_col);
         current_line += count;
-        current_pos += count;
-        current_col = right.length;
-        OUTPUT = left;
-        while (count--) OUTPUT += "\n";
-        OUTPUT += right;
+        current_col = new_col;
+        while (count--) stored += "\n";
     }
 
-    var fix_line = options.max_line_len ? function() {
+    var fix_line = options.max_line_len ? function(flush) {
         if (line_fixed) {
             if (current_col > options.max_line_len) {
                 AST_Node.warn("Output exceeds {max_line_len} characters", options);
             }
             return;
         }
-        if (current_col > options.max_line_len) insert_newlines(1);
+        if (current_col > options.max_line_len) {
+            insert_newlines(1);
             line_fixed = true;
-        flush_mappings();
+        }
+        if (line_fixed || flush) flush_mappings();
     } : noop;
 
-    var requireSemicolonChars = makePredicate("( [ + * / - , .");
+    var require_semicolon = makePredicate("( [ + * / - , .");
+
+    function require_space(prev, ch, str) {
+        return is_identifier_char(prev) && (is_identifier_char(ch) || ch == "\\")
+            || (ch == "/" && ch == prev)
+            || ((ch == "+" || ch == "-") && ch == last)
+            || last == "--" && ch == ">"
+            || last == "!" && str == "--"
+            || prev == "/" && (str == "in" || str == "instanceof");
+    }
 
     var print = options.beautify
         || options.comments
@@ -276,45 +292,39 @@ function OutputStream(options) {
                 space();
             }
         }
-        newline_insert = -1;
         var prev = last.slice(-1);
         if (might_need_semicolon) {
             might_need_semicolon = false;
-
-            if (prev == ":" && ch == "}" || (!ch || ";}".indexOf(ch) < 0) && prev != ";") {
-                if (options.semicolons || requireSemicolonChars[ch]) {
-                    OUTPUT += ";";
+            if (prev == ":" && ch == "}" || prev != ";" && (!ch || ";}".indexOf(ch) < 0)) {
+                var need_semicolon = require_semicolon[ch];
+                if (need_semicolon || options.semicolons) {
+                    output += ";";
                     current_col++;
-                    current_pos++;
+                    if (!line_fixed) {
+                        fix_line();
+                        if (line_fixed && !need_semicolon && output == ";") {
+                            output = "";
+                            current_col = 0;
+                        }
+                    }
+                    if (line_end == output.length - 1) line_end++;
                 } else {
                     fix_line();
-                    OUTPUT += "\n";
-                    current_pos++;
+                    output += "\n";
                     current_line++;
                     current_col = 0;
-
-                    if (/^\s+$/.test(str)) {
                     // reset the semicolon flag, since we didn't print one
                     // now and might still have to later
-                        might_need_semicolon = true;
+                    if (/^\s+$/.test(str)) might_need_semicolon = true;
                 }
-                }
-
-                if (!options.beautify)
-                    might_need_space = false;
+                if (!options.beautify) might_need_space = false;
             }
         }
 
         if (might_need_space) {
-            if (is_identifier_char(prev) && (is_identifier_char(ch) || ch == "\\")
-                || (ch == "/" && ch == prev)
-                || ((ch == "+" || ch == "-") && ch == last)
-                || str == "--" && last == "!"
-                || str == "in" && prev == "/"
-                || last == "--" && ch == ">") {
-                OUTPUT += " ";
+            if (require_space(prev, ch, str)) {
+                output += " ";
                 current_col++;
-                current_pos++;
             }
             if (prev != "<" || str != "!") might_need_space = false;
         }
@@ -324,14 +334,13 @@ function OutputStream(options) {
                 token: mapping_token,
                 name: mapping_name,
                 line: current_line,
-                col: current_col
+                col: current_col,
             });
             mapping_token = false;
             if (line_fixed) flush_mappings();
         }
 
-        OUTPUT += str;
-        current_pos += str.length;
+        output += str;
         var a = str.split(/\r?\n/), n = a.length - 1;
         current_line += n;
         current_col += a[0].length;
@@ -346,22 +355,15 @@ function OutputStream(options) {
         if (might_need_semicolon) {
             might_need_semicolon = false;
             if (prev == ":" && ch == "}" || (!ch || ";}".indexOf(ch) < 0) && prev != ";") {
-                OUTPUT += ";";
+                output += ";";
                 might_need_space = false;
             }
         }
         if (might_need_space) {
-            if (is_identifier_char(prev) && (is_identifier_char(ch) || ch == "\\")
-                || (ch == "/" && ch == prev)
-                || ((ch == "+" || ch == "-") && ch == last)
-                || str == "--" && last == "!"
-                || str == "in" && prev == "/"
-                || last == "--" && ch == ">") {
-                OUTPUT += " ";
-            }
+            if (require_space(prev, ch, str)) output += " ";
             if (prev != "<" || str != "!") might_need_space = false;
         }
-        OUTPUT += str;
+        output += str;
         last = str;
     };
 
@@ -373,30 +375,25 @@ function OutputStream(options) {
 
     var indent = options.beautify ? function(half) {
         if (need_newline_indented) print("\n");
-        print(repeat_string(" ", half ? indentation - (options.indent_level >> 1) : indentation));
+        print(half ? current_indent.slice(0, -half_indent) : current_indent);
     } : noop;
 
     var with_indent = options.beautify ? function(cont) {
-        var save_indentation = indentation;
-        indentation += options.indent_level;
+        var save_indentation = current_indent;
+        current_indent += full_indent;
         cont();
-        indentation = save_indentation;
+        current_indent = save_indentation;
     } : function(cont) { cont() };
 
     var may_add_newline = options.max_line_len || options.preserve_line ? function() {
         fix_line();
-        line_end = OUTPUT.length;
+        line_end = output.length;
         line_fixed = false;
     } : noop;
 
     var newline = options.beautify ? function() {
-        if (newline_insert < 0) return print("\n");
-        if (OUTPUT[newline_insert] != "\n") {
-            OUTPUT = OUTPUT.slice(0, newline_insert) + "\n" + OUTPUT.slice(newline_insert);
-            current_pos++;
-            current_line++;
-        }
-        newline_insert++;
+        print("\n");
+        line_end = output.length;
     } : may_add_newline;
 
     var semicolon = options.beautify ? function() {
@@ -410,10 +407,11 @@ function OutputStream(options) {
         print(";");
     }
 
-    function with_block(cont) {
+    function with_block(cont, end) {
         print("{");
         newline();
         with_indent(cont);
+        add_mapping(end);
         indent();
         print("}");
     }
@@ -452,13 +450,12 @@ function OutputStream(options) {
     } : noop;
 
     function get() {
-        if (!line_fixed) fix_line();
-        return OUTPUT;
+        if (!line_fixed) fix_line(true);
+        return stored + output;
     }
 
     function has_nlb() {
-        var index = OUTPUT.lastIndexOf("\n");
-        return /^ *$/.test(OUTPUT.slice(index + 1));
+        return /(^|\n) *$/.test(output);
     }
 
     function pad_comment(token, force) {
@@ -515,15 +512,13 @@ function OutputStream(options) {
             scan.walk(tw);
         }
 
-        if (current_pos == 0) {
+        if (current_line == 1 && current_col == 0) {
             if (comments.length > 0 && options.shebang && comments[0].type == "comment5") {
                 print("#!" + comments.shift().value + "\n");
                 indent();
             }
             var preamble = options.preamble;
-            if (preamble) {
-                print(preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
-            }
+            if (preamble) print(preamble.replace(/\r\n?|\u2028|\u2029|(^|\S)\s*$/g, "$1\n"));
         }
 
         comments = comments.filter(comment_filter, node);
@@ -561,20 +556,18 @@ function OutputStream(options) {
             return !/comment[134]/.test(c.type);
         }))) return;
         comments._dumped = self;
-        var insert = OUTPUT.length;
         comments.filter(comment_filter, node).forEach(function(comment, index) {
             pad_comment(comment, index || !tail);
             print_comment(comment);
         });
-        if (OUTPUT.length > insert) newline_insert = insert;
     }
 
     return {
         get             : get,
         reset           : reset,
         indent          : indent,
-        should_break    : options.width ? function() {
-            return current_col - indentation >= options.width;
+        should_break    : options.beautify && options.width ? function() {
+            return current_col >= options.width;
         } : return_false,
         has_parens      : function() { return last.slice(-1) == "(" },
         newline         : newline,
@@ -708,6 +701,7 @@ function OutputStream(options) {
         if (p instanceof AST_Class) return true;
         // (x++)[y]
         // (typeof x).y
+        // https://github.com/mishoo/UglifyJS/issues/115
         if (p instanceof AST_PropAccess) return p.expression === this;
         // (~x)`foo`
         if (p instanceof AST_Template) return p.tag === this;
@@ -883,7 +877,9 @@ function OutputStream(options) {
         return needs_parens_assign_cond(this, output);
     });
     PARENS(AST_Conditional, function(output) {
-        return needs_parens_assign_cond(this, output);
+        return needs_parens_assign_cond(this, output)
+            // https://github.com/mishoo/UglifyJS/issues/1144
+            || output.option("extendscript") && output.parent() instanceof AST_Conditional;
     });
     PARENS(AST_Yield, function(output) {
         return needs_parens_assign_cond(this, output);
@@ -962,7 +958,7 @@ function OutputStream(options) {
         if (self.body.length > 0) {
             output.with_block(function() {
                 display_body(self.body, false, output, allow_directives);
-            });
+            }, self.end);
         } else print_braced_empty(self, output);
     }
     DEFPRINT(AST_BlockStatement, function(output) {
@@ -1001,7 +997,7 @@ function OutputStream(options) {
                 if (self.init instanceof AST_Definitions) {
                     self.init.print(output);
                 } else {
-                    parenthesize_for_noin(self.init, output, true);
+                    parenthesize_for_no_in(self.init, output, true);
                 }
                 output.print(";");
                 output.space();
@@ -1070,6 +1066,14 @@ function OutputStream(options) {
         }
         output.semicolon();
     });
+    function print_alias(alias, output) {
+        var value = alias.value;
+        if (value == "*" || is_identifier_string(value)) {
+            output.print_name(value);
+        } else {
+            output.print_string(value, alias.quote);
+        }
+    }
     DEFPRINT(AST_ExportForeign, function(output) {
         var self = this;
         output.print("export");
@@ -1077,7 +1081,7 @@ function OutputStream(options) {
         var len = self.keys.length;
         if (len == 0) {
             print_braced_empty(self, output);
-        } else if (self.keys[0] == "*") {
+        } else if (self.keys[0].value == "*") {
             print_entry(0);
         } else output.with_block(function() {
             output.indent();
@@ -1089,22 +1093,22 @@ function OutputStream(options) {
                 print_entry(i);
             }
             output.newline();
-        });
+        }, self.end);
         output.space();
         output.print("from");
         output.space();
-        output.print_string(self.path, self.quote);
+        self.path.print(output);
         output.semicolon();
 
         function print_entry(index) {
             var alias = self.aliases[index];
             var key = self.keys[index];
-            output.print_name(key);
-            if (alias != key) {
+            print_alias(key, output);
+            if (alias.value != key.value) {
                 output.space();
                 output.print("as");
                 output.space();
-                output.print_name(alias);
+                print_alias(alias, output);
             }
         }
     });
@@ -1133,7 +1137,7 @@ function OutputStream(options) {
             output.print("from");
             output.space();
         }
-        output.print_string(self.path, self.quote);
+        self.path.print(output);
         output.semicolon();
     });
 
@@ -1263,6 +1267,11 @@ function OutputStream(options) {
         }
         print_method(self, output);
     });
+    DEFPRINT(AST_ClassInit, function(output) {
+        output.print("static");
+        output.space();
+        print_braced(this.value, output);
+    });
 
     /* -----[ jumps ]----- */
     function print_jump(kind, prop) {
@@ -1348,7 +1357,7 @@ function OutputStream(options) {
                 if (i < last && branch.body.length > 0)
                     output.newline();
             });
-        });
+        }, self.end);
     });
     function print_branch_body(self, output) {
         output.newline();
@@ -1404,7 +1413,7 @@ function OutputStream(options) {
         print_braced(this, output);
     });
 
-    function print_definitinos(type) {
+    function print_definitions(type) {
         return function(output) {
             var self = this;
             output.print(type);
@@ -1417,15 +1426,15 @@ function OutputStream(options) {
             if (!(p instanceof AST_IterationStatement && p.init === self)) output.semicolon();
         };
     }
-    DEFPRINT(AST_Const, print_definitinos("const"));
-    DEFPRINT(AST_Let, print_definitinos("let"));
-    DEFPRINT(AST_Var, print_definitinos("var"));
+    DEFPRINT(AST_Const, print_definitions("const"));
+    DEFPRINT(AST_Let, print_definitions("let"));
+    DEFPRINT(AST_Var, print_definitions("var"));
 
-    function parenthesize_for_noin(node, output, noin) {
+    function parenthesize_for_no_in(node, output, no_in) {
         var parens = false;
         // need to take some precautions here:
         //    https://github.com/mishoo/UglifyJS/issues/60
-        if (noin) node.walk(new TreeWalker(function(node) {
+        if (no_in) node.walk(new TreeWalker(function(node) {
             if (parens) return true;
             if (node instanceof AST_Binary && node.operator == "in") return parens = true;
             if (node instanceof AST_Scope && !(is_arrow(node) && node.value)) return true;
@@ -1441,8 +1450,8 @@ function OutputStream(options) {
             output.print("=");
             output.space();
             var p = output.parent(1);
-            var noin = p instanceof AST_For || p instanceof AST_ForEnumeration;
-            parenthesize_for_noin(self.value, output, noin);
+            var no_in = p instanceof AST_For || p instanceof AST_ForEnumeration;
+            parenthesize_for_no_in(self.value, output, no_in);
         }
     });
 
@@ -1465,17 +1474,15 @@ function OutputStream(options) {
             parent = output.parent(level++);
             if (parent instanceof AST_Call && parent.expression === node) return;
         } while (parent instanceof AST_PropAccess && parent.expression === node);
-        output.print(typeof self.pure == "string" ? "/*" + self.pure + "*/" : "/*@__PURE__*/");
+        output.print("/*@__PURE__*/");
     }
     function print_call_args(self, output) {
-        if (self.expression instanceof AST_Call || self.expression instanceof AST_Lambda) {
-            output.add_mapping(self.start);
-        }
         output.with_parens(function() {
             self.args.forEach(function(expr, i) {
                 if (i) output.comma();
                 expr.print(output);
             });
+            output.add_mapping(self.end);
         });
     }
     DEFPRINT(AST_Call, function(output) {
@@ -1510,11 +1517,12 @@ function OutputStream(options) {
         var expr = self.expression;
         expr.print(output);
         var prop = self.property;
-        if (output.option("ie") && RESERVED_WORDS[prop]) {
-            output.print(self.optional ? "?.[" : "[");
+        if (output.option("ie") && RESERVED_WORDS[prop] || self.quoted && output.option("keep_quoted_props")) {
+            if (self.optional) output.print("?.");
+            output.with_square(function() {
                 output.add_mapping(self.end);
                 output.print_string(prop);
-            output.print("]");
+            });
         } else {
             if (expr instanceof AST_Number && !/[ex.)]/i.test(output.last())) output.print(".");
             output.print(self.optional ? "?." : ".");
@@ -1526,9 +1534,10 @@ function OutputStream(options) {
     DEFPRINT(AST_Sub, function(output) {
         var self = this;
         self.expression.print(output);
-        output.print(self.optional ? "?.[" : "[");
+        if (self.optional) output.print("?.");
+        output.with_square(function() {
             self.property.print(output);
-        output.print("]");
+        });
     });
     DEFPRINT(AST_Spread, function(output) {
         output.print("...");
@@ -1547,8 +1556,10 @@ function OutputStream(options) {
         exp.print(output);
     });
     DEFPRINT(AST_UnaryPostfix, function(output) {
-        this.expression.print(output);
-        output.print(this.operator);
+        var self = this;
+        self.expression.print(output);
+        output.add_mapping(self.end);
+        output.print(self.operator);
     });
     DEFPRINT(AST_Binary, function(output) {
         var self = this;
@@ -1641,7 +1652,8 @@ function OutputStream(options) {
         value.print(output);
     });
     DEFPRINT(AST_DestructuredObject, function(output) {
-        var props = this.properties, len = props.length, rest = this.rest;
+        var self = this;
+        var props = self.properties, len = props.length, rest = self.rest;
         if (len || rest) output.with_block(function() {
             props.forEach(function(prop, i) {
                 if (i) {
@@ -1661,8 +1673,8 @@ function OutputStream(options) {
                 rest.print(output);
             }
             output.newline();
-        });
-        else print_braced_empty(this, output);
+        }, self.end);
+        else print_braced_empty(self, output);
     });
     function print_properties(self, output, no_comma) {
         var props = self.properties;
@@ -1676,7 +1688,7 @@ function OutputStream(options) {
                 prop.print(output);
             });
             output.newline();
-        });
+        }, self.end);
         else print_braced_empty(self, output);
     }
     DEFPRINT(AST_Object, function(output) {
@@ -1738,19 +1750,19 @@ function OutputStream(options) {
         var name = get_symbol_name(self);
         output.print_name(name);
         var alias = self.alias;
-        if (alias != name) {
+        if (alias.value != name) {
             output.space();
             output.print("as");
             output.space();
-            output.print_name(alias);
+            print_alias(alias, output);
         }
     });
     DEFPRINT(AST_SymbolImport, function(output) {
         var self = this;
         var name = get_symbol_name(self);
         var key = self.key;
-        if (key && key != name) {
-            output.print_name(key);
+        if (key.value && key.value != name) {
+            print_alias(key, output);
             output.space();
             output.print("as");
             output.space();
@@ -1771,6 +1783,9 @@ function OutputStream(options) {
         output.print(self.strings[i]);
         output.print("`");
     });
+    DEFPRINT(AST_BigInt, function(output) {
+        output.print(this.value + "n");
+    });
     DEFPRINT(AST_Constant, function(output) {
         output.print("" + this.value);
     });
@@ -1820,9 +1835,6 @@ function OutputStream(options) {
               case "\u2029": return "\\u2029";
             }
         }));
-        var p = output.parent();
-        if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === this)
-            output.print(" ");
     });
 
     function force_statement(stat, output) {
@@ -1870,8 +1882,8 @@ function OutputStream(options) {
             len = match[0].length;
             digits = str.slice(len);
             candidates.push(digits + "e-" + (digits.length + len - 1));
-        } else if (match = /0+$/.exec(str)) {
-            len = match[0].length;
+        } else if (match = /[^0]0+$/.exec(str)) {
+            len = match[0].length - 1;
             candidates.push(str.slice(0, -len) + "e" + len);
         } else if (match = /^(\d)\.(\d+)e(-?\d+)$/.exec(str)) {
             candidates.push(match[1] + match[2] + "e" + (match[3] - match[2].length));
@@ -1889,7 +1901,7 @@ function OutputStream(options) {
             output.indent();
             stmt.print(output);
             output.newline();
-        });
+        }, stmt.end);
     }
 
     /* -----[ source map generators ]----- */
@@ -1912,22 +1924,27 @@ function OutputStream(options) {
     // or if we should add even more.
     DEFMAP([
         AST_Array,
+        AST_Await,
         AST_BlockStatement,
         AST_Catch,
         AST_Constant,
         AST_Debugger,
         AST_Definitions,
         AST_Destructured,
+        AST_Directive,
         AST_Finally,
         AST_Jump,
         AST_Lambda,
         AST_New,
         AST_Object,
+        AST_Spread,
         AST_StatementWithBody,
         AST_Symbol,
         AST_Switch,
         AST_SwitchBranch,
         AST_Try,
+        AST_UnaryPrefix,
+        AST_Yield,
     ], function(output) {
         output.add_mapping(this.start);
     });

lib/parse.js

@@ -207,11 +207,14 @@ function JS_Parse_Error(message, filename, line, col, pos) {
     this.line = line;
     this.col = col;
     this.pos = pos;
+    try {
+        throw new SyntaxError(message, filename, line, col);
+    } catch (cause) {
+        configure_error_stack(this, cause);
     }
-JS_Parse_Error.prototype = Object.create(Error.prototype);
+}
+JS_Parse_Error.prototype = Object.create(SyntaxError.prototype);
 JS_Parse_Error.prototype.constructor = JS_Parse_Error;
-JS_Parse_Error.prototype.name = "SyntaxError";
-configure_error_stack(JS_Parse_Error);
 
 function js_error(message, filename, line, col, pos) {
     throw new JS_Parse_Error(message, filename, line, col, pos);
@@ -237,8 +240,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         newline_before  : false,
         regex_allowed   : false,
         comments_before : [],
-        directives      : {},
-        directive_stack : [],
+        directives      : Object.create(null),
         read_template   : with_eof_error("Unterminated template literal", function(strings) {
             var s = "";
             for (;;) {
@@ -392,7 +394,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         var valid = parse_js_number(num);
         if (isNaN(valid)) parse_error("Invalid syntax: " + num);
         if (has_dot || has_e || peek() != "n") return token("num", valid);
-        return token("bigint", num.toLowerCase() + next());
+        next();
+        return token("bigint", num.toLowerCase());
     }
 
     function read_escaped_char(in_string) {
@@ -553,16 +556,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     function handle_dot() {
         next();
-        var ch = peek();
-        if (ch == ".") {
-            var op = ".";
-            do {
-                op += ".";
-                next();
-            } while (peek() == ".");
-            return token("operator", op);
-        }
-        return is_digit(ch.charCodeAt(0)) ? read_num(".") : token("punc", ".");
+        if (looking_at("..")) return token("operator", "." + next() + next());
+        return is_digit(peek().charCodeAt(0)) ? read_num(".") : token("punc", ".");
     }
 
     function read_word() {
@@ -635,24 +630,19 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     };
 
     next_token.add_directive = function(directive) {
-        S.directive_stack[S.directive_stack.length - 1].push(directive);
-        if (S.directives[directive]) S.directives[directive]++;
-        else S.directives[directive] = 1;
+        S.directives[directive] = true;
     }
 
     next_token.push_directives_stack = function() {
-        S.directive_stack.push([]);
+        S.directives = Object.create(S.directives);
     }
 
     next_token.pop_directives_stack = function() {
-        var directives = S.directive_stack.pop();
-        for (var i = directives.length; --i >= 0;) {
-            S.directives[directives[i]]--;
-        }
+        S.directives = Object.getPrototypeOf(S.directives);
     }
 
     next_token.has_directive = function(directive) {
-        return S.directives[directive] > 0;
+        return !!S.directives[directive];
     }
 
     return next_token;
@@ -699,6 +689,7 @@ function parse($TEXT, options) {
         expression     : false,
         filename       : null,
         html5_comments : true,
+        module         : false,
         shebang        : true,
         strict         : false,
         toplevel       : null,
@@ -795,7 +786,7 @@ function parse($TEXT, options) {
         else if (!optional && !can_insert_semicolon()) expect(";");
     }
 
-    function parenthesised() {
+    function parenthesized() {
         expect("(");
         var exp = expression();
         expect(")");
@@ -820,7 +811,7 @@ function parse($TEXT, options) {
         }
     }
 
-    var statement = embed_tokens(function() {
+    var statement = embed_tokens(function(toplevel) {
         handle_regexp();
         switch (S.token.type) {
           case "string":
@@ -859,15 +850,15 @@ function parse($TEXT, options) {
                 if (S.in_async) return simple_statement();
                 break;
               case "export":
+                if (!toplevel && options.module !== "") unexpected();
                 next();
                 return export_();
               case "import":
                 var token = peek();
-                if (!(token.type == "punc" && /^[(.]$/.test(token.value))) {
+                if (token.type == "punc" && /^[(.]$/.test(token.value)) break;
+                if (!toplevel && options.module !== "") unexpected();
                 next();
                 return import_();
-                }
-                break;
               case "let":
                 if (is_vardefs()) {
                     next();
@@ -933,18 +924,18 @@ function parse($TEXT, options) {
                 next();
                 var body = in_loop(statement);
                 expect_token("keyword", "while");
-                var condition = parenthesised();
+                var condition = parenthesized();
                 semicolon(true);
                 return new AST_Do({
                     body      : body,
-                    condition : condition
+                    condition : condition,
                 });
 
               case "while":
                 next();
                 return new AST_While({
-                    condition : parenthesised(),
-                    body      : in_loop(statement)
+                    condition : parenthesized(),
+                    body      : in_loop(statement),
                 });
 
               case "for":
@@ -972,15 +963,13 @@ function parse($TEXT, options) {
                     value = expression();
                     semicolon();
                 }
-                return new AST_Return({
-                    value: value
-                });
+                return new AST_Return({ value: value });
 
               case "switch":
                 next();
                 return new AST_Switch({
-                    expression : parenthesised(),
-                    body       : in_loop(switch_body_)
+                    expression : parenthesized(),
+                    body       : in_loop(switch_body_),
                 });
 
               case "throw":
@@ -989,9 +978,7 @@ function parse($TEXT, options) {
                     croak("Illegal newline after 'throw'");
                 var value = expression();
                 semicolon();
-                return new AST_Throw({
-                    value: value
-                });
+                return new AST_Throw({ value: value });
 
               case "try":
                 next();
@@ -1009,8 +996,8 @@ function parse($TEXT, options) {
                 }
                 next();
                 return new AST_With({
-                    expression : parenthesised(),
-                    body       : statement()
+                    expression : parenthesized(),
+                    body       : statement(),
                 });
             }
         }
@@ -1069,13 +1056,13 @@ function parse($TEXT, options) {
         return stat;
     }
 
-    function has_modifier(name) {
+    function has_modifier(name, no_nlb) {
         if (!is("name", name)) return;
         var token = peek();
         if (!token) return;
         if (is_token(token, "operator", "=")) return;
         if (token.type == "punc" && /^[(;}]$/.test(token.value)) return;
-        if (has_newline_before(token)) return;
+        if (no_nlb && has_newline_before(token)) return;
         return next();
     }
 
@@ -1105,7 +1092,7 @@ function parse($TEXT, options) {
             }
             var start = S.token;
             var fixed = !!has_modifier("static");
-            var async = has_modifier("async");
+            var async = has_modifier("async", true);
             if (is("operator", "*")) {
                 next();
                 var internal = is("name") && /^#/.test(S.token.value);
@@ -1124,6 +1111,18 @@ function parse($TEXT, options) {
                 }));
                 continue;
             }
+            if (fixed && is("punc", "{")) {
+                props.push(new AST_ClassInit({
+                    start: start,
+                    value: new AST_ClassInitBlock({
+                        start: start,
+                        body: block_(),
+                        end: prev(),
+                    }),
+                    end: prev(),
+                }));
+                continue;
+            }
             var internal = is("name") && /^#/.test(S.token.value);
             var key = as_property_key();
             if (is("punc", "(")) {
@@ -1194,10 +1193,10 @@ function parse($TEXT, options) {
     }
 
     function for_() {
-        var await = is("name", "await") && next();
+        var await_token = is("name", "await") && next();
         expect("(");
         var init = null;
-        if (await || !is("punc", ";")) {
+        if (await_token || !is("punc", ";")) {
             init = is("keyword", "const")
                 ? (next(), const_(true))
                 : is("name", "let") && is_vardefs()
@@ -1206,7 +1205,7 @@ function parse($TEXT, options) {
                 ? (next(), var_(true))
                 : expression(true);
             var ctor;
-            if (await) {
+            if (await_token) {
                 expect_token("name", "of");
                 ctor = AST_ForAwaitOf;
             } else if (is("operator", "in")) {
@@ -1340,11 +1339,11 @@ function parse($TEXT, options) {
         var loop = S.in_loop;
         var labels = S.labels;
         ++S.in_function;
-        S.in_directives = true;
         S.input.push_directives_stack();
         S.in_loop = 0;
         S.labels = [];
         if (is("punc", "{")) {
+            S.in_directives = true;
             body = block_();
             value = null;
         } else {
@@ -1412,7 +1411,7 @@ function parse($TEXT, options) {
             name: name,
             argnames: argnames,
             rest: argnames.rest || null,
-            body: body
+            body: body,
         });
         if (is_strict) {
             if (name) strict_verify_symbol(name);
@@ -1422,41 +1421,54 @@ function parse($TEXT, options) {
     };
 
     function if_() {
-        var cond = parenthesised(), body = statement(), belse = null;
+        var cond = parenthesized(), body = statement(), alt = null;
         if (is("keyword", "else")) {
             next();
-            belse = statement();
+            alt = statement();
         }
         return new AST_If({
             condition   : cond,
             body        : body,
-            alternative : belse
+            alternative : alt,
         });
     }
 
     function is_alias() {
-        return is("name") || is_identifier_string(S.token.value);
+        return is("name") || is("string") || is_identifier_string(S.token.value);
+    }
+
+    function make_string(token) {
+        return new AST_String({
+            start: token,
+            quote: token.quote,
+            value: token.value,
+            end: token,
+        });
+    }
+
+    function as_path() {
+        var path = S.token;
+        expect_token("string");
+        semicolon();
+        return make_string(path);
     }
 
     function export_() {
         if (is("operator", "*")) {
+            var key = S.token;
+            var alias = key;
             next();
-            var alias = "*";
             if (is("name", "as")) {
                 next();
                 if (!is_alias()) expect_token("name");
-                alias = S.token.value;
+                alias = S.token;
                 next();
             }
             expect_token("name", "from");
-            var path = S.token;
-            expect_token("string");
-            semicolon();
             return new AST_ExportForeign({
-                aliases: [ alias ],
-                keys: [ "*" ],
-                path: path.value,
-                quote: path.quote,
+                aliases: [ make_string(alias) ],
+                keys: [ make_string(key) ],
+                path: as_path(),
             });
         }
         if (is("punc", "{")) {
@@ -1470,26 +1482,20 @@ function parse($TEXT, options) {
                 if (is("name", "as")) {
                     next();
                     if (!is_alias()) expect_token("name");
-                    aliases.push(S.token.value);
+                    aliases.push(S.token);
                     next();
                 } else {
-                    aliases.push(key.value);
+                    aliases.push(key);
                 }
                 if (!is("punc", "}")) expect(",");
             }
             expect("}");
             if (is("name", "from")) {
                 next();
-                var path = S.token;
-                expect_token("string");
-                semicolon();
                 return new AST_ExportForeign({
-                    aliases: aliases,
-                    keys: keys.map(function(token) {
-                        return token.value;
-                    }),
-                    path: path.value,
-                    quote: path.quote,
+                    aliases: aliases.map(make_string),
+                    keys: keys.map(make_string),
+                    path: as_path(),
                 });
             }
             semicolon();
@@ -1497,7 +1503,7 @@ function parse($TEXT, options) {
                 properties: keys.map(function(token, index) {
                     if (!is_token(token, "name")) token_error(token, "Name expected");
                     var sym = _make_symbol(AST_SymbolExport, token);
-                    sym.alias = aliases[index];
+                    sym.alias = make_string(aliases[index]);
                     return sym;
                 }),
             });
@@ -1587,26 +1593,42 @@ function parse($TEXT, options) {
         var all = null;
         var def = as_symbol(AST_SymbolImport, true);
         var props = null;
-        if (def ? (def.key = "", is("punc", ",") && next()) : !is("string")) {
+        var cont;
+        if (def) {
+            def.key = new AST_String({
+                start: def.start,
+                value: "",
+                end: def.end,
+            });
+            if (cont = is("punc", ",")) next();
+        } else {
+            cont = !is("string");
+        }
+        if (cont) {
             if (is("operator", "*")) {
+                var key = S.token;
                 next();
                 expect_token("name", "as");
                 all = as_symbol(AST_SymbolImport);
-                all.key = "*";
+                all.key = make_string(key);
             } else {
                 expect("{");
                 props = [];
                 while (is_alias()) {
                     var alias;
                     if (is_token(peek(), "name", "as")) {
-                        var key = S.token.value;
+                        var key = S.token;
                         next();
                         next();
                         alias = as_symbol(AST_SymbolImport);
-                        alias.key = key;
+                        alias.key = make_string(key);
                     } else {
                         alias = as_symbol(AST_SymbolImport);
-                        alias.key = alias.name;
+                        alias.key = new AST_String({
+                            start: alias.start,
+                            value: alias.name,
+                            end: alias.end,
+                        });
                     }
                     props.push(alias);
                     if (!is("punc", "}")) expect(",");
@@ -1615,15 +1637,11 @@ function parse($TEXT, options) {
             }
         }
         if (all || def || props) expect_token("name", "from");
-        var path = S.token;
-        expect_token("string");
-        semicolon();
         return new AST_Import({
             all: all,
             default: def,
-            path: path.value,
+            path: as_path(),
             properties: props,
-            quote: path.quote,
         });
     }
 
@@ -2153,9 +2171,9 @@ function parse($TEXT, options) {
             token_error(sym.start, "Unexpected " + sym.name + " in strict mode");
     }
 
-    function as_symbol(type, noerror) {
+    function as_symbol(type, no_error) {
         if (!is("name")) {
-            if (!noerror) croak("Name expected");
+            if (!no_error) croak("Name expected");
             return null;
         }
         var sym = _make_symbol(type, S.token);
@@ -2316,9 +2334,8 @@ function parse($TEXT, options) {
             var comments = start.comments_before;
             var i = HOP(start, "comments_before_length") ? start.comments_before_length : comments.length;
             while (--i >= 0) {
-                var match = /[@#]__PURE__/.exec(comments[i].value);
-                if (match) {
-                    expr.pure = match[0];
+                if (/[@#]__PURE__/.test(comments[i].value)) {
+                    expr.pure = true;
                     break;
                 }
             }
@@ -2392,20 +2409,20 @@ function parse($TEXT, options) {
         return new ctor({ operator: op, expression: expr });
     }
 
-    var expr_op = function(left, min_prec, no_in) {
+    var expr_op = function(left, min_precision, no_in) {
         var op = is("operator") ? S.token.value : null;
         if (op == "in" && no_in) op = null;
-        var prec = op != null ? PRECEDENCE[op] : null;
-        if (prec != null && prec > min_prec) {
+        var precision = op != null ? PRECEDENCE[op] : null;
+        if (precision != null && precision > min_precision) {
             next();
-            var right = expr_op(maybe_unary(no_in), op == "**" ? prec - 1 : prec, no_in);
+            var right = expr_op(maybe_unary(no_in), op == "**" ? precision - 1 : precision, no_in);
             return expr_op(new AST_Binary({
                 start    : left.start,
                 left     : left,
                 operator : op,
                 right    : right,
-                end      : right.end
-            }), min_prec, no_in);
+                end      : right.end,
+            }), min_precision, no_in);
         }
         return left;
     };
@@ -2551,9 +2568,13 @@ function parse($TEXT, options) {
     return function() {
         var start = S.token;
         var body = [];
+        if (options.module) {
+            S.in_async = true;
+            S.input.add_directive("use strict");
+        }
         S.input.push_directives_stack();
         while (!is("eof"))
-            body.push(statement());
+            body.push(statement(true));
         S.input.pop_directives_stack();
         var end = prev() || start;
         var toplevel = options.toplevel;

lib/propmangle.js

@@ -43,10 +43,11 @@
 
 "use strict";
 
-var builtins = function() {
-    var names = [];
-    // NaN will be included due to Number.NaN
+function get_builtins() {
+    var names = new Dictionary();
+    // constants
     [
+        "NaN",
         "null",
         "true",
         "false",
@@ -54,37 +55,85 @@ var builtins = function() {
         "-Infinity",
         "undefined",
     ].forEach(add);
+    // global functions
     [
-        Array,
-        Boolean,
-        Date,
-        Error,
-        Function,
-        Math,
-        Number,
-        Object,
-        RegExp,
-        String,
-    ].forEach(function(ctor) {
+        "encodeURI",
+        "encodeURIComponent",
+        "escape",
+        "eval",
+        "decodeURI",
+        "decodeURIComponent",
+        "isFinite",
+        "isNaN",
+        "parseFloat",
+        "parseInt",
+        "unescape",
+    ].forEach(add);
+    // global constructors & objects
+    var global = Function("return this")();
+    [
+        "Array",
+        "ArrayBuffer",
+        "Atomics",
+        "BigInt",
+        "Boolean",
+        "console",
+        "DataView",
+        "Date",
+        "Error",
+        "Function",
+        "Int8Array",
+        "Intl",
+        "JSON",
+        "Map",
+        "Math",
+        "Number",
+        "Object",
+        "Promise",
+        "Proxy",
+        "Reflect",
+        "RegExp",
+        "Set",
+        "String",
+        "Symbol",
+        "WebAssembly",
+    ].forEach(function(name) {
+        add(name);
+        var ctor = global[name];
+        if (!ctor) return;
         Object.getOwnPropertyNames(ctor).map(add);
-        if (ctor.prototype) {
+        if (typeof ctor != "function") return;
+        if (ctor.__proto__) Object.getOwnPropertyNames(ctor.__proto__).map(add);
+        if (ctor.prototype) Object.getOwnPropertyNames(ctor.prototype).map(add);
+        try {
             Object.getOwnPropertyNames(new ctor()).map(add);
-            Object.getOwnPropertyNames(ctor.prototype).map(add);
+        } catch (e) {
+            try {
+                Object.getOwnPropertyNames(ctor()).map(add);
+            } catch (e) {}
         }
     });
-    return makePredicate(names);
+    return (get_builtins = function() {
+        return names.clone();
+    })();
 
     function add(name) {
-        names.push(name);
+        names.set(name, true);
+    }
 }
-}();
 
 function reserve_quoted_keys(ast, reserved) {
     ast.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_ClassProperty) {
-            if (node.start && node.start.quote) add(node.key);
-        } else if (node instanceof AST_ObjectProperty) {
-            if (node.start && node.start.quote) add(node.key);
+        if (node instanceof AST_ClassProperty
+            || node instanceof AST_DestructuredKeyVal
+            || node instanceof AST_ObjectProperty) {
+            if (node.key instanceof AST_Node) {
+                addStrings(node.key, add);
+            } else if (node.start && node.start.quote) {
+                add(node.key);
+            }
+        } else if (node instanceof AST_Dot) {
+            if (node.quoted) add(node.property);
         } else if (node instanceof AST_Sub) {
             addStrings(node.property, add);
         }
@@ -111,14 +160,18 @@ function mangle_properties(ast, options) {
         builtins: false,
         cache: null,
         debug: false,
+        domprops: false,
         keep_quoted: false,
         regex: null,
         reserved: null,
     }, true);
 
-    var reserved = Object.create(options.builtins ? null : builtins);
+    var reserved = options.builtins ? new Dictionary() : get_builtins();
+    if (!options.domprops && typeof domprops !== "undefined") domprops.forEach(function(name) {
+        reserved.set(name, true);
+    });
     if (Array.isArray(options.reserved)) options.reserved.forEach(function(name) {
-        reserved[name] = true;
+        reserved.set(name, true);
     });
 
     var cname = -1;
@@ -126,7 +179,7 @@ function mangle_properties(ast, options) {
     if (options.cache) {
         cache = options.cache.props;
         cache.each(function(name) {
-            reserved[name] = true;
+            reserved.set(name, true);
         });
     } else {
         cache = new Dictionary();
@@ -135,20 +188,18 @@ function mangle_properties(ast, options) {
     var regex = options.regex;
 
     // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
-    // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
+    // note debug may be enabled as an empty string, which is falsy. Also treat passing 'true'
     // the same as passing an empty string.
     var debug = options.debug !== false;
     var debug_suffix;
     if (debug) debug_suffix = options.debug === true ? "" : options.debug;
 
-    var names_to_mangle = Object.create(null);
-    var unmangleable = Object.create(reserved);
+    var names_to_mangle = new Dictionary();
+    var unmangleable = reserved.clone();
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_Binary) {
-            if (node.operator == "in") addStrings(node.left, add);
-        } else if (node.TYPE == "Call") {
+        if (node.TYPE == "Call") {
             var exp = node.expression;
             if (exp instanceof AST_Dot) switch (exp.property) {
               case "defineProperty":
@@ -165,14 +216,18 @@ function mangle_properties(ast, options) {
                 addStrings(node.args[0], add);
                 break;
             }
-        } else if (node instanceof AST_ClassProperty) {
-            if (typeof node.key == "string") add(node.key);
+        } else if (node instanceof AST_ClassProperty
+            || node instanceof AST_DestructuredKeyVal
+            || node instanceof AST_ObjectProperty) {
+            if (node.key instanceof AST_Node) {
+                addStrings(node.key, add);
+            } else {
+                add(node.key);
+            }
         } else if (node instanceof AST_Dot) {
-            add(node.property);
-        } else if (node instanceof AST_ObjectProperty) {
-            if (typeof node.key == "string") add(node.key);
+            if (is_lhs(node, this.parent())) add(node.property);
         } else if (node instanceof AST_Sub) {
-            addStrings(node.property, add);
+            if (is_lhs(node, this.parent())) addStrings(node.property, add);
         }
     }));
 
@@ -197,12 +252,16 @@ function mangle_properties(ast, options) {
                 mangleStrings(node.args[0]);
                 break;
             }
-        } else if (node instanceof AST_ClassProperty) {
-            if (typeof node.key == "string") node.key = mangle(node.key);
+        } else if (node instanceof AST_ClassProperty
+            || node instanceof AST_DestructuredKeyVal
+            || node instanceof AST_ObjectProperty) {
+            if (node.key instanceof AST_Node) {
+                mangleStrings(node.key);
+            } else {
+                node.key = mangle(node.key);
+            }
         } else if (node instanceof AST_Dot) {
             node.property = mangle(node.property);
-        } else if (node instanceof AST_ObjectProperty) {
-            if (typeof node.key == "string") node.key = mangle(node.key);
         } else if (node instanceof AST_Sub) {
             if (!options.keep_quoted) mangleStrings(node.property);
         }
@@ -211,20 +270,26 @@ function mangle_properties(ast, options) {
     // only function declarations after this line
 
     function can_mangle(name) {
-        if (unmangleable[name]) return false;
+        if (unmangleable.has(name)) return false;
         if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false;
         return true;
     }
 
     function should_mangle(name) {
-        if (reserved[name]) return false;
-        if (regex && !regex.test(name)) return false;
-        return cache.has(name) || names_to_mangle[name];
+        if (reserved.has(name)) {
+            AST_Node.info("Preserving reserved property {this}", name);
+            return false;
+        }
+        if (regex && !regex.test(name)) {
+            AST_Node.info("Preserving excluded property {this}", name);
+            return false;
+        }
+        return cache.has(name) || names_to_mangle.has(name);
     }
 
     function add(name) {
-        if (can_mangle(name)) names_to_mangle[name] = true;
-        if (!should_mangle(name)) unmangleable[name] = true;
+        if (can_mangle(name)) names_to_mangle.set(name, true);
+        if (!should_mangle(name)) unmangleable.set(name, true);
     }
 
     function mangle(name) {
@@ -243,12 +308,16 @@ function mangle_properties(ast, options) {
             if (/^#/.test(name)) mangled = "#" + mangled;
             cache.set(name, mangled);
         }
+        AST_Node.info("Mapping property {name} to {mangled}", {
+            mangled: mangled,
+            name: name,
+        });
         return mangled;
     }
 
     function mangleStrings(node) {
         if (node instanceof AST_Sequence) {
-            mangleStrings(node.expressions.tail_node());
+            mangleStrings(node.tail_node());
         } else if (node instanceof AST_String) {
             node.value = mangle(node.value);
         } else if (node instanceof AST_Conditional) {

lib/scope.js

@@ -44,9 +44,9 @@
 "use strict";
 
 function SymbolDef(id, scope, orig, init) {
+    this._bits = 0;
+    this.defun = undefined;
     this.eliminated = 0;
-    this.exported = false;
-    this.global = false;
     this.id = id;
     this.init = init;
     this.mangled_name = null;
@@ -54,8 +54,8 @@ function SymbolDef(id, scope, orig, init) {
     this.orig = [ orig ];
     this.references = [];
     this.replaced = 0;
+    this.safe_ids = undefined;
     this.scope = scope;
-    this.undeclared = false;
 }
 
 SymbolDef.prototype = {
@@ -64,19 +64,18 @@ SymbolDef.prototype = {
         this.references.forEach(fn);
     },
     mangle: function(options) {
-        var cache = options.cache && options.cache.props;
-        if (this.global && cache && cache.has(this.name)) {
+        if (this.mangled_name) return;
+        var cache = this.global && options.cache && options.cache.props;
+        if (cache && cache.has(this.name)) {
             this.mangled_name = cache.get(this.name);
-        } else if (!this.mangled_name && !this.unmangleable(options)) {
+        } else if (!this.unmangleable(options)) {
             var def = this.redefined();
             if (def) {
                 this.mangled_name = def.mangled_name || def.name;
             } else {
                 this.mangled_name = next_mangled_name(this, options);
             }
-            if (this.global && cache) {
-                cache.set(this.name, this.mangled_name);
-            }
+            if (cache) cache.set(this.name, this.mangled_name);
         }
     },
     redefined: function() {
@@ -92,18 +91,35 @@ SymbolDef.prototype = {
         if (def && def !== self) return def.redefined() || def;
     },
     unmangleable: function(options) {
-        return this.global && !options.toplevel
-            || this.exported
-            || this.undeclared
-            || !options.eval && this.scope.pinned()
-            || options.keep_fnames
-                && (this.orig[0] instanceof AST_SymbolClass
-                    || this.orig[0] instanceof AST_SymbolDefClass
-                    || this.orig[0] instanceof AST_SymbolDefun
-                    || this.orig[0] instanceof AST_SymbolLambda);
+        if (this.exported) return true;
+        if (this.undeclared) return true;
+        if (!options.eval && this.scope.pinned()) return true;
+        if (options.keep_fargs && is_funarg(this)) return true;
+        if (options.keep_fnames) {
+            var sym = this.orig[0];
+            if (sym instanceof AST_SymbolClass) return true;
+            if (sym instanceof AST_SymbolDefClass) return true;
+            if (sym instanceof AST_SymbolDefun) return true;
+            if (sym instanceof AST_SymbolLambda) return true;
+        }
+        if (!options.toplevel && this.global) return true;
+        return false;
     },
 };
 
+DEF_BITPROPS(SymbolDef, [
+    "const_redefs",
+    "cross_loop",
+    "direct_access",
+    "exported",
+    "global",
+    "undeclared",
+]);
+
+function is_funarg(def) {
+    return def.orig[0] instanceof AST_SymbolFunarg || def.orig[1] instanceof AST_SymbolFunarg;
+}
+
 var unary_side_effects = makePredicate("delete ++ --");
 
 function is_lhs(node, parent) {
@@ -162,6 +178,13 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             });
             return true;
         }
+        if (node instanceof AST_Switch) {
+            node.expression.walk(tw);
+            walk_scope(function() {
+                walk_body(node, tw);
+            });
+            return true;
+        }
         if (node instanceof AST_SwitchBranch) {
             node.init_vars(scope);
             descend();
@@ -205,20 +228,17 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         } else if (node instanceof AST_SymbolDefun) {
             var def = defun.def_function(node, tw.parent());
             if (exported) def.exported = true;
-            entangle(defun, scope);
         } else if (node instanceof AST_SymbolFunarg) {
             defun.def_variable(node);
-            entangle(defun, scope);
         } else if (node instanceof AST_SymbolLambda) {
             var def = defun.def_function(node, node.name == "arguments" ? undefined : defun);
-            if (options.ie) def.defun = defun.parent_scope.resolve();
+            if (options.ie && node.name != "arguments") def.defun = defun.parent_scope.resolve();
         } else if (node instanceof AST_SymbolLet) {
             var def = scope.def_variable(node);
             if (exported) def.exported = true;
         } else if (node instanceof AST_SymbolVar) {
             var def = defun.def_variable(node, node instanceof AST_SymbolImport ? undefined : null);
             if (exported) def.exported = true;
-            entangle(defun, scope);
         }
 
         function walk_scope(descend) {
@@ -231,16 +251,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             scope = save_scope;
             defun = save_defun;
         }
-
-        function entangle(defun, scope) {
-            if (defun === scope) return;
-            node.mark_enclosed(options);
-            var def = scope.find_variable(node.name);
-            if (node.thedef === def) return;
-            node.thedef = def;
-            def.orig.push(node);
-            node.mark_enclosed(options);
-        }
     });
     self.make_def = function(orig, init) {
         return new SymbolDef(++next_def_id, this, orig, init);
@@ -261,6 +271,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         }
         if (node instanceof AST_Lambda) {
             in_arg.push(node);
+            if (node.name) node.name.walk(tw);
             node.argnames.forEach(function(argname) {
                 argname.walk(tw);
             });
@@ -280,13 +291,23 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
                 // ensure mangling works if `catch` reuses a scope variable
                 var redef = def.redefined();
                 if (redef) for (var s = node.scope; s; s = s.parent_scope) {
-                    push_uniq(s.enclosed, redef);
+                    if (!push_uniq(s.enclosed, redef)) break;
                     if (s === redef.scope) break;
                 }
             } else if (node instanceof AST_SymbolConst) {
                 // ensure compression works if `const` reuses a scope variable
                 var redef = def.redefined();
                 if (redef) redef.const_redefs = true;
+            } else if (def.scope !== node.scope && (node instanceof AST_SymbolDefun
+                || node instanceof AST_SymbolFunarg
+                || node instanceof AST_SymbolVar)) {
+                node.mark_enclosed(options);
+                var redef = node.scope.find_variable(node.name);
+                if (node.thedef !== redef) {
+                    node.thedef = redef;
+                    redef.orig.push(node);
+                    node.mark_enclosed(options);
+                }
             }
             if (node.name != "arguments") return true;
             var parent = node instanceof AST_SymbolVar && tw.parent();
@@ -353,8 +374,9 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     // pass 3: fix up any scoping issue with IE8
     if (options.ie) self.walk(new TreeWalker(function(node) {
         if (node instanceof AST_SymbolCatch) {
-            var scope = node.thedef.defun;
-            if (scope.name instanceof AST_SymbolLambda && scope.name.name == node.name) {
+            var def = node.thedef;
+            var scope = def.defun;
+            if (def.name != "arguments" && scope.name instanceof AST_SymbolLambda && scope.name.name == def.name) {
                 scope = scope.parent_scope.resolve();
             }
             redefine(node, scope);
@@ -363,7 +385,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         if (node instanceof AST_SymbolLambda) {
             var def = node.thedef;
             if (!redefine(node, node.scope.parent_scope.resolve())) {
-                delete def.defun;
+                def.defun = undefined;
             } else if (typeof node.thedef.init !== "undefined") {
                 node.thedef.init = false;
             } else if (def.init) {
@@ -422,38 +444,47 @@ AST_Toplevel.DEFMETHOD("def_global", function(node) {
     }
 });
 
-function init_block_vars(scope, parent) {
-    scope.enclosed = [];                            // variables from this or outer scope(s) that are referenced from this or inner scopes
-    scope.parent_scope = parent;                    // the parent scope (null if this is the top level)
-    scope.functions = new Dictionary();             // map name to AST_SymbolDefun (functions defined in this scope)
-    scope.variables = new Dictionary();             // map name to AST_SymbolVar (variables defined in this scope; includes functions)
-    if (parent) scope.make_def = parent.make_def;   // top-level tracking of SymbolDef instances
+function init_block_vars(scope, parent, orig) {
+    // variables from this or outer scope(s) that are referenced from this or inner scopes
+    scope.enclosed = orig ? orig.enclosed.slice() : [];
+    // map name to AST_SymbolDefun (functions defined in this scope)
+    scope.functions = orig ? orig.functions.clone() : new Dictionary();
+    // map name to AST_SymbolVar (variables defined in this scope; includes functions)
+    scope.variables = orig ? orig.variables.clone() : new Dictionary();
+    if (!parent) return;
+    // top-level tracking of SymbolDef instances
+    scope.make_def = parent.make_def;
+    // the parent scope (null if this is the top level)
+    scope.parent_scope = parent;
 }
 
-function init_scope_vars(scope, parent) {
-    init_block_vars(scope, parent);
-    scope.uses_eval = false;                        // will be set to true if this or nested scope uses the global `eval`
-    scope.uses_with = false;                        // will be set to true if this or some nested scope uses the `with` statement
+function init_scope_vars(scope, parent, orig) {
+    init_block_vars(scope, parent, orig);
+    // will be set to true if this or nested scope uses the global `eval`
+    scope.uses_eval = false;
+    // will be set to true if this or some nested scope uses the `with` statement
+    scope.uses_with = false;
 }
 
-AST_BlockScope.DEFMETHOD("init_vars", function(parent_scope) {
-    init_block_vars(this, parent_scope);
+AST_BlockScope.DEFMETHOD("init_vars", function(parent, orig) {
+    init_block_vars(this, parent, orig);
 });
-AST_Scope.DEFMETHOD("init_vars", function(parent_scope) {
-    init_scope_vars(this, parent_scope);
+AST_Scope.DEFMETHOD("init_vars", function(parent, orig) {
+    init_scope_vars(this, parent, orig);
 });
-AST_Arrow.DEFMETHOD("init_vars", function(parent_scope) {
-    init_scope_vars(this, parent_scope);
+AST_Arrow.DEFMETHOD("init_vars", function(parent, orig) {
+    init_scope_vars(this, parent, orig);
     return this;
 });
-AST_AsyncArrow.DEFMETHOD("init_vars", function(parent_scope) {
-    init_scope_vars(this, parent_scope);
+AST_AsyncArrow.DEFMETHOD("init_vars", function(parent, orig) {
+    init_scope_vars(this, parent, orig);
 });
-AST_Lambda.DEFMETHOD("init_vars", function(parent_scope) {
-    init_scope_vars(this, parent_scope);
+AST_Lambda.DEFMETHOD("init_vars", function(parent, orig) {
+    init_scope_vars(this, parent, orig);
     this.uses_arguments = false;
     this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
+        scope: this,
         start: this.start,
         end: this.end,
     }));
@@ -463,11 +494,14 @@ AST_Lambda.DEFMETHOD("init_vars", function(parent_scope) {
 AST_Symbol.DEFMETHOD("mark_enclosed", function(options) {
     var def = this.definition();
     for (var s = this.scope; s; s = s.parent_scope) {
-        push_uniq(s.enclosed, def);
+        if (!push_uniq(s.enclosed, def)) break;
         if (!options) {
-            delete s._var_names;
-        } else if (options.keep_fnames) {
-            s.functions.each(function(d) {
+            s._var_names = undefined;
+        } else {
+            if (options.keep_fargs && s instanceof AST_Lambda) s.each_argname(function(arg) {
+                push_uniq(def.scope.enclosed, arg.definition());
+            });
+            if (options.keep_fnames) s.functions.each(function(d) {
                 push_uniq(def.scope.enclosed, d);
             });
         }
@@ -510,12 +544,12 @@ function names_in_use(scope, options) {
     if (!names) {
         scope.cname = -1;
         scope.cname_holes = [];
-        scope.names_in_use = names = Object.create(null);
+        scope.names_in_use = names = new Dictionary();
         var cache = options.cache && options.cache.props;
         scope.enclosed.forEach(function(def) {
-            if (def.unmangleable(options)) names[def.name] = true;
+            if (def.unmangleable(options)) names.set(def.name, true);
             if (def.global && cache && cache.has(def.name)) {
-                names[cache.get(def.name)] = true;
+                names.set(cache.get(def.name), true);
             }
         });
     }
@@ -526,34 +560,33 @@ function next_mangled_name(def, options) {
     var scope = def.scope;
     var in_use = names_in_use(scope, options);
     var holes = scope.cname_holes;
-    var names = Object.create(null);
+    var names = new Dictionary();
     var scopes = [ scope ];
     def.forEach(function(sym) {
         var scope = sym.scope;
         do {
-            if (scopes.indexOf(scope) < 0) {
-                for (var name in names_in_use(scope, options)) {
-                    names[name] = true;
-                }
+            if (member(scope, scopes)) break;
+            names_in_use(scope, options).each(function(marker, name) {
+                names.set(name, marker);
+            });
             scopes.push(scope);
-            } else break;
         } while (scope = scope.parent_scope);
     });
     var name;
     for (var i = 0; i < holes.length; i++) {
         name = base54(holes[i]);
-        if (names[name]) continue;
+        if (names.has(name)) continue;
         holes.splice(i, 1);
-        in_use[name] = true;
+        in_use.set(name, true);
         return name;
     }
     while (true) {
         name = base54(++scope.cname);
-        if (in_use[name] || RESERVED_WORDS[name] || options.reserved.has[name]) continue;
-        if (!names[name]) break;
+        if (in_use.has(name) || RESERVED_WORDS[name] || options.reserved.has[name]) continue;
+        if (!names.has(name)) break;
         holes.push(scope.cname);
     }
-    in_use[name] = true;
+    in_use.set(name, true);
     return name;
 }
 
@@ -573,6 +606,7 @@ function _default_mangler_options(options) {
     options = defaults(options, {
         eval        : false,
         ie          : false,
+        keep_fargs  : false,
         keep_fnames : false,
         reserved    : [],
         toplevel    : false,
@@ -580,38 +614,32 @@ function _default_mangler_options(options) {
         webkit      : false,
     });
     if (!Array.isArray(options.reserved)) options.reserved = [];
-    // Never mangle arguments
+    // Never mangle `arguments`
     push_uniq(options.reserved, "arguments");
     options.reserved.has = makePredicate(options.reserved);
     return options;
 }
 
+// We only need to mangle declaration nodes. Special logic wired into the code
+// generator will display the mangled name if it is present (and for
+// `AST_SymbolRef`s it will use the mangled name of the `AST_SymbolDeclaration`
+// that it points to).
 AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
     options = _default_mangler_options(options);
-
-    // We only need to mangle declaration nodes.  Special logic wired
-    // into the code generator will display the mangled name if it's
-    // present (and for AST_SymbolRef-s it'll use the mangled name of
-    // the AST_SymbolDeclaration that it points to).
-    var lname = -1;
-
     if (options.cache && options.cache.props) {
         var mangled_names = names_in_use(this, options);
         options.cache.props.each(function(mangled_name) {
-            mangled_names[mangled_name] = true;
+            mangled_names.set(mangled_name, true);
         });
     }
-
+    var cutoff = 36;
+    var lname = -1;
     var redefined = [];
     var tw = new TreeWalker(function(node, descend) {
-        if (node instanceof AST_LabeledStatement) {
-            // lname is incremented when we get to the AST_Label
-            var save_nesting = lname;
-            descend();
-            if (!options.v8 || !in_label(tw)) lname = save_nesting;
-            return true;
-        }
+        var save_nesting;
         if (node instanceof AST_BlockScope) {
+            // `lname` is incremented when we get to the `AST_Label`
+            if (node instanceof AST_LabeledStatement) save_nesting = lname;
             if (options.webkit && node instanceof AST_IterationStatement && node.init instanceof AST_Let) {
                 node.init.definitions.forEach(function(defn) {
                     defn.name.match_symbol(function(sym) {
@@ -627,9 +655,13 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
                     });
                 }, true);
             }
-            node.to_mangle = [];
-            node.variables.each(function(def) {
-                if (!defer_redef(def)) node.to_mangle.push(def);
+            var to_mangle = node.to_mangle = [];
+            node.variables.each(function(def, name) {
+                if (def.unmangleable(options)) {
+                    names_in_use(node, options).set(name, true);
+                } else if (!defer_redef(def)) {
+                    to_mangle.push(def);
+                }
             });
             descend();
             if (options.cache && node instanceof AST_Toplevel) {
@@ -640,7 +672,24 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
                 sym.scope = node;
                 sym.reference(options);
             }
-            node.to_mangle.forEach(mangle);
+            if (to_mangle.length > cutoff) {
+                var indices = to_mangle.map(function(def, index) {
+                    return index;
+                }).sort(function(i, j) {
+                    return to_mangle[j].references.length - to_mangle[i].references.length || i - j;
+                });
+                to_mangle = indices.slice(0, cutoff).sort(function(i, j) {
+                    return i - j;
+                }).map(function(index) {
+                    return to_mangle[index];
+                }).concat(indices.slice(cutoff).sort(function(i, j) {
+                    return i - j;
+                }).map(function(index) {
+                    return to_mangle[index];
+                }));
+            }
+            to_mangle.forEach(mangle);
+            if (node instanceof AST_LabeledStatement && !(options.v8 && in_label(tw))) lname = save_nesting;
             return true;
         }
         if (node instanceof AST_Label) {
@@ -673,7 +722,12 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
         }
         redefined.push(def);
         def.references.forEach(reference);
-        if (sym instanceof AST_SymbolCatch || sym instanceof AST_SymbolConst) reference(sym);
+        if (sym instanceof AST_SymbolCatch || sym instanceof AST_SymbolConst) {
+            reference(sym);
+            def.redefined = function() {
+                return redef;
+            };
+        }
         return true;
 
         function reference(sym) {

lib/sourcemap.js

@@ -77,21 +77,23 @@ function vlq_encode(num) {
 }
 
 function create_array_map() {
-    var map = Object.create(null);
+    var map = new Dictionary();
     var array = [];
     array.index = function(name) {
-        if (!HOP(map, name)) {
-            map[name] = array.length;
+        var index = map.get(name);
+        if (!(index >= 0)) {
+            index = array.length;
             array.push(name);
+            map.set(name, index);
         }
-        return map[name];
+        return index;
     };
     return array;
 }
 
 function SourceMap(options) {
     var sources = create_array_map();
-    var sources_content = options.includeSources && Object.create(null);
+    var sources_content = options.includeSources && new Dictionary();
     var names = create_array_map();
     var mappings = "";
     if (options.orig) Object.keys(options.orig).forEach(function(name) {
@@ -110,7 +112,7 @@ function SourceMap(options) {
         if (!sources_content || !map.sourcesContent) return;
         for (var i = 0; i < map.sources.length; i++) {
             var content = map.sourcesContent[i];
-            if (content) sources_content[map.sources[i]] = content;
+            if (content) sources_content.set(map.sources[i], content);
         }
     });
     var prev_source;
@@ -144,8 +146,8 @@ function SourceMap(options) {
             add(source, gen_line, gen_col, orig_line, orig_col, name);
         } : add,
         setSourceContent: sources_content ? function(source, content) {
-            if (!(source in sources_content)) {
-                sources_content[source] = content;
+            if (!sources_content.has(source)) {
+                sources_content.set(source, content);
             }
         } : noop,
         toString: function() {
@@ -155,7 +157,7 @@ function SourceMap(options) {
                 sourceRoot: options.root || undefined,
                 sources: sources,
                 sourcesContent: sources_content ? sources.map(function(source) {
-                    return sources_content[source] || null;
+                    return sources_content.get(source) || null;
                 }) : undefined,
                 names: names,
                 mappings: mappings,

lib/utils.js

@@ -55,36 +55,41 @@ function find_if(func, array) {
     for (var i = array.length; --i >= 0;) if (func(array[i])) return array[i];
 }
 
-function repeat_string(str, i) {
-    if (i <= 0) return "";
-    if (i == 1) return str;
-    var d = repeat_string(str, i >> 1);
-    d += d;
-    return i & 1 ? d + str : d;
-}
-
-function configure_error_stack(fn) {
-    Object.defineProperty(fn.prototype, "stack", {
+function configure_error_stack(ex, cause) {
+    var stack = ex.name + ": " + ex.message;
+    Object.defineProperty(ex, "stack", {
         get: function() {
-            var err = new Error(this.message);
-            err.name = this.name;
-            try {
-                throw err;
-            } catch (e) {
-                return e.stack;
+            if (cause) {
+                cause.name = "" + ex.name;
+                stack = "" + cause.stack;
+                var msg = "" + cause.message;
+                cause = null;
+                var index = stack.indexOf(msg);
+                if (index < 0) {
+                    index = 0;
+                } else {
+                    index += msg.length;
+                    index = stack.indexOf("\n", index) + 1;
                 }
+                stack = stack.slice(0, index) + stack.slice(stack.indexOf("\n", index) + 1);
             }
+            return stack;
+        },
     });
 }
 
 function DefaultsError(msg, defs) {
     this.message = msg;
     this.defs = defs;
+    try {
+        throw new Error(msg);
+    } catch (cause) {
+        configure_error_stack(this, cause);
+    }
 }
 DefaultsError.prototype = Object.create(Error.prototype);
 DefaultsError.prototype.constructor = DefaultsError;
 DefaultsError.prototype.name = "DefaultsError";
-configure_error_stack(DefaultsError);
 
 function defaults(args, defs, croak) {
     if (croak) for (var i in args) {
@@ -96,15 +101,6 @@ function defaults(args, defs, croak) {
     return defs;
 }
 
-function merge(obj, ext) {
-    var count = 0;
-    for (var i in ext) if (HOP(ext, i)) {
-        obj[i] = ext[i];
-        count++;
-    }
-    return count;
-}
-
 function noop() {}
 function return_false() { return false; }
 function return_true() { return true; }
@@ -144,8 +140,10 @@ function push_uniq(array, el) {
 
 function string_template(text, props) {
     return text.replace(/\{([^{}]+)\}/g, function(str, p) {
-        var value = props[p];
-        return value instanceof AST_Node ? value.print_to_string() : value;
+        var value = p == "this" ? props : props[p];
+        if (value instanceof AST_Node) return value.print_to_string();
+        if (value instanceof AST_Token) return value.file + ":" + value.line + "," + value.col;
+        return value;
     });
 }
 
@@ -171,63 +169,80 @@ function all(array, predicate) {
 }
 
 function Dictionary() {
-    this._values = Object.create(null);
-    this._size = 0;
+    this.values = Object.create(null);
 }
 Dictionary.prototype = {
     set: function(key, val) {
-        if (!this.has(key)) ++this._size;
-        this._values["$" + key] = val;
+        if (key == "__proto__") {
+            this.proto_value = val;
+        } else {
+            this.values[key] = val;
+        }
         return this;
     },
     add: function(key, val) {
-        if (this.has(key)) {
-            this.get(key).push(val);
+        var list = this.get(key);
+        if (list) {
+            list.push(val);
         } else {
             this.set(key, [ val ]);
         }
         return this;
     },
-    get: function(key) { return this._values["$" + key] },
+    get: function(key) {
+        return key == "__proto__" ? this.proto_value : this.values[key];
+    },
     del: function(key) {
-        if (this.has(key)) {
-            --this._size;
-            delete this._values["$" + key];
+        if (key == "__proto__") {
+            delete this.proto_value;
+        } else {
+            delete this.values[key];
         }
         return this;
     },
-    has: function(key) { return ("$" + key) in this._values },
+    has: function(key) {
+        return key == "__proto__" ? "proto_value" in this : key in this.values;
+    },
     all: function(predicate) {
-        for (var i in this._values)
-            if (!predicate(this._values[i], i.substr(1)))
-                return false;
+        for (var i in this.values)
+            if (!predicate(this.values[i], i)) return false;
+        if ("proto_value" in this && !predicate(this.proto_value, "__proto__")) return false;
         return true;
     },
     each: function(f) {
-        for (var i in this._values)
-            f(this._values[i], i.substr(1));
+        for (var i in this.values)
+            f(this.values[i], i);
+        if ("proto_value" in this) f(this.proto_value, "__proto__");
     },
     size: function() {
-        return this._size;
+        return Object.keys(this.values).length + ("proto_value" in this);
     },
     map: function(f) {
         var ret = [];
-        for (var i in this._values)
-            ret.push(f(this._values[i], i.substr(1)));
+        for (var i in this.values)
+            ret.push(f(this.values[i], i));
+        if ("proto_value" in this) ret.push(f(this.proto_value, "__proto__"));
         return ret;
     },
     clone: function() {
         var ret = new Dictionary();
-        for (var i in this._values)
-            ret._values[i] = this._values[i];
-        ret._size = this._size;
+        this.each(function(value, i) {
+            ret.set(i, value);
+        });
         return ret;
     },
-    toObject: function() { return this._values }
+    toObject: function() {
+        var obj = {};
+        this.each(function(value, i) {
+            obj["$" + i] = value;
+        });
+        return obj;
+    },
 };
 Dictionary.fromObject = function(obj) {
     var dict = new Dictionary();
-    dict._size = merge(dict._values, obj);
+    for (var i in obj)
+        if (HOP(obj, i)) dict.set(i.slice(1), obj[i]);
     return dict;
 };
 
@@ -265,3 +280,21 @@ function first_in_statement(stack, arrow, export_default) {
         return false;
     }
 }
+
+function DEF_BITPROPS(ctor, props) {
+    if (props.length > 31) throw new Error("Too many properties: " + props.length + "\n" + props.join(", "));
+    props.forEach(function(name, pos) {
+        var mask = 1 << pos;
+        Object.defineProperty(ctor.prototype, name, {
+            get: function() {
+                return !!(this._bits & mask);
+            },
+            set: function(val) {
+                if (val)
+                    this._bits |= mask;
+                else
+                    this._bits &= ~mask;
+            },
+        });
+    });
+}

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.14.4",
+  "version": "3.18.0",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -23,7 +23,7 @@
     "LICENSE"
   ],
   "devDependencies": {
-    "acorn": "~8.2.1",
+    "acorn": "~8.7.1",
     "semver": "~6.3.0"
   },
   "scripts": {

test/benchmark.js

@@ -3,6 +3,7 @@
 
 "use strict";
 
+require("../tools/tty");
 var createHash = require("crypto").createHash;
 var fetch = require("./fetch");
 var spawn = require("child_process").spawn;
@@ -17,6 +18,7 @@ var urls = [
     "https://unpkg.com/mathjs@6.2.3/dist/math.js",
     "https://unpkg.com/react@15.3.2/dist/react.js",
     "https://cdnjs.cloudflare.com/ajax/libs/d3/6.7.0/d3.js",
+    "https://cdnjs.cloudflare.com/ajax/libs/antd/4.18.7/antd.js",
     "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.js",
     "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.js",
     "https://cdnjs.cloudflare.com/ajax/libs/ember.js/2.12.2/ember.prod.js",

test/compress.js

@@ -60,8 +60,9 @@ function log() {
     console.log("%s", tmpl.apply(null, arguments));
 }
 
-function make_code(ast, options) {
+function make_code(ast, options, expression) {
     var stream = U.OutputStream(options);
+    if (expression) ast = ast.clone(true).unwrap_expression();
     ast.print(stream);
     return stream.get();
 }
@@ -69,9 +70,7 @@ function make_code(ast, options) {
 function parse_test(file) {
     var script = fs.readFileSync(file, "utf8");
     try {
-        var ast = U.parse(script, {
-            filename: file
-        });
+        var ast = U.parse(script, { filename: file, module: "" });
     } catch (e) {
         console.error("Caught error while parsing tests in " + file);
         console.error(e);
@@ -98,7 +97,7 @@ function parse_test(file) {
             file: file,
             line: node.start.line,
             col: node.start.col,
-            code: make_code(node, { beautify: false })
+            code: make_code(node, { beautify: false }),
         }));
     }
 
@@ -127,6 +126,17 @@ function parse_test(file) {
                     croak(node);
                 }
                 var name = node.left.name;
+                assert.ok([
+                    "beautify",
+                    "expression",
+                    "mangle",
+                    "options",
+                    "rename",
+                ].indexOf(name) >= 0, tmpl("Unsupported setting {name} [{line},{col}]", {
+                    name: name,
+                    line: node.start.line,
+                    col: node.start.col,
+                }));
                 test[name] = evaluate(node.right);
                 return true;
             }
@@ -142,7 +152,7 @@ function parse_test(file) {
                 ].indexOf(label.name) >= 0, tmpl("Unsupported label {name} [{line},{col}]", {
                     name: label.name,
                     line: label.start.line,
-                    col: label.start.col
+                    col: label.start.col,
                 }));
                 var stat = node.body;
                 if (label.name == "expect_exact" || label.name == "node_version") {
@@ -155,12 +165,12 @@ function parse_test(file) {
                         var ctor = global[body.expression.name];
                         assert.ok(ctor === Error || ctor.prototype instanceof Error, tmpl("Unsupported expect_stdout format [{line},{col}]", {
                             line: label.start.line,
-                            col: label.start.col
+                            col: label.start.col,
                         }));
                         test[label.name] = ctor.apply(null, body.args.map(function(node) {
                             assert.ok(node instanceof U.AST_Constant, tmpl("Unsupported expect_stdout format [{line},{col}]", {
                                 line: label.start.line,
-                                col: label.start.col
+                                col: label.start.col,
                             }));
                             return node.value;
                         }));
@@ -180,16 +190,23 @@ function parse_test(file) {
 
 // Try to reminify original input with standard options
 // to see if it matches expect_stdout.
-function reminify(orig_options, input_code, input_formatted, stdout) {
+function reminify(expression, orig_options, input_code, input_formatted, stdout) {
     for (var i = 0; i < minify_options.length; i++) {
         var options = JSON.parse(minify_options[i]);
-        if (options.compress) [
+        if (expression) {
+            if (!options.parse || typeof options.parse != "object") options.parse = {};
+            options.parse.expression = true;
+            if (options.compress == null) options.compress = {};
+            if (options.compress) {
+                if (typeof options.compress != "object") options.compress = {};
+                options.compress.expression = true;
+            }
+        }
+        [
             "keep_fargs",
             "keep_fnames",
         ].forEach(function(name) {
-            if (name in orig_options) {
-                options.compress[name] = orig_options[name];
-            }
+            if (name in orig_options) options[name] = orig_options[name];
         });
         var options_formatted = JSON.stringify(options, null, 4);
         options.validate = true;
@@ -214,7 +231,7 @@ function reminify(orig_options, input_code, input_formatted, stdout) {
         } else {
             var toplevel = sandbox.has_toplevel(options);
             var expected = stdout[toplevel ? 1 : 0];
-            var actual = sandbox.run_code(result.code, toplevel);
+            var actual = run_code(expression, result.code, toplevel);
             if (typeof expected != "string" && typeof actual != "string" && expected.name == actual.name) {
                 actual = expected;
             }
@@ -249,18 +266,25 @@ function reminify(orig_options, input_code, input_formatted, stdout) {
     return true;
 }
 
+function run_code(expression, code, toplevel) {
+    return sandbox.run_code(expression ? "console.log(" + code + ");" : code, toplevel);
+}
+
 function test_case(test) {
     log("    Running test [{name}]", { name: test.name });
     U.AST_Node.enable_validation();
     var output_options = test.beautify || {};
     var expect;
     if (test.expect) {
-        expect = make_code(to_toplevel(test.expect, test.mangle), output_options);
+        expect = to_toplevel(test.expect, test.mangle, test.expression);
+        expect = make_code(expect, output_options, test.expression);
     } else {
         expect = test.expect_exact;
     }
-    var input = to_toplevel(test.input, test.mangle);
-    var input_code = make_code(input);
+    var input = to_toplevel(test.input, test.mangle, test.expression);
+    var input_code = make_code(input, {
+        keep_quoted_props: true,
+    }, test.expression);
     var input_formatted = make_code(test.input, {
         annotations: true,
         beautify: true,
@@ -270,7 +294,7 @@ function test_case(test) {
     });
     try {
         input.validate_ast();
-        U.parse(input_code);
+        U.parse(input_code, { expression: test.expression });
     } catch (ex) {
         log([
             "!!! Cannot parse input",
@@ -296,8 +320,9 @@ function test_case(test) {
             warnings_emitted.push(text);
         }, /"INFO: /.test(expected_warnings));
     }
+    var quoted_props;
     if (test.mangle && test.mangle.properties && test.mangle.properties.keep_quoted) {
-        var quoted_props = test.mangle.properties.reserved;
+        quoted_props = test.mangle.properties.reserved;
         if (!Array.isArray(quoted_props)) quoted_props = [];
         test.mangle.properties.reserved = quoted_props;
         U.reserve_quoted_keys(input, quoted_props);
@@ -312,9 +337,10 @@ function test_case(test) {
     if (test.mangle) {
         output.compute_char_frequency(test.mangle);
         output.mangle_names(test.mangle);
+        if (quoted_props) U.reserve_quoted_keys(input, quoted_props);
         if (test.mangle.properties) U.mangle_properties(output, test.mangle.properties);
     }
-    var output_code = make_code(output, output_options);
+    var output_code = make_code(output, output_options, test.expression);
     U.AST_Node.log_function();
     if (expect != output_code) {
         log([
@@ -337,7 +363,7 @@ function test_case(test) {
     // expect == output
     try {
         output.validate_ast();
-        U.parse(output_code);
+        U.parse(output_code, { expression: test.expression });
     } catch (ex) {
         log([
             "!!! Test matched expected result but cannot parse output",
@@ -381,7 +407,7 @@ function test_case(test) {
         }
     }
     if (test.expect_stdout && (!test.node_version || semver.satisfies(process.version, test.node_version))) {
-        var stdout = [ sandbox.run_code(input_code), sandbox.run_code(input_code, true) ];
+        var stdout = [ run_code(test.expression, input_code), run_code(test.expression, input_code, true) ];
         var toplevel = sandbox.has_toplevel({
             compress: test.options,
             mangle: test.mangle
@@ -410,7 +436,7 @@ function test_case(test) {
             });
             return false;
         }
-        actual = sandbox.run_code(output_code, toplevel);
+        actual = run_code(test.expression, output_code, toplevel);
         if (!sandbox.same_stdout(test.expect_stdout, actual)) {
             log([
                 "!!! failed",
@@ -431,7 +457,7 @@ function test_case(test) {
             });
             return false;
         }
-        if (!reminify(test.options, input_code, input_formatted, stdout)) {
+        if (!reminify(test.expression, test.options, input_code, input_formatted, stdout)) {
             return false;
         }
     }
@@ -442,20 +468,30 @@ function tmpl() {
     return U.string_template.apply(null, arguments);
 }
 
-function to_toplevel(input, mangle_options) {
+function to_toplevel(input, mangle_options, expression) {
     if (!(input instanceof U.AST_BlockStatement)) throw new Error("Unsupported input syntax");
-    var directive = true;
     var offset = input.start.line;
     var tokens = [];
-    var toplevel = new U.AST_Toplevel(input.transform(new U.TreeTransformer(function(node) {
+    input.walk(new U.TreeWalker(function(node) {
         if (U.push_uniq(tokens, node.start)) node.start.line -= offset;
-        if (!directive || node === input) return;
+        if (U.push_uniq(tokens, node.end)) node.end.line -= offset;
+    }));
+    var toplevel;
+    if (!expression) {
+        var directive = true;
+        toplevel = new U.AST_Toplevel(input.transform(new U.TreeTransformer(function(node) {
+            if (!directive) return node;
+            if (node === input) return;
             if (node instanceof U.AST_SimpleStatement && node.body instanceof U.AST_String) {
                 return new U.AST_Directive(node.body);
-        } else {
-            directive = false;
             }
+            directive = false;
         })));
+    } else if (input.body.length == 1) {
+        toplevel = input.body[0].wrap_expression();
+    } else {
+        throw new Error("Invalid expression");
+    }
     toplevel.figure_out_scope(mangle_options);
     return toplevel;
 }

test/compress/annotations.js

@@ -442,9 +442,9 @@ compress_annotations_disabled_output_annotations_enabled: {
     }
     expect_exact: [
         "/*@__PURE__*/a(3),",
-        "/*#__PURE__*/b(5),",
+        "/*@__PURE__*/b(5),",
         "c(side_effect),",
-        "/*#__PURE__*/d(effect());",
+        "/*@__PURE__*/d(effect());",
     ]
 }
 

test/compress/arrows.js

@@ -363,6 +363,28 @@ negate: {
 }
 
 inline_this: {
+    options = {
+        inline: true,
+    }
+    input: {
+        var p = "PASS";
+        console.log({
+            p: "FAIL",
+            q: (() => this.p)(),
+        }.q);
+    }
+    expect: {
+        var p = "PASS";
+        console.log({
+            p: "FAIL",
+            q: this.p,
+        }.q);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+dont_inline_this: {
     options = {
         inline: true,
     }
@@ -486,7 +508,7 @@ drop_value: {
         ((a, b) => a + b)(console.log(42));
     }
     expect: {
-        ((a, b) => {})(console.log(42));
+        void console.log(42);
     }
     expect_stdout: "42"
     node_version: ">=4"
@@ -646,6 +668,87 @@ single_use_recursive: {
     node_version: ">=4"
 }
 
+inline_iife_within_arrow: {
+    options = {
+        arrows: true,
+        inline: true,
+    }
+    input: {
+        var f = () => console.log(function(a) {
+            return Math.ceil(a);
+        }(Math.random()));
+        f();
+    }
+    expect: {
+        var f = () => {
+            return console.log((a = Math.random(), Math.ceil(a)));
+            var a;
+        };
+        f();
+    }
+    expect_stdout: "1"
+    node_version: ">=4"
+}
+
+instanceof_lambda_1: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(42 instanceof (() => {}));
+    }
+    expect: {
+        console.log(false);
+    }
+    expect_stdout: "false"
+    node_version: ">=4"
+}
+
+instanceof_lambda_2: {
+    options = {
+        evaluate: true,
+        side_effects: false,
+    }
+    input: {
+        console.log(null instanceof (() => {}));
+    }
+    expect: {
+        console.log((null, () => {}, false));
+    }
+    expect_stdout: "false"
+    node_version: ">=4"
+}
+
+instanceof_lambda_3: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log({} instanceof (() => {}));
+    }
+    expect: {
+        console.log({} instanceof (() => {}));
+    }
+    expect_stdout: TypeError("Function has non-object prototype 'undefined' in instanceof check")
+    node_version: ">=4"
+}
+
+instanceof_lambda_4: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({ p: "foo" }) instanceof (() => {});
+    }
+    expect: {
+        [] instanceof (() => {});
+    }
+    expect_stdout: TypeError("Function has non-object prototype 'undefined' in instanceof check")
+    node_version: ">=4"
+}
+
 issue_4388: {
     options = {
         inline: true,
@@ -884,3 +987,334 @@ issue_4772: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_5251: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        (() => {
+            while (console.log(arguments))
+                var arguments = "FAIL";
+        })();
+    }
+    expect: {
+        (() => {
+            while (console.log(arguments))
+                var arguments = "FAIL";
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_5342_1: {
+    options = {
+        dead_code: true,
+        inline: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var a in 0) {
+            (() => {
+                while (1);
+            })(new function(NaN) {
+                a.p;
+            }());
+        }
+        console.log(function() {
+            return b;
+            try {
+                b;
+            } catch (e) {
+                var b;
+            }
+        }());
+    }
+    expect: {
+        for (var a in 0) {
+            (function(NaN) {
+                a.p;
+            })();
+            while (1);
+        }
+        console.log(b);
+        var b;
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5342_2: {
+    rename = true
+    options = {
+        dead_code: true,
+        inline: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var a in 0) {
+            (() => {
+                while (1);
+            })(new function(NaN) {
+                a.p;
+            }());
+        }
+        console.log(function() {
+            return b;
+            try {
+                b;
+            } catch (e) {
+                var b;
+            }
+        }());
+    }
+    expect: {
+        for (var a in 0) {
+            a.p;
+            while (1);
+        }
+        console.log(c);
+        var c;
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5356: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log((a => a++)(console));
+    }
+    expect: {
+        console.log((a => +a)(console));
+    }
+    expect_stdout: "NaN"
+    node_version: ">=4"
+}
+
+issue_5414_1: {
+    options = {
+        arrows: true,
+        if_return: true,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        (() => {
+            (() => {
+                if (!console)
+                    var arguments = 42;
+                while (console.log(arguments));
+            })();
+        })();
+    }
+    expect: {
+        (() => {
+            if (!console)
+                var arguments = 42;
+            while (console.log(arguments));
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_5414_2: {
+    options = {
+        arrows: true,
+        inline: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        (() => {
+            (() => {
+                if (!console)
+                    var arguments = 42;
+                while (console.log(arguments));
+            })();
+        })();
+    }
+    expect: {
+        (() => {
+            if (!console)
+                var arguments = 42;
+            while (console.log(arguments));
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_5416_1: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        loops: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            while ((() => {
+                console;
+                var a = function g(arguments) {
+                    console.log(arguments);
+                }();
+            })());
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            {
+                console;
+                arguments = void 0,
+                console.log(arguments);
+                var arguments;
+                return;
+            }
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5416_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        loops: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            while ((() => {
+                console;
+                var a = function g(arguments) {
+                    while (console.log(arguments));
+                }();
+            })());
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            {
+                console;
+                var arguments = void 0;
+                for (; console.log(arguments););
+                return;
+            }
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5416_3: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            (() => {
+                var a = function g(arguments) {
+                    console.log(arguments);
+                }();
+            })();
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            arguments = void 0,
+            console.log(arguments);
+            var arguments;
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5416_4: {
+    options = {
+        arrows: true,
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            (() => {
+                var a = function g(arguments) {
+                    while (console.log(arguments));
+                }();
+            })();
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            var arguments = void 0;
+            while (console.log(arguments));
+            return;
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5495: {
+    input: {
+        console.log((() => {
+            "use strict";
+            return function() {
+                return this;
+            }();
+        })());
+    }
+    expect_exact: 'console.log((()=>{"use strict";return function(){return this}()})());'
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5653: {
+    options = {
+        arrows: true,
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log((a => {
+            a = { p: console };
+            return a++;
+        })());
+    }
+    expect: {
+        console.log((a => {
+            return +{};
+        })());
+    }
+    expect_stdout: "NaN"
+    node_version: ">=4"
+}

test/compress/assignments.js

@@ -290,6 +290,45 @@ increment_decrement_2: {
     expect_stdout: "42"
 }
 
+lazily_chained_assignments: {
+    options = {
+        assignments: true,
+        collapse_vars: true,
+        conditionals: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            if (a = console.log("foo"))
+                a = console.log("bar");
+            return a;
+        }
+        function g(b) {
+            if (b = console.log("baz"))
+                ;
+            else
+                b = console.log("moo");
+            return b;
+        }
+        console.log(f(), g());
+    }
+    expect: {
+        function f(a) {
+            return console.log("foo") && console.log("bar");
+        }
+        function g(b) {
+            return console.log("baz") || console.log("moo");
+        }
+        console.log(f(), g());
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "moo",
+        "undefined undefined",
+    ]
+}
+
 issue_3375_1: {
     options = {
         assignments: true,
@@ -489,7 +528,7 @@ logical_assignments: {
     node_version: ">=15"
 }
 
-logical_collapse_vars: {
+logical_collapse_vars_1: {
     options = {
         collapse_vars: true,
     }
@@ -509,6 +548,46 @@ logical_collapse_vars: {
     node_version: ">=15"
 }
 
+logical_collapse_vars_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "PASS";
+        (function(b) {
+            b ||= (a = "FAIL", {});
+            return b;
+        })(console).log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (function(b) {
+            return b ||= (a = "FAIL", {});
+        })(console).log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+logical_collapse_vars_3: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 6;
+        a *= 7;
+        a ??= "FAIL";
+        console.log(a);
+    }
+    expect: {
+        var a = 6;
+        a = a * 7 ?? "FAIL";
+        console.log(a);
+    }
+    expect_stdout: "42"
+    node_version: ">=15"
+}
+
 logical_reduce_vars: {
     options = {
         evaluate: true,
@@ -633,8 +712,7 @@ issue_4827_1: {
         c &&= b = a, console.log(b);
     }
     expect: {
-        A = "FAIL";
-        var a = A, b = "PASS", c;
+        var a = A = "FAIL", b = "PASS", c;
         c &&= b = a, console.log(b);
     }
     expect_stdout: "PASS"
@@ -764,3 +842,23 @@ issue_4924_2: {
     expect_stdout: "PASS"
     node_version: ">=15"
 }
+
+issue_5670: {
+    options = {
+        assignments: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function(a, b) {
+            a && a && (a = b += "") || console.log("PASS");
+        })();
+    }
+    expect: {
+        (function(a, b) {
+            a = a,
+            console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+}

test/compress/bigint.js

@@ -4,7 +4,7 @@ arithmetic: {
     }
     expect_exact: "console.log((1n+0x2n)*(0o3n- -4n)>>5n-6n);"
     expect_stdout: "42n"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 minus_dot: {
@@ -13,7 +13,7 @@ minus_dot: {
     }
     expect_exact: "console.log(typeof-42n.toString(),typeof(-42n).toString());"
     expect_stdout: "number string"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 evaluate: {
@@ -28,7 +28,7 @@ evaluate: {
         console.log(0xdeadbeefn.toString(16));
     }
     expect_stdout: "deadbeef"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 Number: {
@@ -42,7 +42,7 @@ Number: {
         console.log(+("" + -0xfeed_dead_beef_badn));
     }
     expect_stdout: "-1148098955808013200"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 issue_4590: {
@@ -58,7 +58,7 @@ issue_4590: {
         0n || console.log("PASS");
     }
     expect_stdout: "PASS"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 issue_4801: {
@@ -88,5 +88,19 @@ issue_4801: {
         }
     }
     expect_stdout: "PASS"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
+}
+
+issue_5728: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log("" + 4n + 2);
+    }
+    expect: {
+        console.log("42");
+    }
+    expect_stdout: "42"
+    node_version: ">=10.4.0"
 }

test/compress/blocks.js

@@ -47,3 +47,45 @@ keep_some_blocks: {
         } else stuff();
     }
 }
+
+issue_1666: {
+    input: {
+        var a = 42;
+        {
+            function a() {}
+            a();
+        }
+        console.log("PASS");
+    }
+    expect: {
+        var a = 42;
+        {
+            function a() {}
+            a();
+        }
+        console.log("PASS");
+    }
+    expect_stdout: true
+}
+
+issue_1666_strict: {
+    input: {
+        "use strict";
+        var a = 42;
+        {
+            function a() {}
+            a();
+        }
+        console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        var a = 42;
+        {
+            function a() {}
+            a();
+        }
+        console.log("PASS");
+    }
+    expect_stdout: true
+}

test/compress/booleans.js

@@ -80,6 +80,25 @@ de_morgan_1c: {
     expect_stdout: "true"
 }
 
+de_morgan_1d: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        function f(a) {
+            return (a = false) || a;
+        }
+        console.log(f(null), f(42));
+    }
+    expect: {
+        function f(a) {
+            return a = !1;
+        }
+        console.log(f(null), f(42));
+    }
+    expect_stdout: "false false"
+}
+
 de_morgan_2a: {
     options = {
         booleans: true,
@@ -181,6 +200,31 @@ de_morgan_2d: {
     ]
 }
 
+de_morgan_2e: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        function f(a, b) {
+            return (a && b) && b;
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect: {
+        function f(a, b) {
+            return a && b;
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect_stdout: [
+        "null null",
+        "undefined {}",
+    ]
+}
+
 de_morgan_3a: {
     options = {
         booleans: true,
@@ -427,6 +471,44 @@ negated_if: {
     expect_stdout: "PASS"
 }
 
+concat_truthy: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        console.log("foo") + (console.log("bar"), "baz") || console.log("moo");
+    }
+    expect: {
+        console.log("foo") + (console.log("bar"), "baz");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    expect_warnings: [
+        "WARN: + in boolean context always true [test/compress/booleans.js:1,8]",
+        "WARN: Condition left of || always true [test/compress/booleans.js:1,8]",
+    ]
+}
+
+process_returns: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        (function() {
+            return 42;
+        })() && console.log("PASS");
+    }
+    expect: {
+        (function() {
+            return 42;
+        })() && console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
 issue_3465_1: {
     options = {
         booleans: true,
@@ -697,3 +779,88 @@ issue_5041_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5228: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+    }
+    input: {
+        console.log(function() {
+            return !function() {
+                do {
+                    return null;
+                } while (console);
+            }();
+        }());
+    }
+    expect: {
+        console.log(function() {
+            do {
+                return !0;
+            } while (console);
+            return !0;
+        }());
+    }
+    expect_stdout: "true"
+}
+
+issue_5469: {
+    options = {
+        assignments: true,
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        console.log(function f(a) {
+            a && 42[a = A && null];
+        }());
+    }
+    expect: {
+        console.log(function f(a) {
+            a && A,
+            0;
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_5694_1: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        var Infinity;
+        // Node.js v0.12~6 (vm): 42
+        console.log((Infinity = 42) && Infinity);
+    }
+    expect: {
+        var Infinity;
+        console.log((Infinity = 42) && Infinity);
+    }
+    expect_stdout: true
+}
+
+issue_5694_2: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        var undefined;
+        // Node.js v0.12~6 (vm): NaN
+        console.log(("foo", ++undefined) || undefined);
+    }
+    expect: {
+        var undefined;
+        console.log(("foo", ++undefined) || undefined);
+    }
+    expect_stdout: true
+}

test/compress/comparisons.js

@@ -40,6 +40,22 @@ unsafe_comps: {
     }
 }
 
+unsafe_in_instanceof: {
+    options = {
+        side_effects: true,
+        unsafe_comps: true,
+    }
+    input: {
+        var a;
+        42 in a;
+        f() instanceof "foo";
+    }
+    expect: {
+        var a;
+        f();
+    }
+}
+
 dont_change_in_or_instanceof_expressions: {
     input: {
         1 in 1;
@@ -259,6 +275,7 @@ issue_2857_3: {
 issue_2857_4: {
     options = {
         comparisons: true,
+        conditionals: true,
     }
     input: {
         function f(a, p) {
@@ -289,6 +306,7 @@ issue_2857_4: {
 issue_2857_5: {
     options = {
         comparisons: true,
+        conditionals: true,
     }
     input: {
         function f(a, p) {
@@ -489,7 +507,37 @@ issue_3413: {
     }
     expect: {
         var b;
-        void 0 !== ("" < b || void 0) || console.log("PASS");
+        void 0 === ("" < b || void 0) && console.log("PASS");
     }
     expect_stdout: "PASS"
 }
+
+nullish_assign: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        var a;
+        void 0 !== (a = "PASS".split("")) && null !== a && console.log(a.join("-"));
+    }
+    expect: {
+        var a;
+        null != (a = "PASS".split("")) && console.log(a.join("-"));
+    }
+    expect_stdout: "P-A-S-S"
+}
+
+nullish_chain: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+    }
+    input: {
+        var a;
+        A || B || void 0 === a || null === a || C;
+    }
+    expect: {
+        var a;
+        A || B || null == a || C;
+    }
+}

test/compress/concat-strings.js

@@ -12,7 +12,7 @@ concat_1: {
 
         var e = 1 + x() + 2 + "X" + 3 + "boo";
 
-        // be careful with concatentation with "\0" with octal-looking strings.
+        // be careful with concatenation with "\0" with octal-looking strings.
         var f = "\0" + 360 + "\0" + 8 + "\0";
     }
     expect: {
@@ -273,6 +273,23 @@ concat_9: {
     expect_stdout: true
 }
 
+concat_sequence: {
+    options = {
+        collapse_vars: true,
+        strings: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        console.log(12 + (a = null, "34" + a));
+    }
+    expect: {
+        console.log(12 + "34" + null);
+    }
+    expect_stdout: "1234null"
+}
+
 issue_3689: {
     options = {
         strings: true,

test/compress/const.js

@@ -142,6 +142,80 @@ if_dead_branch: {
     expect_stdout: "undefined"
 }
 
+retain_tail_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                const b = "bar";
+                while (console.log("baz"));
+                console.log(b);
+            } else {
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                const b = "bar";
+                while (console.log("baz"));
+                console.log(b);
+            } else {
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: true
+}
+
+retain_tail_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                const b = "baz";
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                const b = "baz";
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: true
+}
+
 merge_vars_1: {
     options = {
         merge_vars: true,
@@ -220,6 +294,32 @@ merge_vars_3: {
     expect_stdout: true
 }
 
+merge_vars_4: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        console.log(typeof a);
+        {
+            var b = console;
+            console.log(typeof b);
+            const a = 0;
+        }
+    }
+    expect: {
+        var a = 1;
+        console.log(typeof a);
+        {
+            var b = console;
+            console.log(typeof b);
+            const a = 0;
+        }
+    }
+    expect_stdout: true
+}
+
 use_before_init_1: {
     options = {
         reduce_vars: true,
@@ -553,6 +653,37 @@ dead_block_after_return: {
     expect_stdout: true
 }
 
+if_return_3: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        var a = "PASS";
+        function f(b) {
+            if (console) {
+                const b = a;
+                return b;
+            } else
+                while (console.log("FAIL 1"));
+            return b;
+        }
+        console.log(f("FAIL 2"));
+    }
+    expect: {
+        var a = "PASS";
+        function f(b) {
+            if (console) {
+                const b = a;
+                return b;
+            } else
+                while (console.log("FAIL 1"));
+            return b;
+        }
+        console.log(f("FAIL 2"));
+    }
+    expect_stdout: true
+}
+
 do_if_continue_1: {
     options = {
         if_return: true,
@@ -571,8 +702,7 @@ do_if_continue_1: {
     }
     expect: {
         do {
-            if (!console);
-            else {
+            if (console) {
                 console.log("PASS");
                 {
                     const a = 0;
@@ -602,8 +732,7 @@ do_if_continue_2: {
     }
     expect: {
         do {
-            if (!console);
-            else {
+            if (console) {
                 console.log("PASS");
                 {
                     const a = 0;
@@ -838,12 +967,10 @@ issue_4202: {
     expect: {
         {
             const o = {};
-            (function() {
             function f() {
                 o.p = 42;
             }
             f(f);
-            })();
             console.log(o.p++);
         }
     }
@@ -1219,9 +1346,9 @@ issue_4248: {
     expect_stdout: "PASS"
 }
 
-issue_4261: {
+issue_4261_1: {
     options = {
-        inline: true,
+        inline: 3,
         reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
@@ -1259,6 +1386,43 @@ issue_4261: {
     expect_stdout: "42"
 }
 
+issue_4261_2: {
+    options = {
+        if_return: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        {
+            const a = 42;
+            (function() {
+                function f() {
+                    console.log(a);
+                }
+                function g() {
+                    while (f());
+                }
+                (function() {
+                    while (g());
+                })();
+            })();
+        }
+    }
+    expect: {
+        {
+            const a = 42;
+            function g() {
+                while (void console.log(a));
+            }
+            while (g());
+        }
+    }
+    expect_stdout: "42"
+}
+
 issue_4274_1: {
     options = {
         loops: true,
@@ -1457,6 +1621,7 @@ issue_4689: {
 
 issue_4691: {
     options = {
+        conditionals: true,
         if_return: true,
         toplevel: true,
     }
@@ -1692,3 +1857,377 @@ issue_4965_2: {
     expect_stdout: "undefined"
     node_version: ">=4"
 }
+
+issue_5254: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        do {
+            (function() {
+                const a = console.log;
+                a && a("foo");
+            })();
+        } while (console.log("bar"));
+    }
+    expect: {
+        do {
+            const a = console.log;
+            a && a("foo");
+        } while (console.log("bar"));
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+issue_5260: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = "foo", o;
+        while (console.log("bar"));
+        o = {
+            baz: function(b) {
+                console.log(a, b);
+            },
+        };
+        for (const a in o)
+            o[a](a);
+    }
+    expect: {
+        "use strict";
+        var a = "foo", o;
+        while (console.log("bar"));
+        o = {
+            baz: function(b) {
+                console.log(a, b);
+            },
+        };
+        for (const a in o)
+            o[a](a);
+    }
+    expect_stdout: [
+        "bar",
+        "foo baz",
+    ]
+    node_version: ">=4"
+}
+
+issue_5319: {
+    options = {
+        collapse_vars: true,
+        merge_vars: true,
+    }
+    input: {
+        (function(a, c) {
+            var b = a, c = b;
+            {
+                const a = c;
+                console.log(c());
+            }
+        })(function() {
+            return "PASS";
+        });
+    }
+    expect: {
+        (function(a, c) {
+            var b = a, c;
+            {
+                const a = c = b;
+                console.log(c());
+            }
+        })(function() {
+            return "PASS";
+        });
+    }
+    expect_stdout: true
+}
+
+issue_5338: {
+    options = {
+        unused: true,
+    }
+    input: {
+        const a = a;
+    }
+    expect: {
+        const a = a;
+    }
+    expect_stdout: true
+}
+
+issue_5476: {
+    mangle = {
+        keep_fargs: true,
+    }
+    input: {
+        console.log(function(n) {
+            const a = 42;
+        }());
+    }
+    expect: {
+        console.log(function(n) {
+            const o = 42;
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_5516: {
+    options = {
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function() {
+            try {} catch (a) {
+                (function f() {
+                    a;
+                })();
+            }
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            try {} catch (a) {
+                void a;
+            }
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect_stdout: "function"
+}
+
+issue_5580_1: {
+    mangle = {}
+    input: {
+        "use strict";
+        console.log(function(a, b, c) {
+            try {
+                FAIL;
+            } catch (e) {
+                return function() {
+                    var d = e, i, j;
+                    {
+                        const e = j;
+                    }
+                    return a;
+                }();
+            } finally {
+                const e = 42;
+            }
+        }("PASS"));
+    }
+    expect: {
+        "use strict";
+        console.log(function(r, n, t) {
+            try {
+                FAIL;
+            } catch (o) {
+                return function() {
+                    var n = o, t, c;
+                    {
+                        const o = c;
+                    }
+                    return r;
+                }();
+            } finally {
+                const c = 42;
+            }
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5580_2: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        (function() {
+            try {
+                throw "PASS";
+            } catch (e) {
+                return function() {
+                    console.log(e);
+                    {
+                        const e = "FAIL 1";
+                    }
+                }();
+            } finally {
+                const e = "FAIL 2";
+            }
+        })();
+    }
+    expect: {
+        "use strict";
+        (function() {
+            try {
+                throw "PASS";
+            } catch (e) {
+                console.log(e);
+                {
+                    const e = "FAIL 1";
+                }
+                return;
+            } finally {
+                var e = "FAIL 2";
+            }
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5591: {
+    options = {
+        dead_code: true,
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            switch (console.log("foo")) {
+              case console.log("bar"):
+                if (console.log("baz"))
+                    return;
+                else {
+                    const a = 42;
+                    return;
+                }
+                break;
+              case null:
+                FAIL;
+            }
+        }
+        f();
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            switch (console.log("foo")) {
+              case console.log("bar"):
+                if (console.log("baz"))
+                    return;
+                else {
+                    const a = 42;
+                    return;
+                }
+              case null:
+                FAIL;
+            }
+        }
+        f();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+    node_version: ">=4"
+}
+
+issue_5656: {
+    options = {
+        collapse_vars: true,
+        merge_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            var b = a;
+            b++;
+            {
+                const a = b;
+            }
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            var b = a;
+            {
+                const a = ++b;
+            }
+        }());
+    }
+    expect_stdout: true
+}
+
+issue_5660: {
+    options = {
+        merge_vars: true,
+        side_effects: true,
+    }
+    input: {
+        function f() {
+            try {
+                a;
+                var b;
+                return b;
+            } catch (e) {
+                var a = "FAIL";
+                const b = null;
+                return a;
+            }
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            try {
+                var b;
+                return b;
+            } catch (e) {
+                var a = "FAIL";
+                const b = null;
+                return a;
+            }
+        }
+        console.log(f());
+    }
+    expect_stdout: true
+}
+
+issue_5787: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            const a = 42;
+            switch (a) {
+              case 42:
+                const a = "PASS";
+                return a;
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            const a = 42;
+            switch (a) {
+              case 42:
+                const a = "PASS";
+                return a;
+            }
+        }());
+    }
+    expect_stdout: true
+}

test/compress/dead-code.js

@@ -1485,8 +1485,6 @@ self_assignments_5: {
     }
     expect: {
         var i = 0, l = [ "FAIL", "PASS" ];
-        l[0];
-        l[0];
         l[0] = l[1];
         console.log(l[0], 2);
     }
@@ -1669,3 +1667,66 @@ issue_5106_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5506: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        try {
+            (function(a) {
+                var b = 1;
+                (function f() {
+                    try {
+                        b-- && f();
+                    } catch (c) {}
+                    console.log(a);
+                    a = 42 in (a = "bar");
+                })();
+            })("foo");
+        } catch (e) {}
+    }
+    expect: {
+        try {
+            (function(a) {
+                var b = 1;
+                (function f() {
+                    try {
+                        b-- && f();
+                    } catch (c) {}
+                    console.log(a);
+                    a = 42 in (a = "bar");
+                })();
+            })("foo");
+        } catch (e) {}
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+issue_5641: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        dead_code: true,
+    }
+    input: {
+        function f(a) {
+            if (a || b) {
+                var b = "PASS", c = b && console.log(b);
+            } else
+                var d = a || b;
+        }
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b, c, d;
+            (a || b) && (b = "PASS") && console.log(b);
+        }
+        f(42);
+    }
+    expect_stdout: "PASS"
+}

test/compress/directives.js

@@ -129,3 +129,47 @@ valid_after_invalid_2: {
     }
     expect_stdout: "undefined"
 }
+
+issue_5368_1: {
+    expression = true
+    options = {
+        directives: true,
+        expression: true,
+    }
+    input: {
+        "foo"
+    }
+    expect_exact: '"foo"'
+    expect_stdout: "foo"
+}
+
+issue_5368_2: {
+    expression = true
+    options = {
+        directives: true,
+        expression: true,
+    }
+    input: {
+        (function() {
+            "foo";
+        })()
+    }
+    expect_exact: "function(){}()"
+    expect_stdout: "undefined"
+}
+
+issue_5368_3: {
+    options = {
+        directives: true,
+        expression: true,
+    }
+    input: {
+        "foo";
+        (function() {
+            "bar";
+        })();
+    }
+    expect: {
+        (function() {})();
+    }
+}

test/compress/drop-unused.js

@@ -409,6 +409,15 @@ drop_toplevel_retain: {
         a = 2;
         console.log(3);
     }
+    expect_stdout: "3"
+    expect_warnings: [
+        "INFO: Retaining variable a",
+        "INFO: Retaining variable f",
+        "INFO: Dropping unused variable b [test/compress/drop-unused.js:1,15]",
+        "INFO: Dropping unused variable c [test/compress/drop-unused.js:1,22]",
+        "INFO: Dropping unused function g [test/compress/drop-unused.js:8,17]",
+        "WARN: Dropping unused function h [test/compress/drop-unused.js:9,17]",
+    ]
 }
 
 drop_toplevel_retain_array: {
@@ -442,6 +451,15 @@ drop_toplevel_retain_array: {
         a = 2;
         console.log(3);
     }
+    expect_stdout: "3"
+    expect_warnings: [
+        "INFO: Retaining variable a",
+        "INFO: Retaining variable f",
+        "INFO: Dropping unused variable b [test/compress/drop-unused.js:1,15]",
+        "INFO: Dropping unused variable c [test/compress/drop-unused.js:1,22]",
+        "INFO: Dropping unused function g [test/compress/drop-unused.js:8,17]",
+        "WARN: Dropping unused function h [test/compress/drop-unused.js:9,17]",
+    ]
 }
 
 drop_toplevel_retain_regex: {
@@ -471,6 +489,15 @@ drop_toplevel_retain_regex: {
         a = 2;
         console.log(3);
     }
+    expect_stdout: "3"
+    expect_warnings: [
+        "INFO: Retaining variable a",
+        "INFO: Retaining variable f",
+        "INFO: Dropping unused variable b [test/compress/drop-unused.js:1,15]",
+        "INFO: Dropping unused variable c [test/compress/drop-unused.js:1,22]",
+        "INFO: Dropping unused function g [test/compress/drop-unused.js:8,17]",
+        "WARN: Dropping unused function h [test/compress/drop-unused.js:9,17]",
+    ]
 }
 
 drop_toplevel_all_retain: {
@@ -501,6 +528,15 @@ drop_toplevel_all_retain: {
         a = 2;
         console.log(3);
     }
+    expect_stdout: "3"
+    expect_warnings: [
+        "INFO: Retaining variable a",
+        "INFO: Retaining variable f",
+        "INFO: Dropping unused variable b [test/compress/drop-unused.js:1,15]",
+        "INFO: Dropping unused variable c [test/compress/drop-unused.js:1,22]",
+        "INFO: Dropping unused function g [test/compress/drop-unused.js:8,17]",
+        "WARN: Dropping unused function h [test/compress/drop-unused.js:9,17]",
+    ]
 }
 
 drop_toplevel_funcs_retain: {
@@ -532,6 +568,12 @@ drop_toplevel_funcs_retain: {
         function g() {}
         console.log(b = 3);
     }
+    expect_stdout: "3"
+    expect_warnings: [
+        "INFO: Retaining variable a",
+        "INFO: Retaining variable f",
+        "WARN: Dropping unused function h [test/compress/drop-unused.js:9,17]",
+    ]
 }
 
 drop_toplevel_vars_retain: {
@@ -564,6 +606,13 @@ drop_toplevel_vars_retain: {
         function h() {}
         console.log(3);
     }
+    expect_stdout: "3"
+    expect_warnings: [
+        "INFO: Retaining variable a",
+        "INFO: Retaining variable f",
+        "INFO: Dropping unused variable b [test/compress/drop-unused.js:1,15]",
+        "INFO: Dropping unused variable c [test/compress/drop-unused.js:1,22]",
+    ]
 }
 
 drop_toplevel_keep_assign: {
@@ -671,6 +720,76 @@ iife: {
     }
 }
 
+drop_instanceof: {
+    options = {
+        booleans: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        console.log(!1, (Math, !1));
+    }
+    expect_stdout: "false false"
+}
+
+keep_instanceof_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        var f;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        function f() {}
+        var f;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect_stdout: "false false"
+}
+
+keep_instanceof_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        var f = Object;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        function f() {}
+        var f = Object;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect_stdout: "true true"
+}
+
+keep_instanceof_3: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        f = Object;
+        function f() {}
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        f = Object;
+        function f() {}
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect_stdout: "true true"
+}
+
 issue_1539: {
     options = {
         collapse_vars: true,
@@ -1233,8 +1352,11 @@ issue_2105_2: {
 issue_2105_3: {
     options = {
         inline: true,
-        passes: 2,
+        join_vars: true,
+        passes: 3,
         reduce_vars: true,
+        side_effects: true,
+        sequences: true,
         unused: true,
     }
     input: {
@@ -1258,12 +1380,12 @@ issue_2105_3: {
         });
     }
     expect: {
-        !void void {
+        ({
             prop: function() {
-                console.log;
-                void console.log("PASS");
-            }
-        }.prop();
+                console.log,
+                console.log("PASS");
+            },
+        }).prop();
     }
     expect_stdout: "PASS"
 }
@@ -1728,7 +1850,8 @@ issue_2768: {
     }
     expect: {
         var a = "FAIL";
-        var c = (d = a, void (d && (a = "PASS")));
+        d = a;
+        var c = void (d && (a = "PASS"));
         var d;
         console.log(a, typeof c);
     }
@@ -1755,7 +1878,7 @@ issue_2846: {
         var c = function(a, b) {
             a = 0;
             b && b(a);
-            return a++;
+            return +a;
         }();
         console.log(c);
     }
@@ -1765,7 +1888,7 @@ issue_2846: {
 issue_805_1: {
     options = {
         inline: true,
-        passes: 2,
+        passes: 3,
         pure_getters: "strict",
         reduce_vars: true,
         sequences: true,
@@ -1798,7 +1921,7 @@ issue_805_1: {
 issue_805_2: {
     options = {
         inline: true,
-        passes: 2,
+        passes: 3,
         pure_getters: "strict",
         reduce_vars: true,
         sequences: true,
@@ -2382,7 +2505,8 @@ issue_3664: {
     }
     expect: {
         console.log(function() {
-            var a, b = (a = (a = [ b && console.log("FAIL") ]).p = 0, 0);
+            a = (a = [ b && console.log("FAIL") ]).p = 0;
+            var a, b = 0;
             return "PASS";
         }());
     }
@@ -2551,10 +2675,9 @@ issue_3899: {
         console.log(typeof a);
     }
     expect: {
-        function a() {
+        console.log(typeof function() {
             return 2;
-        }
-        console.log(typeof a);
+        });
     }
     expect_stdout: "function"
 }
@@ -2652,7 +2775,7 @@ issue_3956: {
         collapse_vars: true,
         evaluate: true,
         inline: true,
-        passes: 2,
+        passes: 3,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -2783,7 +2906,7 @@ issue_3986: {
     expect_stdout: "0"
 }
 
-issue_4017: {
+issue_4017_1: {
     options = {
         pure_getters: "strict",
         reduce_vars: true,
@@ -2801,7 +2924,31 @@ issue_4017: {
         var a = 0;
         console.log(function() {
             c &= 0;
-            var c;
+            var c = a++ + (A = a);
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4017_2: {
+    options = {
+        passes: 2,
+        pure_getters: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        console.log(function f() {
+            var b = c &= 0;
+            var c = a++ + (A = a);
+            var d = c && c[f];
+        }());
+    }
+    expect: {
+        var a = 0;
+        console.log(function() {
+            0;
             a++,
             A = a;
         }());
@@ -2829,14 +2976,12 @@ issue_4025: {
         console.log(a, b, d);
     }
     expect: {
-        var c = 0;
         try {
-            console.log(c);
+            console.log(0);
         } finally {
-            var d = c + 1;
-            c = 0;
+            0;
         }
-        console.log(1, 1, d);
+        console.log(1, 1, 1);
     }
     expect_stdout: [
         "0",
@@ -3244,7 +3389,7 @@ issue_4558_1: {
     expect: {
         var a = 0;
         var b = c >>>= a;
-        var c;
+        var c = 0;
         b && a++,
         console.log(a);
     }
@@ -3330,6 +3475,7 @@ issue_4806_1: {
 issue_4806_2: {
     options = {
         sequences: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -3516,3 +3662,155 @@ issue_5079: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5224: {
+    options = {
+        evaluate: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            try {
+                var b = function() {
+                    var a = "FAIL 1";
+                    null && a;
+                    a = console.log(a);
+                }(new function(c, d) {
+                    console.log(d);
+                    a;
+                }("FAIL 2", Infinity));
+            } finally {
+                return f;
+            }
+        }
+        f();
+    }
+    expect: {
+        (function f() {
+            try {
+                (function() {
+                    var a = "FAIL 1";
+                    null;
+                    console.log(a);
+                })(function() {
+                    console.log(1 / 0);
+                    a;
+                }());
+            } finally {
+                return f;
+            }
+        })();
+    }
+    expect_stdout: "Infinity"
+}
+
+issue_5271: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            do {
+                var a = b = 0 ^ f, b = b;
+            } while (console.log(42 - b));
+        }
+        f();
+    }
+    expect: {
+        (function f() {
+            do {
+                var b;
+                b = 0 ^ f;
+            } while (console.log(42 - b));
+        })();
+    }
+    expect_stdout: "42"
+}
+
+issue_5533_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5533_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/evaluate.js

@@ -745,7 +745,7 @@ call_args: {
     expect: {
         var a = 1;
         console.log(1);
-        +(1, 1);
+        1, 1;
     }
     expect_stdout: true
 }
@@ -769,7 +769,7 @@ call_args_drop_param: {
     }
     expect: {
         console.log(1);
-        +(b, 1);
+        b, 1;
     }
     expect_stdout: true
 }
@@ -888,6 +888,39 @@ unsafe_charAt_noop: {
     expect_stdout: "f  n"
 }
 
+chained_side_effects: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log("foo") || (console.log("bar"), "baz") || console.log("moo");
+    }
+    expect: {
+        console.log("foo") || (console.log("bar"), "baz");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    expect_warnings: [
+        "WARN: Condition left of || always true [test/compress/evaluate.js:1,8]",
+    ]
+}
+
+instanceof_lambda: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(42 instanceof function() {});
+    }
+    expect: {
+        console.log(false);
+    }
+    expect_stdout: "false"
+}
+
 issue_1649: {
     options = {
         evaluate: true,
@@ -2752,8 +2785,7 @@ issue_3944: {
     }
     expect: {
         void function f() {
-            while (a = 0 == (a = void 0), console.log(a), void 0);
-            var a;
+            while (0 == void 0, console.log(false), void 0);
             f;
         }();
     }
@@ -3203,7 +3235,7 @@ issue_4552: {
     expect_stdout: "NaN"
 }
 
-issue_4886: {
+issue_4886_1: {
     options = {
         evaluate: true,
         unsafe: true,
@@ -3222,3 +3254,165 @@ issue_4886: {
     }
     expect_stdout: "true"
 }
+
+issue_4886_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log("foo" in {
+            "foo": null,
+            __proto__: 42,
+        });
+    }
+    expect: {
+        console.log("foo" in {
+            "foo": null,
+            __proto__: 42,
+        });
+    }
+    expect_stdout: "true"
+}
+
+issue_5354: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        function f(a) {
+            return +a.toExponential(1);
+        }
+        function g(b) {
+            return 0 + b.toFixed(2);
+        }
+        function h(c) {
+            return 1 * c.toPrecision(3);
+        }
+        console.log(typeof f(45), typeof g(67), typeof h(89));
+    }
+    expect: {
+        function f(a) {
+            return +a.toExponential(1);
+        }
+        function g(b) {
+            return 0 + b.toFixed(2);
+        }
+        function h(c) {
+            return +c.toPrecision(3);
+        }
+        console.log(typeof f(45), typeof g(67), typeof h(89));
+    }
+    expect_stdout: "number string number"
+}
+
+issue_5356: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            return a++;
+            var a = a;
+        }());
+    }
+    expect: {
+        console.log(+a);
+        var a;
+    }
+    expect_stdout: "NaN"
+}
+
+issue_5362_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = -console;
+        console.log(delete +a);
+    }
+    expect: {
+        var a = -console;
+        console.log((+a, true));
+    }
+    expect_stdout: "true"
+}
+
+issue_5362_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = -console;
+        console.log(delete +a);
+    }
+    expect: {
+        console.log(true);
+    }
+    expect_stdout: "true"
+}
+
+issue_5380: {
+    options = {
+        evaluate: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f(b) {
+            return function g() {
+                for (b in { PASS: 42 });
+            }(), b;
+        }("FAIL");
+        console.log(a);
+    }
+    expect: {
+        var a = function f(b) {
+            return function g() {
+                for (b in { PASS: 42 });
+            }(), b;
+        }("FAIL");
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5558: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 99, b = 0;
+        a++;
+        b++;
+        b += a;
+        b *= a;
+        b += a;
+        console.log(a);
+    }
+    expect: {
+        var a = 99, b = 0;
+        b++,
+        b = (b += ++a) * a + a,
+        console.log(a);
+    }
+    expect_stdout: "100"
+}

test/compress/exponentiation.js

@@ -62,7 +62,7 @@ assignment_2: {
     }
     expect_exact: "var a=8n;a**=a;console.log(a);"
     expect_stdout: "16777216n"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 evaluate: {
@@ -99,8 +99,8 @@ issue_4664: {
     expect: {
         (function f() {
             new function(a) {
-                console.log(typeof f, a, typeof this);
-            }((A = 0, 2 ** 30));
+                console.log(typeof f, 2 ** 30, typeof this);
+            }(A = 0);
         })();
     }
     expect_stdout: "function 1073741824 object"

test/compress/exports.js

@@ -109,6 +109,17 @@ foreign: {
     expect_exact: 'export*from"foo";export{}from"bar";export*as a from"baz";export{default}from"moo";export{b,c as case,default as delete,d}from"moz";'
 }
 
+non_identifiers: {
+    beautify = {
+        quote_style: 3,
+    }
+    input: {
+        export * as "42" from 'foo';
+        export { '42', "delete" as 'foo' } from "bar";
+    }
+    expect_exact: "export*as\"42\"from'foo';export{'42',delete as foo}from\"bar\";"
+}
+
 same_quotes: {
     beautify = {
         beautify: true,
@@ -249,7 +260,7 @@ hoist_exports_2: {
         }
     }
     expect: {
-        let e, a = 42["foo"];
+        let e, a = 42..foo;
         function f(t, { [e]: o }) {
             t(o, f);
         }
@@ -417,6 +428,46 @@ hoist_funs: {
     expect_exact: "export function f(){}export default async function*g(){}"
 }
 
+instanceof_default_class: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class A {
+            f(a) {
+                return a instanceof A;
+            }
+        }
+    }
+    expect: {
+        export default class A {
+            f(a) {
+                return a instanceof A;
+            }
+        }
+    }
+}
+
+instanceof_default_function: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f() {
+            if (!(this instanceof f))
+                throw new Error("must instantiate");
+        }
+    }
+    expect: {
+        export default function f() {
+            if (!(this instanceof f))
+                throw new Error("must instantiate");
+        }
+    }
+}
+
 issue_4742_join_vars_1: {
     options = {
         join_vars: true,
@@ -496,3 +547,36 @@ issue_4766: {
         export var a = "bar";
     }
 }
+
+issue_5444: {
+    options = {
+        unused: true,
+    }
+    input: {
+        export var a = (console, console);
+    }
+    expect: {
+        console;
+        export var a = console;
+    }
+}
+
+issue_5628: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var a;
+        export default function f() {
+            for (a in 42);
+        }
+        console.log(a);
+    }
+    expect: {
+        var a;
+        export default function f() {
+            for (a in 42);
+        }
+        console.log(a);
+    }
+}

test/compress/hoist_props.js

@@ -462,6 +462,11 @@ issue_2473_1: {
         var x = {};
         var y = [];
     }
+    expect_warnings: [
+        "INFO: Retaining variable x",
+        "INFO: Retaining variable y",
+        "WARN: Dropping unused variable z [test/compress/hoist_props.js:3,12]",
+    ]
 }
 
 issue_2473_2: {
@@ -484,6 +489,11 @@ issue_2473_2: {
         var x = {};
         var y = [];
     }
+    expect_warnings: [
+        "INFO: Retaining variable x",
+        "INFO: Retaining variable y",
+        "WARN: Dropping unused variable z [test/compress/hoist_props.js:3,12]",
+    ]
 }
 
 issue_2473_3: {
@@ -509,6 +519,9 @@ issue_2473_3: {
         console.log(o.a, o.b);
     }
     expect_stdout: "1 2"
+    expect_warnings: [
+        "INFO: Retaining variable o",
+    ]
 }
 
 issue_2473_4: {
@@ -535,6 +548,9 @@ issue_2473_4: {
         })();
     }
     expect_stdout: "1 2"
+    expect_warnings: [
+        "INFO: Dropping unused variable o [test/compress/hoist_props.js:2,16]",
+    ]
 }
 
 issue_2508_1: {
@@ -1163,16 +1179,64 @@ issue_5182: {
         log(o.p(42));
     }
     expect: {
-        var o_p = console;
-        log = o_p.log;
-        o_p = function(a) {
+        var o = console;
+        log = o.log;
+        o = function(a) {
             console.log(a ? "PASS" : "FAIL");
             return a;
         };
-        log(o_p(42));
+        log(o(42));
     }
     expect_stdout: [
         "PASS",
         "42",
     ]
 }
+
+issue_5441: {
+    options = {
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(a) {
+            (function() {
+                a = { p: this };
+            })();
+            return typeof a;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            (function() {
+                a_p = this;
+            })();
+            var a_p;
+            return typeof {};
+        }());
+    }
+    expect_stdout: "object"
+}
+
+issue_5498: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            __proto__: 42,
+        };
+        while (console.log(typeof o.__proto__));
+    }
+    expect: {
+        var o = {
+            __proto__: 42,
+        };
+        while (console.log(typeof o.__proto__));
+    }
+    expect_stdout: "object"
+}

test/compress/hoist_vars.js

@@ -2,6 +2,8 @@ statements: {
     options = {
         hoist_funs: false,
         hoist_vars: true,
+        join_vars: true,
+        unused: true,
     }
     input: {
         function f() {
@@ -25,6 +27,8 @@ statements_funs: {
     options = {
         hoist_funs: true,
         hoist_vars: true,
+        join_vars: true,
+        unused: true,
     }
     input: {
         function f() {
@@ -48,6 +52,8 @@ sequences: {
     options = {
         hoist_funs: false,
         hoist_vars: true,
+        join_vars: true,
+        unused: true,
     }
     input: {
         function f() {
@@ -71,6 +77,8 @@ sequences_funs: {
     options = {
         hoist_funs: true,
         hoist_vars: true,
+        join_vars: true,
+        unused: true,
     }
     input: {
         function f() {
@@ -108,7 +116,8 @@ catch_var: {
         console.log(a);
     }
     expect: {
-        var a = "PASS";
+        a = "PASS";
+        var a;
         console.log(a);
     }
     expect_stdout: "PASS"
@@ -118,6 +127,8 @@ issue_2295: {
     options = {
         collapse_vars: true,
         hoist_vars: true,
+        join_vars: true,
+        unused: true,
     }
     input: {
         function foo(o) {
@@ -139,6 +150,7 @@ issue_4487_1: {
     options = {
         functions: true,
         hoist_vars: true,
+        join_vars: true,
         keep_fnames: true,
         reduce_vars: true,
         toplevel: true,
@@ -163,6 +175,7 @@ issue_4487_2: {
     options = {
         functions: true,
         hoist_vars: true,
+        join_vars: true,
         keep_fnames: true,
         passes: 2,
         reduce_vars: true,
@@ -188,6 +201,7 @@ issue_4487_3: {
     options = {
         functions: true,
         hoist_vars: true,
+        join_vars: true,
         keep_fnames: true,
         passes: 3,
         reduce_vars: true,
@@ -214,6 +228,7 @@ issue_4489: {
         evaluate: true,
         hoist_vars: true,
         reduce_vars: true,
+        sequences: true,
         toplevel: true,
         unused: true,
     }
@@ -224,8 +239,7 @@ issue_4489: {
         console.log(k);
     }
     expect: {
-        !(A = 0);
-        for (var k in true);
+        for (var k in !(A = 0));
         console.log(k);
     }
     expect_stdout: "undefined"
@@ -249,9 +263,7 @@ issue_4517: {
     }
     expect: {
         console.log(function() {
-            var a = 2;
-            A = a;
-            return A + typeof !1;
+            return (A = 2) + typeof !1;
         }());
     }
     expect_stdout: "2boolean"
@@ -262,6 +274,7 @@ issue_4736: {
         collapse_vars: true,
         evaluate: true,
         hoist_vars: true,
+        join_vars: true,
         merge_vars: true,
         reduce_vars: true,
         toplevel: true,
@@ -281,8 +294,8 @@ issue_4736: {
     expect: {
         (function() {
             (function() {
-                0,
-                console.log(1073741824);
+                0;
+                console.log(1 << 30);
             })();
         })();
     }
@@ -293,6 +306,7 @@ issue_4839: {
     options = {
         evaluate: true,
         hoist_vars: true,
+        join_vars: true,
         keep_fargs: false,
         reduce_vars: true,
         toplevel: true,
@@ -319,6 +333,7 @@ issue_4859: {
     options = {
         evaluate: true,
         hoist_vars: true,
+        join_vars: true,
         keep_infinity: true,
         merge_vars: true,
         reduce_vars: true,
@@ -336,7 +351,7 @@ issue_4859: {
     }
     expect: {
         (function f(a) {
-            console.log(Infinity);
+            console.log(2 + 1 / 0);
             return f;
         })();
     }
@@ -349,6 +364,7 @@ issue_4893_1: {
         evaluate: true,
         hoist_vars: true,
         reduce_vars: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -369,9 +385,8 @@ issue_4893_1: {
     }
     expect: {
         try{
-            (function f() {
+            (function() {
                 null.p += 42;
-                f;
             })();
         } catch (e) {
             console.log("PASS");
@@ -408,9 +423,7 @@ issue_4893_2: {
     expect: {
         try{
             (function() {
-                var b;
-                b = null;
-                b.p += 42;
+                null.p += 42;
             })();
         } catch (e) {
             console.log("PASS");
@@ -443,7 +456,7 @@ issue_4898: {
     expect_stdout: "PASS"
 }
 
-issue_5187: {
+issue_5187_1: {
     options = {
         hoist_props: true,
         hoist_vars: true,
@@ -461,6 +474,37 @@ issue_5187: {
         }
         f();
     }
+    expect: {
+        (function() {
+            var a, b;
+            a = 42;
+            do {
+                b = { 0: a++ };
+            } while (console.log(b[b ^= 0]));
+        })();
+    }
+    expect_stdout: "42"
+}
+
+issue_5187_2: {
+    options = {
+        hoist_props: true,
+        hoist_vars: true,
+        join_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var a = 42;
+            do {
+                var b = { 0: a++ };
+            } while (console.log(b[b ^= 0]));
+        }
+        f();
+    }
     expect: {
         (function() {
             var b, a = 42;
@@ -500,3 +544,260 @@ issue_5195: {
     }
     expect_stdout: "[object Object]"
 }
+
+issue_5378: {
+    options = {
+        hoist_vars: true,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 2;
+        while (a--)
+            (function() {
+                var b;
+                var c;
+                while (console.log(b));
+                --b;
+            })();
+    }
+    expect: {
+        var a = 2;
+        while (a--) {
+            b = void 0;
+            var b, c;
+            while (console.log(b));
+            --b;
+        }
+    }
+    expect_stdout: [
+        "undefined",
+        "undefined",
+    ]
+}
+
+issue_5411_1: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        b++;
+        b = a;
+        var b = b, c = c && c[b];
+        console.log(b);
+    }
+    expect: {
+        var a, b, c;
+        b++;
+        b = a = "PASS";
+        c = c && c[b];
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5411_2: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        b++;
+        b = a;
+        var b = b, c = c && c[b];
+        console.log(b);
+    }
+    expect: {
+        var b, c;
+        b++,
+        b = "PASS",
+        c,
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5411_3: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = console;
+        a++;
+        var a = A = a;
+        console.log(A);
+    }
+    expect: {
+        var a;
+        a = console;
+        a = A = ++a;
+        console.log(A);
+    }
+    expect_stdout: "NaN"
+}
+
+issue_5411_4: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        join_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = console;
+        a++;
+        var a = A = a;
+        console.log(A);
+    }
+    expect: {
+        var a = console;
+        a = A = ++a;
+        console.log(A);
+    }
+    expect_stdout: "NaN"
+}
+
+issue_5626: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function() {
+            return console.log(arguments[0]), 42;
+        }("PASS") ? null : "foo";
+        for (var b in a)
+            FAIL;
+    }
+    expect: {
+        (function() {
+            console.log(arguments[0]);
+        }("PASS"));
+        for (var b in null)
+            FAIL;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5638_1: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL";
+        var a = [ 42 ];
+        console || FAIL(a);
+        console.log(a++);
+    }
+    expect: {
+        var a;
+        a = "FAIL";
+        a = [ 42 ];
+        console || FAIL(a);
+        console.log(a++);
+    }
+    expect_stdout: "42"
+}
+
+issue_5638_2: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL";
+        var a = [ 6 ];
+        console || FAIL(a);
+        console.log(a *= 7);
+    }
+    expect: {
+        var a;
+        a = "FAIL";
+        a = [ 6 ];
+        console || FAIL(a);
+        console.log(a *= 7);
+    }
+    expect_stdout: "42"
+}
+
+issue_5638_3: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var log = console.log;
+        var o = { foo: 42 };
+        for (var k in o) {
+            var v = o[k];
+            log(k || v, v++);
+        }
+    }
+    expect: {
+        var log, o, k, v;
+        log = console.log;
+        for (k in o = { foo: 42 }) {
+            v = o[k];
+            log(k || v, v++);
+        }
+    }
+    expect_stdout: "foo 42"
+}
+
+issue_5638_4: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var log = console.log;
+        var o = { foo: 6 };
+        for (var k in o) {
+            var v = o[k];
+            log(k || v, v *= 7);
+        }
+    }
+    expect: {
+        var log, o, k, v;
+        log = console.log;
+        for (k in o = { foo: 6 }) {
+            v = o[k];
+            log(k || v, v *= 7);
+        }
+    }
+    expect_stdout: "foo 42"
+}

test/compress/ie.js

@@ -2631,13 +2631,14 @@ issue_3999: {
     ]
 }
 
-issue_4001: {
+issue_4001_1: {
     options = {
         collapse_vars: true,
         ie: true,
         inline: true,
         reduce_vars: true,
         sequences: true,
+        side_effects: false,
         toplevel: true,
         unused: true,
     }
@@ -2660,7 +2661,42 @@ issue_4001: {
             return a;
         }
         var a;
-        console.log((a = 42, void f()[42], void function a() {}));
+        console.log((a = 42, f()[42], void f, void function a() {}));
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4001_2: {
+    options = {
+        collapse_vars: true,
+        ie: true,
+        inline: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            function f() {
+                return a;
+                var b;
+            }
+            var c = f();
+            (function g() {
+                c[42];
+                f;
+            })();
+            (function a() {});
+        }(42));
+    }
+    expect: {
+        function f() {
+            return a;
+        }
+        var a;
+        console.log((a = 42, void f()[42]));
     }
     expect_stdout: "undefined"
 }
@@ -3109,9 +3145,9 @@ issue_5081_call: {
         }));
     }
     expect: {
-        function f(b) {
+        function f(a) {
             // IE5-10: TypeError: Function expected
-            return b(b = "A") + (b += "SS");
+            return a(a = "A") + (a += "SS");
         }
         console.log(f(function() {
             return "P";
@@ -3161,8 +3197,8 @@ issue_5081_property_access: {
         console.log(f({ A: "P" }));
     }
     expect: {
-        function f(b) {
-            return b[b = "A"] + (b += "SS");
+        function f(a) {
+            return a[a = "A"] + (a += "SS");
         }
         // IE9-11: undefinedASS
         console.log(f({ A: "P" }));
@@ -3192,3 +3228,249 @@ issue_5081_property_access_ie: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5269_1: {
+    options = {
+        ie: false,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        do {
+            (function() {
+                try {
+                    throw "PASS";
+                } catch (e) {
+                    console.log(e);
+                }
+            })();
+        } while (!console);
+    }
+    expect: {
+        "use strict";
+        do {
+            try {
+                throw "PASS";
+            } catch (e) {
+                console.log(e);
+            }
+        } while (!console);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5269_1_ie: {
+    options = {
+        ie: true,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        do {
+            (function() {
+                try {
+                    throw "PASS";
+                } catch (e) {
+                    console.log(e);
+                }
+            })();
+        } while (!console);
+    }
+    expect: {
+        "use strict";
+        do {
+            try {
+                throw "PASS";
+            } catch (e) {
+                console.log(e);
+            }
+        } while (!console);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5269_2: {
+    options = {
+        ie: false,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        for (var i = 0; i < 2; i++)
+            (function() {
+                console.log(e);
+                try {
+                    console;
+                } catch (e) {
+                    var e = "FAIL 1";
+                }
+                e = "FAIL 2";
+                console;
+            })();
+    }
+    expect: {
+        for (var i = 0; i < 2; i++) {
+            e = void 0;
+            console.log(e);
+            try {
+                console;
+            } catch (e) {
+                var e = "FAIL 1";
+            }
+            e = "FAIL 2";
+            console;
+        }
+    }
+    expect_stdout: [
+        "undefined",
+        "undefined",
+    ]
+}
+
+issue_5269_2_ie: {
+    options = {
+        ie: true,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        for (var i = 0; i < 2; i++)
+            (function() {
+                console.log(e);
+                try {
+                    console;
+                } catch (e) {
+                    var e = "FAIL 1";
+                }
+                e = "FAIL 2";
+                console;
+            })();
+    }
+    expect: {
+        for (var i = 0; i < 2; i++) {
+            e = void 0;
+            console.log(e);
+            try {
+                console;
+            } catch (e) {
+                var e = "FAIL 1";
+            }
+            e = "FAIL 2";
+            console;
+        }
+    }
+    expect_stdout: [
+        "undefined",
+        "undefined",
+    ]
+}
+
+issue_5269_3: {
+    options = {
+        ie: false,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        e = "foo";
+        for (var i = 0; i < 2; i++)
+            (function() {
+                console.log(e);
+                try {
+                    console;
+                } catch (e) {
+                    e = "FAIL";
+                }
+                e = "bar";
+                console;
+            })();
+    }
+    expect: {
+        e = "foo";
+        for (var i = 0; i < 2; i++) {
+            console.log(e);
+            try {
+                console;
+            } catch (e) {
+                e = "FAIL";
+            }
+            e = "bar";
+            console;
+        }
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+issue_5269_3_ie: {
+    options = {
+        ie: true,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        e = "foo";
+        for (var i = 0; i < 2; i++)
+            (function() {
+                console.log(e);
+                try {
+                    console;
+                } catch (e) {
+                    e = "FAIL";
+                }
+                e = "bar";
+                console;
+            })();
+    }
+    expect: {
+        e = "foo";
+        for (var i = 0; i < 2; i++) {
+            console.log(e);
+            try {
+                console;
+            } catch (e) {
+                e = "FAIL";
+            }
+            e = "bar";
+            console;
+        }
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+issue_5350: {
+    options = {
+        ie: false,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(typeof f, [ 42, function f() {} ][0]);
+    }
+    expect: {
+        console.log(typeof f, 42);
+    }
+    expect_stdout: "undefined 42"
+}
+
+issue_5350_ie: {
+    options = {
+        ie: true,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(typeof f, [ 42, function f() {} ][0]);
+    }
+    expect: {
+        console.log(typeof f, (function f() {}, 42));
+    }
+    expect_stdout: "undefined 42"
+}

test/compress/imports.js

@@ -40,6 +40,17 @@ default_keys: {
     expect_exact: 'import foo,{bar}from"baz";'
 }
 
+non_identifiers: {
+    beautify = {
+        quote_style: 3,
+    }
+    input: {
+        import { '42' as foo } from "bar";
+        import { "foo" as bar } from 'baz';
+    }
+    expect_exact: "import{'42'as foo}from\"bar\";import{foo as bar}from'baz';"
+}
+
 dynamic: {
     input: {
         (async a => await import(a))("foo").then(bar);
@@ -106,6 +117,22 @@ drop_unused: {
     }
 }
 
+drop_side_effect_free: {
+    options = {
+        imports: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        import foo from "bar";
+        var a = foo;
+    }
+    expect: {
+        import "bar";
+    }
+}
+
 mangle: {
     rename = false
     mangle = {
@@ -113,12 +140,12 @@ mangle: {
     }
     input: {
         import foo, { bar } from "baz";
-        consoe.log(moo);
+        console.log(moo);
         import * as moo from "moz";
     }
     expect: {
         import o, { bar as m } from "baz";
-        consoe.log(r);
+        console.log(r);
         import * as r from "moz";
     }
 }
@@ -130,16 +157,44 @@ rename_mangle: {
     }
     input: {
         import foo, { bar } from "baz";
-        consoe.log(moo);
+        console.log(moo);
         import * as moo from "moz";
     }
     expect: {
         import o, { bar as m } from "baz";
-        consoe.log(r);
+        console.log(r);
         import * as r from "moz";
     }
 }
 
+mangle_export_import: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export let o = A;
+        import { p as A } from "foo";
+    }
+    expect: {
+        export let o = p;
+        import { p } from "foo";
+    }
+}
+
+mangle_import_export: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import { p as A } from "foo";
+        export let o = A;
+    }
+    expect: {
+        import { p } from "foo";
+        export let o = p;
+    }
+}
+
 keep_ref: {
     options = {
         reduce_vars: true,
@@ -211,3 +266,33 @@ issue_4708_2: {
         import a from "foo";
     }
 }
+
+pr_5550_1: {
+    input: {
+        if (console)
+            import("foo");
+        else
+            import.meta.url.replace(/bar/g, console.log);
+    }
+    expect: {
+        if (console)
+            import("foo");
+        else
+            import.meta.url.replace(/bar/g, console.log);
+    }
+}
+
+pr_5550_2: {
+    input: {
+        L: {
+            import("foo");
+            import.meta.url.replace(/bar/g, console.log);
+        }
+    }
+    expect: {
+        L: {
+            import("foo");
+            import.meta.url.replace(/bar/g, console.log);
+        }
+    }
+}

test/compress/indentation.js

@@ -0,0 +1,100 @@
+numeric: {
+    beautify = {
+        beautify: true,
+        indent_start: 1,
+        indent_level: 3,
+    }
+    input: {
+        switch (42) {
+          case null:
+            console.log("FAIL");
+        }
+        console.log("PASS");
+    }
+    expect_exact: [
+        " switch (42) {",
+        "  case null:",
+        '    console.log("FAIL");',
+        " }",
+        "",
+        ' console.log("PASS");',
+    ]
+    expect_stdout: "PASS"
+}
+
+spaces: {
+    beautify = {
+        beautify: true,
+        indent_start: " ",
+        indent_level: "   ",
+    }
+    input: {
+        switch (42) {
+          case null:
+            console.log("FAIL");
+        }
+        console.log("PASS");
+    }
+    expect_exact: [
+        " switch (42) {",
+        "  case null:",
+        '    console.log("FAIL");',
+        " }",
+        "",
+        ' console.log("PASS");',
+    ]
+    expect_stdout: "PASS"
+}
+
+tabs: {
+    beautify = {
+        beautify: true,
+        indent_start: "\t",
+        indent_level: "\t",
+    }
+    input: {
+        switch (42) {
+          case null:
+            console.log("FAIL");
+        }
+        console.log("PASS");
+    }
+    expect_exact: [
+        "\tswitch (42) {",
+        "\tcase null:",
+        '\t\tconsole.log("FAIL");',
+        "\t}",
+        "",
+        '\tconsole.log("PASS");',
+    ]
+    expect_stdout: "PASS"
+}
+
+mixed: {
+    beautify = {
+        beautify: true,
+        indent_start: "\n",
+        indent_level: "       \t",
+    }
+    input: {
+        switch (42) {
+          case null:
+            console.log("FAIL");
+        }
+        console.log("PASS");
+    }
+    expect_exact: [
+        "",
+        "switch (42) {",
+        "",
+        "    case null:",
+        "",
+        '       \tconsole.log("FAIL");',
+        "",
+        "}",
+        "",
+        "",
+        'console.log("PASS");',
+    ]
+    expect_stdout: "PASS"
+}

test/compress/issue-1052.js

@@ -5,9 +5,8 @@ multiple_functions: {
     }
     input: {
         (function() {
-            if ( !window ) {
+            if (!window)
                 return;
-            }
             function f() {}
             function g() {}
         })();
@@ -30,9 +29,8 @@ single_function: {
     }
     input: {
         (function() {
-            if ( !window ) {
+            if (!window)
                 return;
-            }
             function f() {}
         })();
     }
@@ -51,14 +49,12 @@ deeply_nested: {
     }
     input: {
         (function() {
-            if ( !window ) {
+            if (!window)
                 return;
-            }
             function f() {}
             function g() {}
-            if ( !document ) {
+            if (!document)
                 return;
-            }
             function h() {}
         })();
     }
@@ -66,8 +62,8 @@ deeply_nested: {
         (function() {
             // NOTE: other compression steps will reduce this
             // down to just `window`.
-            if ( window )
-                if ( !document );
+            if (!window);
+            else if (!document);
             function f() {}
             function g() {}
             function h() {}
@@ -82,16 +78,16 @@ not_hoisted_when_already_nested: {
     }
     input: {
         (function() {
-            if ( !window ) {
+            if (!window)
                 return;
-            }
             if (foo) function f() {}
         })();
     }
     expect: {
         (function() {
-            if ( window )
-                if ( foo ) function f() {}
+            if (!window);
+            else if (foo)
+                function f() {}
         })();
     }
 }
@@ -104,15 +100,19 @@ defun_if_return: {
     input: {
         function e() {
             function f() {}
-            if (!window) return;
-            else function g() {}
+            if (!window)
+                return;
+            else
+                function g() {}
             function h() {}
         }
     }
     expect: {
         function e() {
             function f() {}
-            if (window) function g() {}
+            if (!window);
+            else
+                function g() {}
             function h() {}
         }
     }
@@ -126,8 +126,10 @@ defun_hoist_funs: {
     input: {
         function e() {
             function f() {}
-            if (!window) return;
-            else function g() {}
+            if (!window)
+                return;
+            else
+                function g() {}
             function h() {}
         }
     }
@@ -136,7 +138,7 @@ defun_hoist_funs: {
             function f() {}
             function g() {}
             function h() {}
-            if (window);
+            if (!window);
         }
     }
 }
@@ -149,15 +151,18 @@ defun_else_if_return: {
     input: {
         function e() {
             function f() {}
-            if (window) function g() {}
-            else return;
+            if (window)
+                function g() {}
+            else
+                return;
             function h() {}
         }
     }
     expect: {
         function e() {
             function f() {}
-            if (window) function g() {}
+            if (window)
+                function g() {}
             function h() {}
         }
     }

test/compress/issue-1321.js

@@ -1,6 +1,7 @@
 issue_1321_no_debug: {
     mangle = {
         properties: {
+            domprops: true,
             keep_quoted: true,
         },
     }
@@ -23,6 +24,7 @@ issue_1321_debug: {
     mangle = {
         properties: {
             debug: "",
+            domprops: true,
             keep_quoted: true,
         },
     }
@@ -44,6 +46,7 @@ issue_1321_debug: {
 issue_1321_with_quoted: {
     mangle = {
         properties: {
+            domprops: true,
             keep_quoted: false,
         },
     }

test/compress/issue-143.js

@@ -1,5 +1,5 @@
 /**
- * There was an incorrect sort behaviour documented in issue #143:
+ * There was an incorrect sort behavior documented in issue #143:
  * (x = f(…)) <= x → x >= (x = f(…))
  *
  * For example, let the equation be:
@@ -12,37 +12,54 @@
  * a >= (a = parseInt('100')) → 99 >= 100 → false
  */
 
-tranformation_sort_order_equal: {
+transformation_sort_order_equal: {
     options = {
         comparisons: true,
     }
-
-    input: { (a = parseInt('100')) == a }
-    expect: { (a = parseInt('100')) == a }
+    input: {
+        console.log((a = parseInt("100")) == a);
+    }
+    expect: {
+        console.log((a = parseInt("100")) == a);
+    }
+    expect_stdout: "true"
 }
 
-tranformation_sort_order_unequal: {
+transformation_sort_order_unequal: {
     options = {
         comparisons: true,
     }
-
-    input: { (a = parseInt('100')) != a }
-    expect: { (a = parseInt('100')) != a }
+    input: {
+        console.log((a = parseInt("100")) != a);
+    }
+    expect: {
+        console.log((a = parseInt("100")) != a);
+    }
+    expect_stdout: "false"
 }
 
-tranformation_sort_order_lesser_or_equal: {
+transformation_sort_order_lesser_or_equal: {
     options = {
         comparisons: true,
     }
-
-    input: { (a = parseInt('100')) <= a }
-    expect: { (a = parseInt('100')) <= a }
+    input: {
+        console.log((a = parseInt("100")) <= a);
     }
-tranformation_sort_order_greater_or_equal: {
+    expect: {
+        console.log((a = parseInt("100")) <= a);
+    }
+    expect_stdout: "true"
+}
+
+transformation_sort_order_greater_or_equal: {
     options = {
         comparisons: true,
     }
-
-    input: { (a = parseInt('100')) >= a }
-    expect: { (a = parseInt('100')) >= a }
+    input: {
+        console.log((a = parseInt("100")) >= a);
+    }
+    expect: {
+        console.log((a = parseInt("100")) >= a);
+    }
+    expect_stdout: "true"
 }

test/compress/issue-1447.js

@@ -40,6 +40,9 @@ conditional_false_stray_else_in_loop: {
             console.log(i);
         }
     }
-    expect_exact: "for(var i=1;i<=4;++i)if(!(i<=2))console.log(i);"
-    expect_stdout: true
+    expect_exact: "for(var i=1;i<=4;++i)if(i<=2);else console.log(i);"
+    expect_stdout: [
+        "3",
+        "4",
+    ]
 }

test/compress/issue-1704.js

@@ -356,6 +356,7 @@ mangle_catch_redef_3: {
         try {
             throw 0;
         } catch (o) {
+            // prints "FAIL" if inlined on Node.js v4-
             (function() {
                 function f() {
                     o = "FAIL";
@@ -366,7 +367,8 @@ mangle_catch_redef_3: {
         console.log(o);
     }
     expect_exact: 'var o="PASS";try{throw 0}catch(o){(function(){function c(){o="FAIL"}c(),c()})()}console.log(o);'
-    expect_stdout: true
+    expect_stdout: "PASS"
+    node_version: ">=6"
 }
 
 mangle_catch_redef_3_toplevel: {
@@ -379,6 +381,7 @@ mangle_catch_redef_3_toplevel: {
         try {
             throw 0;
         } catch (o) {
+            // prints "FAIL" if inlined on Node.js v4-
             (function() {
                 function f() {
                     o = "FAIL";
@@ -389,7 +392,8 @@ mangle_catch_redef_3_toplevel: {
         console.log(o);
     }
     expect_exact: 'var c="PASS";try{throw 0}catch(c){(function(){function o(){c="FAIL"}o(),o()})()}console.log(c);'
-    expect_stdout: true
+    expect_stdout: "PASS"
+    node_version: ">=6"
 }
 
 mangle_catch_redef_3_ie8: {
@@ -402,6 +406,7 @@ mangle_catch_redef_3_ie8: {
         try {
             throw 0;
         } catch (o) {
+            // prints "FAIL" if inlined on Node.js v4-
             (function() {
                 function f() {
                     o = "FAIL";
@@ -412,7 +417,8 @@ mangle_catch_redef_3_ie8: {
         console.log(o);
     }
     expect_exact: 'var o="PASS";try{throw 0}catch(o){(function(){function c(){o="FAIL"}c(),c()})()}console.log(o);'
-    expect_stdout: true
+    expect_stdout: "PASS"
+    node_version: ">=6"
 }
 
 mangle_catch_redef_3_ie8_toplevel: {
@@ -425,6 +431,7 @@ mangle_catch_redef_3_ie8_toplevel: {
         try {
             throw 0;
         } catch (o) {
+            // prints "FAIL" if inlined on Node.js v4-
             (function() {
                 function f() {
                     o = "FAIL";
@@ -435,5 +442,6 @@ mangle_catch_redef_3_ie8_toplevel: {
         console.log(o);
     }
     expect_exact: 'var c="PASS";try{throw 0}catch(c){(function(){function o(){c="FAIL"}o(),o()})()}console.log(c);'
-    expect_stdout: true
+    expect_stdout: "PASS"
+    node_version: ">=6"
 }

test/compress/issue-1770.js

@@ -53,11 +53,21 @@ mangle_props: {
         );
     }
     expect_stdout: "1 1 1 2 2 2 3 3 3 4 4 4 5 5"
+    expect_warnings: [
+        "INFO: Preserving reserved property undefined",
+        "INFO: Preserving reserved property NaN",
+        "INFO: Preserving reserved property Infinity",
+        "INFO: Preserving reserved property -Infinity",
+        "INFO: Preserving reserved property null",
+        "INFO: Preserving reserved property log",
+    ]
 }
 
 numeric_literal: {
     mangle = {
-        properties: true,
+        properties: {
+            domprops: true,
+        },
     }
     beautify = {
         beautify: true,
@@ -106,11 +116,19 @@ numeric_literal: {
         "4 5 4 4",
         "8 7 8",
     ]
+    expect_warnings: [
+        "INFO: Mapping property 0x25 to o",
+        "INFO: Mapping property 1E42 to b",
+        "INFO: Preserving reserved property log",
+    ]
 }
 
 identifier: {
     mangle = {
-        properties: true,
+        properties: {
+            builtins: true,
+            domprops: true,
+        },
     }
     input: {
         var obj = {
@@ -209,37 +227,37 @@ identifier: {
             B: 28,
             C: 29,
             D: 30,
-            F: 31,
-            G: 32,
-            false: 33,
-            null: 34,
-            true: 35,
-            H: 36,
-            I: 37,
-            J: 38,
-            K: 39,
-            L: 40,
-            M: 41,
-            N: 42,
-            O: 43,
-            P: 44,
-            Q: 45,
-            R: 46,
-            S: 47,
-            T: 48,
-            U: 49,
-            V: 50,
-            W: 51,
-            X: 52,
-            Y: 53,
-            Z: 54,
-            $: 55,
-            _: 56,
-            ee: 57,
-            te: 58,
-            ne: 59,
-            ae: 60,
-            ie: 61,
+            E: 31,
+            F: 32,
+            G: 33,
+            H: 34,
+            I: 35,
+            J: 36,
+            K: 37,
+            L: 38,
+            M: 39,
+            N: 40,
+            O: 41,
+            P: 42,
+            Q: 43,
+            R: 44,
+            S: 45,
+            T: 46,
+            U: 47,
+            V: 48,
+            W: 49,
+            X: 50,
+            Y: 51,
+            Z: 52,
+            $: 53,
+            _: 54,
+            ee: 55,
+            te: 56,
+            ne: 57,
+            ae: 58,
+            ie: 59,
+            oe: 60,
+            re: 61,
         };
     }
 }

test/compress/issue-281.js

@@ -108,6 +108,7 @@ safe_undefined: {
 }
 
 negate_iife_3: {
+    expression = true
     options = {
         conditionals: true,
         expression: true,
@@ -123,6 +124,7 @@ negate_iife_3: {
 }
 
 negate_iife_3_off: {
+    expression = true
     options = {
         conditionals: true,
         expression: true,
@@ -203,6 +205,7 @@ negate_iife_5_off: {
 }
 
 issue_1254_negate_iife_true: {
+    expression = true
     options = {
         expression: true,
         inline: true,
@@ -215,11 +218,12 @@ issue_1254_negate_iife_true: {
             };
         })()();
     }
-    expect_exact: 'void console.log("test");'
+    expect_exact: 'void console.log("test")'
     expect_stdout: true
 }
 
 issue_1254_negate_iife_nested: {
+    expression = true
     options = {
         expression: true,
         inline: true,
@@ -232,7 +236,7 @@ issue_1254_negate_iife_nested: {
             };
         })()()()()();
     }
-    expect_exact: '(void console.log("test"))()()();'
+    expect_exact: '(void console.log("test"))()()()'
 }
 
 negate_iife_issue_1073: {

test/compress/issue-368.js

@@ -15,7 +15,7 @@ collapse: {
             var a;
             b = c();
             a = typeof b === 'function' ? b() : b;
-            return 'stirng' == typeof a && d();
+            return 'string' == typeof a && d();
         }
         function f3(c) {
             var a;
@@ -41,7 +41,7 @@ collapse: {
             return void 0 !== ('function' === typeof b ? b() : b) && c();
         }
         function f2(b) {
-            return 'stirng' == typeof ('function' === typeof (b = c()) ? b() : b) && d();
+            return 'string' == typeof ('function' === typeof (b = c()) ? b() : b) && d();
         }
         function f3(c) {
             var a;

test/compress/issue-5614.js

@@ -0,0 +1,195 @@
+record_update: {
+    options = {
+        loops: true,
+        passes: 3,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var value = { a: 42, b: "PASS" };
+        var unused = _Utils_update(value, { b: "FAIL" });
+        function _Utils_update(oldRecord, updatedFields) {
+            var newRecord = {};
+            for (var key in oldRecord)
+                newRecord[key] = oldRecord[key];
+            for (var key in updatedFields)
+                newRecord[key] = updatedFields[key];
+            return newRecord;
+        }
+    }
+    expect: {}
+}
+
+currying: {
+    options = {
+        inline: true,
+        passes: 3,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function F(arity, fun, wrapper) {
+            wrapper.a = arity;
+            wrapper.f = fun;
+            return wrapper;
+        }
+        function F2(fun) {
+            return F(2, fun, function(a) {
+                return function(b) {
+                    return fun(a, b);
+                };
+            });
+        }
+        function _Utils_eq(x, y) {
+            var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);
+            while (isEqual && (pair = stack.pop()))
+                isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack);
+            return isEqual;
+        }
+        var _Utils_equal = F2(_Utils_eq);
+    }
+    expect: {}
+}
+
+conditional_property_write: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var o = {};
+            if (a)
+                o.p = console.log("foo");
+            else
+                o.q = console.log("bar");
+            o.r = console.log("baz");
+        }
+        f(42);
+        f(null);
+    }
+    expect: {
+        function f(a) {
+            if (a)
+                console.log("foo");
+            else
+                console.log("bar");
+            console.log("baz");
+        }
+        f(42);
+        f(null);
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "bar",
+        "baz",
+    ]
+}
+
+reassign_1: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS", b = "FAIL";
+        (b = a).toString();
+        console.log(b);
+    }
+    expect: {
+        var b = "FAIL";
+        (b = "PASS").toString();
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+reassign_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        if (false) {
+            a = null + 0;
+            a();
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        if (false) {
+            a = 0;
+            a();
+        }
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+reassign_3: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 0;
+        (a = a || "PASS").toString();
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        (a = (0, "PASS")).toString();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+retain_instance_write: {
+    options = {
+        pure_getters: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            return a;
+        }
+        function g() {
+            var o = {};
+            var b = new f(o);
+            if (console)
+                b.p = "PASS";
+            return o;
+        }
+        console.log(g().p);
+    }
+    expect: {
+        function f(a) {
+            return a;
+        }
+        function g() {
+            var o = {};
+            var b = new f(o);
+            if (console)
+                b.p = "PASS";
+            return o;
+        }
+        console.log(g().p);
+    }
+    expect_stdout: "PASS"
+}

test/compress/issue-640.js

@@ -68,6 +68,7 @@ drop_console_2: {
 }
 
 drop_value: {
+    expression = true
     options = {
         expression: true,
         side_effects: true,
@@ -106,6 +107,7 @@ wrongly_optimized: {
 }
 
 negate_iife_1: {
+    expression = true
     options = {
         expression: true,
         negate_iife: true,
@@ -119,6 +121,7 @@ negate_iife_1: {
 }
 
 negate_iife_3: {
+    expression = true
     options = {
         conditionals: true,
         expression: true,
@@ -133,6 +136,7 @@ negate_iife_3: {
 }
 
 negate_iife_3_off: {
+    expression = true
     options = {
         conditionals: true,
         expression: true,
@@ -215,6 +219,7 @@ negate_iife_5_off: {
 }
 
 issue_1254_negate_iife_true: {
+    expression = true
     options = {
         expression: true,
         negate_iife: true,
@@ -226,11 +231,12 @@ issue_1254_negate_iife_true: {
             };
         })()();
     }
-    expect_exact: '(function(){return function(){console.log("test")}})()();'
+    expect_exact: 'function(){return function(){console.log("test")}}()()'
     expect_stdout: true
 }
 
 issue_1254_negate_iife_nested: {
+    expression = true
     options = {
         expression: true,
         negate_iife: true,
@@ -242,7 +248,7 @@ issue_1254_negate_iife_nested: {
             };
         })()()()()();
     }
-    expect_exact: '(function(){return function(){console.log("test")}})()()()()();'
+    expect_exact: 'function(){return function(){console.log("test")}}()()()()()'
     expect_stdout: true
 }
 
@@ -317,7 +323,35 @@ iife: {
         typeof function g() {}();
     }
     expect: {
-        x = 42, function a() {}(), function b() {}(), function c() {}(),
-        function d() {}(), function e() {}(), function f() {}(), typeof function g() {}();
+        x = 42,
+        function a() {}(),
+        !function b() {}(),
+        ~function c() {}(),
+        +function d() {}(),
+        -function e() {}(),
+        void function f() {}(),
+        typeof function g() {}();
+    }
+}
+
+iife_drop_side_effect_free: {
+    options = {
+        expression: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        x = 42;
+        (function a() {})();
+        !function b() {}();
+        ~function c() {}();
+        +function d() {}();
+        -function e() {}();
+        void function f() {}();
+        typeof function g() {}();
+    }
+    expect: {
+        x = 42,
+        typeof void 0;
     }
 }

test/compress/issue-747.js

@@ -1,6 +1,7 @@
 dont_reuse_prop: {
     mangle = {
         properties: {
+            domprops: true,
             regex: /asd/,
         },
     }
@@ -19,11 +20,17 @@ dont_reuse_prop: {
         console.log(obj.a);
     }
     expect_stdout: "123"
+    expect_warnings: [
+        "INFO: Preserving excluded property a",
+        "INFO: Mapping property asd to b",
+        "INFO: Preserving reserved property log",
+    ]
 }
 
 unmangleable_props_should_always_be_reserved: {
     mangle = {
         properties: {
+            domprops: true,
             regex: /asd/,
         },
     }
@@ -42,4 +49,9 @@ unmangleable_props_should_always_be_reserved: {
         console.log(obj.a);
     }
     expect_stdout: "123"
+    expect_warnings: [
+        "INFO: Preserving excluded property a",
+        "INFO: Mapping property asd to b",
+        "INFO: Preserving reserved property log",
+    ]
 }

test/compress/issue-892.js

@@ -1,6 +1,4 @@
 dont_mangle_arguments: {
-    mangle = {
-    };
     options = {
         booleans: true,
         comparisons: true,
@@ -21,12 +19,13 @@ dont_mangle_arguments: {
         side_effects: true,
         unused: true,
     }
+    mangle = {}
     input: {
         (function(){
             var arguments = arguments, not_arguments = 9;
             console.log(not_arguments, arguments);
         })(5, 6, 7);
     }
-    expect_exact: "(function(){var arguments=arguments,o=9;console.log(o,arguments)})(5,6,7);"
+    expect_exact: "(function(){var arguments,o=9;console.log(o,arguments)})(5,6,7);"
     expect_stdout: true
 }

test/compress/issue-913.js

@@ -1,6 +1,7 @@
 keep_var_for_in: {
     options = {
         hoist_vars: true,
+        join_vars: true,
         unused: true,
     }
     input: {

test/compress/issue-979.js

@@ -1,4 +1,4 @@
-issue979_reported: {
+reported: {
     options = {
         booleans: true,
         comparisons: true,
@@ -17,18 +17,15 @@ issue979_reported: {
     }
     input: {
         function f1() {
-            if (a == 1 || b == 2) {
+            if (a == 1 || b == 2)
                 foo();
         }
-        }
         function f2() {
-            if (!(a == 1 || b == 2)) {
-            }
-            else {
+            if (!(a == 1 || b == 2));
+            else
                 foo();
         }
     }
-    }
     expect: {
         function f1() {
             1 != a && 2 != b || foo();
@@ -39,7 +36,7 @@ issue979_reported: {
     }
 }
 
-issue979_test_negated_is_best: {
+test_negated_is_best: {
     options = {
         booleans: true,
         comparisons: true,
@@ -58,38 +55,30 @@ issue979_test_negated_is_best: {
     }
     input: {
         function f3() {
-            if (a == 1 | b == 2) {
+            if (a == 1 | b == 2)
                 foo();
         }
-        }
         function f4() {
-            if (!(a == 1 | b == 2)) {
-            }
-            else {
+            if (!(a == 1 | b == 2));
+            else
                 foo();
         }
-        }
         function f5() {
-            if (a == 1 && b == 2) {
+            if (a == 1 && b == 2)
                 foo();
         }
-        }
         function f6() {
-            if (!(a == 1 && b == 2)) {
-            }
-            else {
+            if (!(a == 1 && b == 2));
+            else
                 foo();
         }
-        }
         function f7() {
-            if (a == 1 || b == 2) {
+            if (a == 1 || b == 2)
                 foo();
-            }
-            else {
+            else
                 return bar();
         }
     }
-    }
     expect: {
         function f3() {
             1 == a | 2 == b && foo();
@@ -101,10 +90,12 @@ issue979_test_negated_is_best: {
             1 == a && 2 == b && foo();
         }
         function f6() {
-            1!=a||2!=b||foo();
+            1 == a && 2 == b && foo();
         }
         function f7() {
-            if(1!=a&&2!=b)return bar();foo()
+            if (1 != a && 2 != b)
+                return bar();
+            foo();
         }
     }
 }

test/compress/join_vars.js

@@ -16,6 +16,105 @@ join_vars_assign: {
     expect_stdout: "PASS"
 }
 
+join_array_assignments_1: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        console.log(function () {
+            var a = [ "foo", , "bar" ];
+            a[1] = "baz";
+            a[7] = "moo";
+            a[0] = "moz";
+            return a;
+        }().join());
+    }
+    expect: {
+        console.log(function () {
+            var a = [ "moz", "baz", "bar", , , , , "moo" ];
+            return a;
+        }().join());
+    }
+    expect_stdout: "moz,baz,bar,,,,,moo"
+}
+
+join_array_assignments_2: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        console.log(function () {
+            var a = [ "foo" ];
+            a[1] = "bar";
+            a[7] = "baz";
+            a[2] = "moo";
+            return a;
+        }().join());
+    }
+    expect: {
+        console.log(function () {
+            var a = [ "foo", "bar" ];
+            a[7] = "baz";
+            a[2] = "moo";
+            return a;
+        }().join());
+    }
+    expect_stdout: "foo,bar,moo,,,,,baz"
+}
+
+join_array_assignments_3: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        console.log(function () {
+            var a = [ "foo" ];
+            a[1] = "bar";
+            a.b = "baz";
+            a[2] = "moo";
+            return a;
+        }().join());
+    }
+    expect: {
+        console.log(function () {
+            var a = [ "foo", "bar" ];
+            a.b = "baz";
+            a[2] = "moo";
+            return a;
+        }().join());
+    }
+    expect_stdout: true
+}
+
+join_array_assignments_4: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function () {
+            var a = [ "foo" ];
+            a[0] = "bar";
+            a[1] = a;
+            a[2] = "baz";
+            return a;
+        }().join());
+    }
+    expect: {
+        console.log(function () {
+            var a = [ "bar" ];
+            a[1] = a;
+            a[2] = "baz";
+            return a;
+        }().join());
+    }
+    expect_stdout: true
+}
+
 join_object_assignments_1: {
     options = {
         evaluate: true,
@@ -570,6 +669,50 @@ inlined_assignments: {
     expect_stdout: "PASS"
 }
 
+inline_for: {
+    options = {
+        inline: true,
+        join_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function() {
+            for (; console.log("PASS"););
+        };
+        a();
+    }
+    expect: {
+        for (; console.log("PASS"););
+    }
+    expect_stdout: "PASS"
+}
+
+inline_var: {
+    options = {
+        inline: true,
+        join_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        A = "PASS";
+        var a = function() {
+            var b = A;
+            for (b in console.log(b));
+        };
+        a();
+    }
+    expect: {
+        A = "PASS";
+        var b = A;
+        for (b in console.log(b));
+    }
+    expect_stdout: "PASS"
+}
+
 typescript_enum: {
     rename = true
     options = {
@@ -1100,7 +1243,7 @@ conditional_assignments_3: {
     expect_stdout: "PASS"
 }
 
-issue_3856: {
+issue_3856_1: {
     options = {
         booleans: true,
         conditionals: true,
@@ -1125,9 +1268,46 @@ issue_3856: {
         console.log(function() {
             (function() {
                 var a, b;
-                if (a) return a, 1;
-                for (a = 0; !console;);
+                if (a) a;
+                else {
+                    a = 0;
+                    for (; !console;);
+                }
+            })();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_3856_2: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        if_return: true,
+        join_vars: true,
+        passes: 2,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function() {
+            (function() {
+                var a;
+                if (!a) {
+                    a = 0;
+                    for (var b; !console;);
                     return 0;
+                }
+                if (a) return 1;
+            })();
+        }());
+    }
+    expect: {
+        console.log(function() {
+            (function() {
+                var a, b;
+                if (!a)
+                    for (a = 0; !console;);
             })();
         }());
     }
@@ -1282,10 +1462,7 @@ assign_sequence_var: {
         console.log(a, b, c);
     }
     expect: {
-        var a = 0, b = 1;
-        console.log(a),
-        a++;
-        var b = 2, c = 3;
+        var a = 0, b = 1, c = (console.log(a), a++, b = 2, 3);
         console.log(a, b, c);
     }
     expect_stdout: [
@@ -1316,3 +1493,37 @@ issue_5175: {
     }
     expect_stdout: "PASS PASS"
 }
+
+issue_5831: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        var a = [ console.log("PASS") ];
+        a[0] = 42;
+    }
+    expect: {
+        var a = [ (console.log("PASS"), 42) ];
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5849: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+        side_effects: true,
+    }
+    input: {
+        var a;
+        a = [ 42 ];
+        a[0] = "PASS";
+        console.log(a.join(""));
+    }
+    expect: {
+        var a, a = [ "PASS" ];
+        console.log(a.join(""));
+    }
+    expect_stdout: "PASS"
+}

test/compress/keep_fargs.js

@@ -181,10 +181,10 @@ issue_2203_2: {
             a: "FAIL",
             b: function() {
                 return function() {
-                    return (String, (Object, function() {
+                    return (Object, function() {
                         return this;
-                    }())).a;
-                }();
+                    }()).a;
+                }(String);
             }
         }.b());
     }
@@ -925,6 +925,28 @@ duplicate_lambda_defun_name_2: {
     expect_stdout: "0"
 }
 
+function_argument_mangle: {
+    mangle = {
+        keep_fargs: true,
+        toplevel: true,
+    }
+    input: {
+        A = "PASS";
+        var a = A;
+        (function(o) {
+            console.log(a);
+        })("FAIL");
+    }
+    expect: {
+        A = "PASS";
+        var n = A;
+        (function(o) {
+            console.log(n);
+        })("FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
 function_name_mangle: {
     options = {
         keep_fargs: false,
@@ -1217,6 +1239,7 @@ issues_3267_1: {
         evaluate: true,
         inline: true,
         keep_fargs: false,
+        negate_iife: true,
         reduce_vars: true,
         sequences: true,
         side_effects: true,

test/compress/labels.js

@@ -111,6 +111,7 @@ labels_5: {
 labels_6: {
     options = {
         dead_code: true,
+        unused: true,
     }
     input: {
         out: break out;
@@ -208,6 +209,59 @@ labels_10: {
     expect_stdout: "PASS"
 }
 
+labels_11: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        unused: true,
+    }
+    input: {
+        L: if (console.log("PASS"))
+            break L;
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+labels_12: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
+    input: {
+        L: try {
+            if (console.log("foo"))
+                break L;
+            throw "bar";
+        } catch (e) {
+            console.log(e);
+            break L;
+        } finally {
+            if (console.log("baz"))
+                break L;
+        }
+    }
+    expect: {
+        L: try {
+            if (!console.log("foo"))
+                throw "bar";
+        } catch (e) {
+            console.log(e);
+        } finally {
+            if (console.log("baz"))
+                break L;
+        }
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+}
+
 issue_4466_1: {
     mangle = {
         v8: false,
@@ -327,3 +381,53 @@ issue_4466_2_toplevel_v8: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5522: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(function() {
+            L: try {
+                return "FAIL";
+            } finally {
+                break L;
+            }
+            return "PASS";
+        }());
+    }
+    expect: {
+        console.log(function() {
+            L: try {
+                return "FAIL";
+            } finally {
+                break L;
+            }
+            return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5524: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        L: try {
+            FAIL;
+        } finally {
+            break L;
+        }
+        console.log("PASS");
+    }
+    expect: {
+        L: try {
+            FAIL;
+        } finally {
+            break L;
+        }
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}

test/compress/max_line_len.js

@@ -37,6 +37,51 @@ just_enough: {
     expect_warnings: []
 }
 
+drop_semicolon: {
+    beautify = {
+        max_line_len: 5,
+        semicolons: true,
+    }
+    input: {
+        var a;
+        console.log(a || 42);
+    }
+    expect_exact: [
+        "var a",
+        "console.log(",
+        "a||42",
+        ");",
+    ]
+    expect_stdout: "42"
+    expect_warnings: [
+        "WARN: Output exceeds 5 characters",
+    ]
+}
+
+template_newline: {
+    beautify = {
+        max_line_len: 2,
+    }
+    input: {
+        console.log(`foo
+bar`);
+    }
+    expect_exact: [
+        "console.log(",
+        "`foo",
+        "bar`",
+        ");",
+    ]
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    expect_warnings: [
+        "WARN: Output exceeds 2 characters",
+    ]
+    node_version: ">=4"
+}
+
 issue_304: {
     beautify = {
         max_line_len: 10,

test/compress/negate-iife.js

@@ -122,13 +122,41 @@ negate_iife_4: {
         sequences: true,
     }
     input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
+        (function() {
+            return t;
+        })() ? console.log(true) : console.log(false);
         (function() {
             console.log("something");
         })();
     }
     expect: {
-        !function(){ return t }() ? console.log(false) : console.log(true), function(){
+        !function() {
+            return t;
+        }() ? console.log(false) : console.log(true), !function() {
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_4_drop_side_effect_free: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        (function() {
+            return t;
+        })() ? console.log(true) : console.log(false);
+        (function() {
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function() {
+            return t;
+        }() ? console.log(false) : console.log(true), function() {
             console.log("something");
         }();
     }
@@ -176,7 +204,9 @@ negate_iife_5: {
         sequences: true,
     }
     input: {
-        if ((function(){ return t })()) {
+        if (function() {
+            return t;
+        }()) {
             foo(true);
         } else {
             bar(false);
@@ -186,7 +216,37 @@ negate_iife_5: {
         })();
     }
     expect: {
-        !function(){ return t }() ? bar(false) : foo(true), function(){
+        !function() {
+            return t;
+        }() ? bar(false) : foo(true), !function() {
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_5_drop_side_effect_free: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        if (function() {
+            return t;
+        }()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function() {
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function() {
+            return t;
+        }() ? bar(false) : foo(true), function() {
             console.log("something");
         }();
     }
@@ -389,6 +449,7 @@ issue_1288_side_effects: {
     options = {
         conditionals: true,
         negate_iife: true,
+        sequences: true,
         side_effects: true,
     }
     input: {
@@ -409,10 +470,10 @@ issue_1288_side_effects: {
             })(0);
     }
     expect: {
-        w;
+        w,
         x || function() {
             x = {};
-        }();
+        }(),
         y;
     }
 }

test/compress/nullish.js

@@ -262,6 +262,30 @@ de_morgan_2e: {
     node_version: ">=14"
 }
 
+inline_binary_nullish: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (function() {
+            while (console.log("foo"));
+        })() ?? (function() {
+            while (console.log("bar"));
+        })();
+    }
+    expect: {
+        if (null == function() {
+            while (console.log("foo"));
+        }())
+            while (console.log("bar"));
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=14"
+}
+
 issue_4679: {
     options = {
         comparisons: true,
@@ -280,3 +304,83 @@ issue_4679: {
     expect_stdout: "PASS"
     node_version: ">=14"
 }
+
+issue_5266: {
+    options = {
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        [
+            42,
+            null,
+            false,
+            void 0,
+            "FAIL",
+        ].forEach(function (a) {
+            a ?? function() {
+                while (console.log(a));
+            }();
+        });
+    }
+    expect: {
+        [
+            42,
+            null,
+            false,
+            void 0,
+            "FAIL",
+        ].forEach(function (a) {
+            if (null == a) {
+                while (console.log(a));
+                return;
+            } else
+                return;
+        });
+    }
+    expect_stdout: [
+        "null",
+        "undefined",
+    ]
+    node_version: ">=14"
+}
+
+issue_5829_1: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function f(a) {
+            var b;
+            (!a ?? (b = 0)) || console.log(b || "PASS");
+        })("FAIL");
+    }
+    expect: {
+        (function f(a) {
+            var b;
+            (!a ?? (b = 0)) || console.log(b || "PASS");
+        })("FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_5829_2: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function f(a) {
+            var b;
+            (a ?? (b = 0)) && console.log(b || "PASS");
+        })("FAIL");
+    }
+    expect: {
+        (function f(a) {
+            var b;
+            (a ?? (b = 0)) && console.log(b || "PASS");
+        })("FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}

test/compress/numbers.js

@@ -842,9 +842,9 @@ unary_binary_parentheses: {
         v.forEach(function(x) {
             v.forEach(function(y) {
                 console.log(
-                    +x*y,
-                    +x/y,
-                    +x%y,
+                    x*y,
+                    x/y,
+                    x%y,
                     -x*y,
                     -x/y,
                     -x%y
@@ -1397,7 +1397,7 @@ issue_3695: {
     }
     expect: {
         var a = [];
-        console.log(+(a * (a[0] = false)));
+        console.log(a * (a[0] = false));
     }
     expect_stdout: "NaN"
 }

test/compress/objects.js

@@ -173,7 +173,9 @@ numeric_literal: {
         side_effects: true,
     }
     mangle = {
-        properties: true,
+        properties: {
+            domprops: true,
+        },
     }
     beautify = {
         beautify: true,
@@ -521,3 +523,25 @@ issue_4415: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_5213: {
+    options = {
+        objects: true,
+    }
+    input: {
+        var a = "FAIL";
+        console.log({
+            p: a = "PASS",
+            0: a,
+            p: null,
+        }[0]);
+    }
+    expect: {
+        var a = "FAIL";
+        console.log({
+            p: (a = "PASS", null),
+            0: a,
+        }[0]);
+    }
+    expect_stdout: "PASS"
+}

test/compress/optional-chains.js

@@ -361,7 +361,9 @@ issue_4906: {
         } while (console.log("PASS"));
     }
     expect: {
-        do {} while (console.log("PASS"));
+        do {
+            var a = a?.[42];
+        } while (console.log("PASS"));
     }
     expect_stdout: "PASS"
     node_version: ">=14"
@@ -434,7 +436,7 @@ issue_5039: {
         console.log("PASS");
     }
     expect: {
-        (function f() {});
+        var a = a?.[function f() {}];
         console.log("PASS");
     }
     expect_stdout: "PASS"
@@ -455,14 +457,193 @@ issue_5091: {
         console.log(f("FAIL 1") || "PASS");
     }
     expect: {
-        function f(b) {
-            var b = b.p;
+        function f(a) {
+            var a = a.p;
             var c;
-            b?.[c = "FAIL 2"];
-            return b || c;
+            a?.[c = "FAIL 2"];
+            return a || c;
         }
         console.log(f("FAIL 1") || "PASS");
     }
     expect_stdout: "PASS"
     node_version: ">=14"
 }
+
+issue_5292_dot: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+        o?.p;
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+        o?.p;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_5292_dot_pure_getters: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+        o?.p;
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+    }
+}
+
+issue_5292_dot_pure_getters_strict: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+        o?.p;
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+        o?.p;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_5292_sub: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        o?.[console.log("bar"), "p"];
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        o?.[console.log("bar"), "p"];
+    }
+    expect_stdout: [
+        "bar",
+        "foo",
+    ]
+    node_version: ">=14"
+}
+
+issue_5292_sub_pure_getters: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        o?.[console.log("bar"), "p"];
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        console.log("bar");
+    }
+}
+
+issue_5292_sub_pure_getters_strict: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        o?.[console.log("bar"), "p"];
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        o?.[console.log("bar"), "p"];
+    }
+    expect_stdout: [
+        "bar",
+        "foo",
+    ]
+    node_version: ">=14"
+}
+
+issue_5856: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        try {
+            var a;
+            a?.p;
+            a.q;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            var a;
+            a?.p;
+            a.q;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}

test/compress/preserve_line.js

@@ -97,10 +97,10 @@ return_5: {
     }
     expect_exact: [
         "_is_selected=function(tags,slug){",
-        "var ref",
+        "var ref;",
         "",
         "",
-        ";return null!=(ref=_.find(tags,{slug:slug}))?ref.selected:void 0};",
+        "return null!=(ref=_.find(tags,{slug:slug}))?ref.selected:void 0};",
     ]
 }
 
@@ -146,10 +146,10 @@ return_7: {
     }
     expect_exact: [
         "_is_selected=function(e,l){",
-        "var n",
+        "var n;",
         "",
         "",
-        ";return null!=(n=_.find(e,{slug:l}))?n.selected:void 0};",
+        "return null!=(n=_.find(e,{slug:l}))?n.selected:void 0};",
     ]
 }
 

test/compress/properties.js

@@ -133,6 +133,7 @@ evaluate_string_length: {
 mangle_properties_1: {
     mangle = {
         properties: {
+            domprops: true,
             keep_quoted: false,
         },
     }
@@ -147,17 +148,18 @@ mangle_properties_1: {
         a["a"] = "bar";
         a.b = "red";
         x = {o: 10};
-        a.r(x.o, a.a);
-        a['r']({b: "blue", a: "baz"});
+        a.run(x.o, a.a);
+        a['run']({b: "blue", a: "baz"});
     }
 }
 
 mangle_properties_2: {
     mangle = {
         properties: {
+            domprops: true,
             reserved: [
                 "value",
-            ]
+            ],
         },
     }
     input: {
@@ -199,6 +201,24 @@ mangle_properties_2: {
     ]
 }
 
+mangle_properties_3: {
+    mangle = {
+        properties: true,
+    }
+    input: {
+        console.log({
+            [(console, "foo")]: "PASS",
+        }.foo);
+    }
+    expect: {
+        console.log({
+            [(console, "o")]: "PASS",
+        }.o);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 mangle_unquoted_properties: {
     options = {
         evaluate: true,
@@ -206,6 +226,8 @@ mangle_unquoted_properties: {
     }
     mangle = {
         properties: {
+            builtins: true,
+            domprops: true,
             keep_quoted: true,
         },
     }
@@ -305,7 +327,9 @@ mangle_debug_suffix_keep_quoted: {
     }
     mangle = {
         properties: {
+            builtins: true,
             debug: "XYZ",
+            domprops: true,
             keep_quoted: true,
             reserved: [],
         },
@@ -351,6 +375,68 @@ mangle_debug_suffix_keep_quoted: {
     }
 }
 
+keep_substituted_property: {
+    options = {
+        evaluate: true,
+        properties: true,
+        reduce_vars: true,
+    }
+    mangle = {
+        properties: {
+            keep_quoted: true,
+        },
+    }
+    input: {
+        var o = { p: [] };
+        function f(b) {
+            return o[b];
+        }
+        function g() {
+            var a = "p";
+            return o[a] === f(a);
+        }
+        console.log(g() ? "PASS" : "FAIL");
+    }
+    expect: {
+        var o = { p: [] };
+        function f(n) {
+            return o[n];
+        }
+        function g() {
+            var n = "p";
+            return o.p === f(n);
+        }
+        console.log(g() ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+keep_substituted_property_quotes: {
+    options = {
+        evaluate: true,
+        properties: true,
+        reduce_vars: true,
+    }
+    beautify = {
+        keep_quoted_props: true,
+    }
+    input: {
+        function f(o) {
+            var a = "p";
+            return o[a];
+        }
+        console.log(f({ p: "PASS" }));
+    }
+    expect: {
+        function f(o) {
+            var a = "p";
+            return o["p"];
+        }
+        console.log(f({ p: "PASS" }));
+    }
+    expect_stdout: "PASS"
+}
+
 first_256_chars_as_properties: {
     beautify = {
         ascii_only: true,
@@ -897,12 +983,15 @@ issue_2256: {
         },
     }
     input: {
-        ({ "keep": 1 });
-        g.keep = g.change;
+        ({ "keep": 42 });
+        global.keep = global.change = "PASS";
+        console.log(keep);
     }
     expect: {
-        g.keep = g.g;
+        global.keep = global.l = "PASS";
+        console.log(keep);
     }
+    expect_stdout: "PASS"
 }
 
 lhs_prop_1: {
@@ -1578,3 +1667,163 @@ issue_5177: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_5682_in_1: {
+    mangle = {
+        properties: true,
+    }
+    input: {
+        function f(a) {
+            return "foo" in a;
+        }
+        var o = {};
+        var p = "foo";
+        o[p] = 42;
+        console.log(f(o) ? "PASS" : "FAIL");
+    }
+    expect: {
+        function f(o) {
+            return "foo" in o;
+        }
+        var o = {};
+        var p = "foo";
+        o[p] = 42;
+        console.log(f(o) ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5682_in_2: {
+    mangle = {
+        properties: true,
+    }
+    input: {
+        function f(a) {
+            return "foo" in a;
+        }
+        var o = { foo: 42 };
+        console.log(f(o) ? "PASS" : "FAIL");
+    }
+    expect: {
+        function f(o) {
+            return "o" in o;
+        }
+        var o = { o: 42 };
+        console.log(f(o) ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5682_dot_1: {
+    mangle = {
+        properties: true,
+    }
+    input: {
+        function f(a) {
+            return a.foo;
+        }
+        var o = {};
+        var p = "foo";
+        o[p] = "PASS";
+        console.log(f(o));
+    }
+    expect: {
+        function f(o) {
+            return o.foo;
+        }
+        var o = {};
+        var p = "foo";
+        o[p] = "PASS";
+        console.log(f(o));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5682_dot_2: {
+    mangle = {
+        properties: true,
+    }
+    input: {
+        function f(a) {
+            return a.foo;
+        }
+        var o = { foo: "PASS" };
+        console.log(f(o));
+    }
+    expect: {
+        function f(o) {
+            return o.o;
+        }
+        var o = { o: "PASS" };
+        console.log(f(o));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5682_dot_2_computed: {
+    mangle = {
+        properties: true,
+    }
+    input: {
+        function f(a) {
+            return a.foo;
+        }
+        var o = { ["foo"]: "PASS" };
+        console.log(f(o));
+    }
+    expect: {
+        function f(o) {
+            return o.o;
+        }
+        var o = { ["o"]: "PASS" };
+        console.log(f(o));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5682_sub_1: {
+    mangle = {
+        properties: true,
+    }
+    input: {
+        function f(a) {
+            return a["foo"];
+        }
+        var o = {};
+        var p = "foo";
+        o[p] = "PASS";
+        console.log(f(o));
+    }
+    expect: {
+        function f(o) {
+            return o["foo"];
+        }
+        var o = {};
+        var p = "foo";
+        o[p] = "PASS";
+        console.log(f(o));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5682_sub_2: {
+    mangle = {
+        properties: true,
+    }
+    input: {
+        function f(a) {
+            return a["foo"];
+        }
+        var o = { foo: "PASS" };
+        console.log(f(o));
+    }
+    expect: {
+        function f(o) {
+            return o["o"];
+        }
+        var o = { o: "PASS" };
+        console.log(f(o));
+    }
+    expect_stdout: "PASS"
+}

test/compress/pure_funcs.js

@@ -147,7 +147,7 @@ relational: {
         "bar" >= "bar";
     }
     expect: {
-        bar();
+        [] instanceof bar();
         bar();
         bar(), bar();
         bar();

test/compress/pure_getters.js

@@ -1289,6 +1289,7 @@ issue_2878: {
         collapse_vars: true,
         pure_getters: true,
         sequences: true,
+        side_effects: true,
     }
     input: {
         var c = 0;
@@ -1363,9 +1364,8 @@ issue_3490_1: {
     }
     expect: {
         var b = 42, c = "FAIL";
-        if (function() {
         var a;
-        }(), c = "PASS", b) while ("" == typeof d);
+        if (c = "PASS", b) while ("" == typeof d);
         console.log(c, b);
     }
     expect_stdout: "PASS 42"
@@ -1540,10 +1540,12 @@ this_toString: {
 issue_4803: {
     options = {
         hoist_vars: true,
+        join_vars: true,
         pure_getters: "strict",
         reduce_vars: true,
         side_effects: true,
         toplevel: true,
+        unused: true,
     }
     input: {
         var o = {
@@ -1685,3 +1687,31 @@ issue_4939: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5856: {
+    options = {
+        pure_getters: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = [ "FAIL", "PASS" ];
+        (function(b) {
+            var c = b[0];
+            b[0] = b[1];
+            b[1] = c;
+        })(a);
+        console.log(a[0]);
+    }
+    expect: {
+        var a = [ "FAIL", "PASS" ];
+        (function(b) {
+            var c = b[0];
+            b[0] = b[1];
+            b[1] = c;
+        })(a);
+        console.log(a[0]);
+    }
+    expect_stdout: "PASS"
+}

test/compress/reduce_vars.js

@@ -6,6 +6,7 @@ reduce_vars: {
             C: 0,
         },
         inline: true,
+        passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
@@ -41,10 +42,8 @@ reduce_vars: {
     }
     expect: {
         var A = 1;
-        (function() {
         console.log(-3);
         console.log(A - 5);
-        })();
         (function f1() {
             var a = 2;
             console.log(a - 5);
@@ -905,7 +904,7 @@ use_before_var: {
     }
     expect: {
         function f(){
-            console.log(void 0);
+            console.log(t);
             var t = 1;
         }
     }
@@ -981,7 +980,7 @@ inner_var_for_1: {
     expect: {
         function f() {
             var a = 1;
-            x(1, void 0, d);
+            x(1, b, d);
             for (var b = 2, c = 3; x(1, 2, 3, d); x(1, 2, 3, d)) {
                 var d = 4, e = 5;
                 x(1, 2, 3, d, e);
@@ -2489,7 +2488,7 @@ side_effects_assign: {
         console.log(a);
     }
     expect: {
-        var a = typeof void (a && a.in);
+        var a = "undefined";
         console.log(a);
     }
     expect_stdout: "undefined"
@@ -2531,7 +2530,8 @@ pure_getters_2: {
         var a = a && a.b;
     }
     expect: {
-        var a = a && a.b;
+        var a;
+        a && a.b;
     }
 }
 
@@ -5425,7 +5425,7 @@ issue_2774: {
             get a() {
                 var b;
                 (b = true) && b.c;
-                b = void 0;
+                void 0;
             }
         }.a);
     }
@@ -6671,6 +6671,7 @@ issues_3267_1: {
         dead_code: true,
         evaluate: true,
         inline: true,
+        negate_iife: true,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -6688,7 +6689,7 @@ issues_3267_1: {
         });
     }
     expect: {
-        !function(i) {
+        !function(x) {
             if (Object())
                 return console.log("PASS");
             throw "FAIL";
@@ -6705,6 +6706,7 @@ issues_3267_2: {
         evaluate: true,
         inline: true,
         keep_fargs: false,
+        negate_iife: true,
         passes: 2,
         reduce_vars: true,
         sequences: true,
@@ -7831,3 +7833,516 @@ issue_5055_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5324: {
+    options = {
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        A = 0;
+        do {
+            var a, b = A;
+            for (a in b)
+                var c = b;
+        } while (function() {
+            var d;
+            console.log(d *= A);
+        }());
+    }
+    expect: {
+        A = 0;
+        do {
+            var a, b = A;
+            for (a in b);
+        } while (b = void 0, void console.log(b *= A));
+    }
+    expect_stdout: "NaN"
+}
+
+issue_5434: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            for (var i = 0; i < 2; i++) {
+                var b = "FAIL";
+                f && f();
+                a = b;
+                var f = function() {
+                    b = "PASS";
+                };
+            }
+            return a;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            for (var i = 0; i < 2; i++) {
+                var b = "FAIL";
+                f && f();
+                a = b;
+                var f = function() {
+                    b = "PASS";
+                };
+            }
+            return a;
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5623: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 0;
+        function f() {
+            var b = a;
+            a = b;
+        }
+        f && f((a++ && a).toString());
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        function f() {
+            var b;
+            a = a;
+        }
+        f((a++ && a).toString());
+        console.log(a);
+    }
+    expect_stdout: "1"
+}
+
+issue_5716_1: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        function f() {
+            var b = [ c, c ], c = function() {
+                return b++ + (a = b);
+            }();
+        }
+        f();
+        console.log(a);
+    }
+    expect: {
+        c = [ c, c ],
+        void (c = ++c);
+        var c;
+        console.log(c);
+    }
+    expect_stdout: "NaN"
+}
+
+issue_5716_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        function f() {
+            var b = [ c, c ], c = function() {
+                return (b += 4) + (a = b += 2);
+            }();
+        }
+        f();
+        console.log(a);
+    }
+    expect: {
+        void (c = c = (c = [ c, c ]) + 4 + 2);
+        var c;
+        console.log(c);
+    }
+    expect_stdout: ",42"
+}
+
+issue_5716_3: {
+    options = {
+        assignments: true,
+        collapse_vars: true,
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        function f() {
+            var b = [ c, c ], c = function() {
+                return (b = b + 4) + (a = b += 2);
+            }();
+        }
+        f();
+        console.log(a);
+    }
+    expect: {
+        void (c = c = (c = [ c, c ]) + 4 + 2);
+        var c;
+        console.log(c);
+    }
+    expect_stdout: ",42"
+}
+
+issue_5716_4: {
+    options = {
+        assignments: true,
+        collapse_vars: true,
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        function f() {
+            var b = [ c, c ], c = function() {
+                return (b = true | b) + (a = b *= 42);
+            }();
+        }
+        f();
+        console.log(a);
+    }
+    expect: {
+        void (c = c = ((c = [ c, c ]) | true) * 42);
+        var c;
+        console.log(c);
+    }
+    expect_stdout: "42"
+}
+
+issue_5716_5: {
+    options = {
+        assignments: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            return 0 || (a = 42 | a);
+            var a = function() {
+                return a;
+            };
+        }());
+    }
+    expect: {
+        console.log(function() {
+            return 0 || (a |= 42);
+            var a = function() {
+                return a;
+            };
+        }());
+    }
+    expect_stdout: "42"
+}
+
+issue_5730_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        L: {
+            var f = function() {
+                console.log(a);
+            };
+        }
+        f();
+        a++;
+    }
+    expect: {
+        var a = "PASS";
+        var f = function() {
+            console.log(a);
+        };
+        f();
+        a++;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5730_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            var f = function() {
+                console.log(a);
+            };
+        } finally {}
+        f();
+        a++;
+    }
+    expect: {
+        var a = "PASS";
+        try {
+            var f = function() {
+                console.log(a);
+            };
+        } finally {}
+        f();
+        a++;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5730_3: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var f, a = "PASS";
+        L: {
+            f = function() {
+                console.log(a);
+            };
+        }
+        f();
+        a++;
+    }
+    expect: {
+        var f, a = "PASS";
+        f = function() {
+            console.log(a);
+        };
+        f();
+        a++;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5777_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            (function(a) {
+                function g() {
+                    h();
+                }
+                g();
+                a = function() {};
+                function h() {
+                    console.log(a);
+                }
+            })("PASS");
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            (function(a) {
+                (function() {
+                    h();
+                })();
+                a = function() {};
+                function h() {
+                    console.log(a);
+                }
+            })("PASS");
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5777_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            (function() {
+                function g() {
+                    h();
+                }
+                g();
+                a = function() {};
+                function h() {
+                    console.log(a);
+                }
+            })();
+        }
+        f("PASS");
+    }
+    expect: {
+        (function(a) {
+            (function() {
+                (function() {
+                    h();
+                })();
+                a = function() {};
+                function h() {
+                    console.log(a);
+                }
+            })();
+        })("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_1666: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var x = 42;
+        {
+            x();
+            function x() {
+                console.log("foo");
+            }
+        }
+        console.log(typeof x);
+    }
+    expect: {
+        var x = 42;
+        {
+            x();
+            function x() {
+                console.log("foo");
+            }
+        }
+        console.log(typeof x);
+    }
+    expect_stdout: true
+}
+
+issue_1666_strict: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var x = 42;
+        {
+            x();
+            function x() {
+                console.log("foo");
+            }
+        }
+        console.log(typeof x);
+    }
+    expect: {
+        "use strict";
+        var x = 42;
+        {
+            x();
+            function x() {
+                console.log("foo");
+            }
+        }
+        console.log(typeof x);
+    }
+    expect_stdout: true
+}
+
+issue_1666_undefined: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var undefined = 42;
+        {
+            undefined();
+            function undefined() {
+                console.log("foo");
+            }
+        }
+        console.log(typeof undefined);
+    }
+    expect: {
+        var undefined = 42;
+        {
+            undefined();
+            function undefined() {
+                console.log("foo");
+            }
+        }
+        console.log(typeof undefined);
+    }
+    expect_stdout: true
+}
+
+issue_1666_undefined_strict: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var undefined = 42;
+        {
+            undefined();
+            function undefined() {
+                console.log("foo");
+            }
+        }
+        console.log(typeof undefined);
+    }
+    expect: {
+        "use strict";
+        var undefined = 42;
+        {
+            undefined();
+            function undefined() {
+                console.log("foo");
+            }
+        }
+        console.log(typeof undefined);
+    }
+    expect_stdout: true
+}

test/compress/regexp.js

@@ -50,6 +50,22 @@ regexp_properties: {
     expect_stdout: "abc true false 0 false"
 }
 
+instanceof_1: {
+    input: {
+        console.log(/foo/ instanceof RegExp);
+    }
+    expect_exact: "console.log(/foo/ instanceof RegExp);"
+    expect_stdout: "true"
+}
+
+instanceof_2: {
+    input: {
+        console.log(42 + /foo/ instanceof Object);
+    }
+    expect_exact: "console.log(42+/foo/ instanceof Object);"
+    expect_stdout: "false"
+}
+
 issue_3434_1: {
     options = {
         evaluate: true,

test/compress/rename.js

@@ -739,3 +739,55 @@ issue_3480_ie8_toplevel: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5787_1: {
+    rename = true
+    input: {
+        console.log(function() {
+            const a = 42;
+            switch (a) {
+              case 42:
+                const a = "PASS";
+                return a;
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            const a = 42;
+            switch (a) {
+              case 42:
+                const a = "PASS";
+                return a;
+            }
+        }());
+    }
+    expect_stdout: true
+}
+
+issue_5787_2: {
+    rename = true
+    input: {
+        console.log(function() {
+            let a = 42;
+            switch (a) {
+              case 42:
+                // Node.js v4 (vm): SyntaxError: Identifier 'a' has already been declared
+                let a = "PASS";
+                return a;
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            let a = 42;
+            switch (a) {
+              case 42:
+                let b = "PASS";
+                return b;
+            }
+        }());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}

test/compress/rests.js

@@ -51,7 +51,7 @@ arrow_destructured_object_1: {
     }
     expect_exact: "var f=({...a})=>a,o=f({PASS:42});for(var k in o)console.log(k,o[k]);"
     expect_stdout: "PASS 42"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 arrow_destructured_object_2: {
@@ -62,7 +62,7 @@ arrow_destructured_object_2: {
     }
     expect_exact: "var f=({FAIL:a,...b})=>b,o=f({PASS:42,FAIL:null});for(var k in o)console.log(k,o[k]);"
     expect_stdout: "PASS 42"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 arrow_destructured_object_3: {
@@ -79,7 +79,7 @@ arrow_destructured_object_3: {
         "2 S",
         "3 S",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 funarg_1: {
@@ -131,7 +131,7 @@ destructured_object_1: {
     }
     expect_exact: 'var{...a}=["FAIL","PASS",42];console.log(a[1],a[2]);'
     expect_stdout: "PASS 42"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 destructured_object_2: {
@@ -141,7 +141,7 @@ destructured_object_2: {
     }
     expect_exact: 'var{0:a,...b}=["FAIL","PASS",42];console.log(b[1],b[2]);'
     expect_stdout: "PASS 42"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 drop_fargs: {
@@ -231,7 +231,7 @@ reduce_destructured_object: {
         console.log(a[0]);
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 retain_destructured_array: {
@@ -270,7 +270,7 @@ retain_destructured_object_1: {
         "1 PASS",
         "2 42",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 retain_destructured_object_2: {
@@ -292,7 +292,7 @@ retain_destructured_object_2: {
         "bar PASS",
         "baz 42",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 retain_funarg_destructured_array_1: {
@@ -344,11 +344,12 @@ retain_funarg_destructured_object_1: {
         console.log((({ ...a }) => a)([ "PASS" ])[0]);
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 retain_funarg_destructured_object_2: {
     options = {
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -359,10 +360,10 @@ retain_funarg_destructured_object_2: {
     expect: {
         console.log(function({ p: a, ... b }) {
             return b;
-        }({ p: "FAIL" }).p || "PASS");
+        }({}).p || "PASS");
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 drop_unused_call_args_1: {
@@ -436,9 +437,9 @@ merge_funarg: {
         })();
     }
     expect: {
-        (function(...b) {
-            var b = b.length;
-            console.log(b);
+        (function(...a) {
+            var a = a.length;
+            console.log(a);
         })();
     }
     expect_stdout: "0"
@@ -456,9 +457,9 @@ merge_funarg_destructured_array: {
         })([]);
     }
     expect: {
-        (function([ ...b ]) {
-            var b = b.length;
-            console.log(b);
+        (function([ ...a ]) {
+            var a = a.length;
+            console.log(a);
         })([]);
     }
     expect_stdout: "0"
@@ -476,13 +477,13 @@ merge_funarg_destructured_object: {
         })([ "PASS" ]);
     }
     expect: {
-        (function({ ...b }) {
-            var b = b[0];
-            console.log(b);
+        (function({ ...a }) {
+            var a = a[0];
+            console.log(a);
         })([ "PASS" ]);
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_arguments: {
@@ -647,7 +648,7 @@ drop_new_function: {
     }
     expect: {
         void ([ ... {
-            [console.log("PASS")]: [].e,
+            [console.log("PASS")]: [][0],
         }] = []);
     }
     expect_stdout: "PASS"
@@ -866,9 +867,9 @@ issue_4575: {
     }
     expect: {
         (function(a) {
-            (function a(...d) {
+            (function(d) {
                 console.log(d.length);
-            })();
+            })([]);
         })();
     }
     expect_stdout: "0"
@@ -992,7 +993,7 @@ issue_5089_1: {
         console.log(o.p);
     }
     expect_stdout: "undefined"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_5089_2: {
@@ -1019,7 +1020,7 @@ issue_5089_2: {
         console.log(o.p);
     }
     expect_stdout: "undefined"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_5100_1: {
@@ -1048,13 +1049,15 @@ issue_5100_1: {
             p: {},
             ...a
         } = [ {
-            p: [ a = 42["q"] ],
+            p: {
+                q: a,
+            } = 42,
             r: "PASS",
         } ][0]);
         console.log(a.r);
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_5100_2: {
@@ -1081,16 +1084,19 @@ issue_5100_2: {
             p: {},
             ...a
         } = [ {
-            p: [ console.log("PASS"), a = 42["q"] ],
+            p: (console.log("PASS"), {
+                q: a,
+            } = 42),
         } ][0]);
     }
     expect_stdout: "PASS"
-    node_version: ">=10"
+    node_version: ">=10.22.0"
 }
 
 issue_5108: {
     options = {
         evaluate: true,
+        keep_fargs: false,
         reduce_vars: true,
         rests: true,
         unsafe: true,
@@ -1102,9 +1108,7 @@ issue_5108: {
         }([ "PASS", "FAIL" ]));
     }
     expect: {
-        console.log(function([]) {
-            return "PASS";
-        }([ "PASS", "FAIL" ]));
+        console.log("PASS");
     }
     expect_stdout: "PASS"
     node_version: ">=6"
@@ -1205,3 +1209,436 @@ issue_5165_2: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_5246_1: {
+    options = {
+        keep_fargs: false,
+        reduce_vars: true,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function([ , ...a ]) {
+            return this && a;
+        }([ , function(){} ])[0]);
+    }
+    expect: {
+        console.log(typeof function() {
+            return this && [ function(){} ];
+        }()[0]);
+    }
+    expect_stdout: "function"
+    node_version: ">=6"
+}
+
+issue_5246_2: {
+    options = {
+        keep_fargs: false,
+        reduce_vars: true,
+        rests: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        A = [ , "PASS", "FAIL" ];
+        var  [ , ...a ] = [ ... A ];
+        console.log(a[0]);
+    }
+    expect: {
+        A = [ , "PASS", "FAIL" ];
+        var  [ , ...a ] = [ ... A ];
+        console.log(a[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5246_3: {
+    options = {
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        (function f(...[ [ a ] ]) {
+            console.log(a);
+        })([ "PASS" ]);
+    }
+    expect: {
+        (function(...[ a ]) {
+            console.log(a);
+        })([ "PASS" ][0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5360: {
+    options = {
+        keep_fargs: false,
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        var a;
+        console.log(function({ p: {}, ...b }) {
+            return b.q;
+        }({
+            p: ~a && ([ a ] = []),
+            q: "PASS",
+        }));
+    }
+    expect: {
+        var a;
+        console.log(function({ p: {}, ...b }) {
+            return b.q;
+        }({
+            p: ~a && ([ a ] = []),
+            q: "PASS",
+        }));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8.3.0"
+}
+
+issue_5370: {
+    options = {
+        dead_code: true,
+        ie: true,
+        unused: true,
+    }
+    input: {
+        console.log(function arguments(...a) {
+            return arguments;
+            try {} catch (e) {
+                var arguments;
+            }
+        }());
+    }
+    expect: {
+        console.log(function arguments(...a) {
+            return arguments;
+            var arguments;
+        }());
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_5391: {
+    options = {
+        evaluate: true,
+        keep_fargs: false,
+        objects: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, b = function f({
+            p: {},
+            ...c
+        }) {
+            while (c.q);
+        }({
+            p: {
+                r: a++,
+                r: 0,
+            }
+        });
+        console.log(a);
+    }
+    expect: {
+        (function({
+            p: {},
+            ...c
+        }) {
+            while (c.q);
+        })({
+            p: 0,
+        });
+        console.log(NaN);
+    }
+    expect_stdout: "NaN"
+    node_version: ">=8.3.0"
+}
+
+issue_5533_1_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(...b) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_1_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(...b) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_2_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(...[ b ]) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_2_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(...[ b ]) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5552_1: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var log = console.log;
+        var a = f, b = log();
+        function f(...[ c = a = "PASS" ]) {}
+        f((a = "FAIL", b));
+        log(a);
+    }
+    expect: {
+        var log = console.log;
+        var a = f, b = log();
+        function f(...[ c = a = "PASS" ]) {}
+        f((a = "FAIL", b));
+        log(a);
+    }
+    expect_stdout: [
+        "",
+        "PASS",
+    ]
+    node_version: ">=6"
+}
+
+issue_5552_2: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var log = console.log;
+        var a = f;
+        function f(...{ [a = "PASS"]: b }) {}
+        f((a = "FAIL", 42));
+        log(a);
+    }
+    expect: {
+        var log = console.log;
+        var a = f;
+        function f(...{ [a = "PASS"]: b }) {}
+        f((a = "FAIL", 42));
+        log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5552_3: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = [ "FAIL", "PASS" ];
+        console.log(function(b, ...[ c = a.pop() ]) {
+            return b;
+        }(a.pop()));
+    }
+    expect: {
+        var a = [ "FAIL", "PASS" ];
+        console.log(function(b, ...[ c = a.pop() ]) {
+            return b;
+        }(a.pop()));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5552_4: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = [ "FAIL", "PASS" ];
+        console.log(function(b, ...{ [a.pop()]: c }) {
+            return b;
+        }(a.pop()));
+    }
+    expect: {
+        var a = [ "FAIL", "PASS" ];
+        console.log(function(b, ...{ [a.pop()]: c }) {
+            return b;
+        }(a.pop()));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5705: {
+    options = {
+        reduce_vars: true,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        (function(...a) {
+            var b = { ...a };
+        })(console.log("PASS"));
+    }
+    expect: {
+        (function() {})(console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8.3.0"
+}

test/compress/sandbox.js

@@ -125,6 +125,7 @@ log_nested: {
 
 timers: {
     options = {
+        evaluate: true,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -132,26 +133,22 @@ timers: {
     input: {
         var count = 0, interval = 1000, duration = 3210;
         var timer = setInterval(function() {
-            console.log(++count);
-        }, interval);
-        setTimeout(function() {
+            if (!count++) setTimeout(function() {
                 clearInterval(timer);
+                console.log(count <= 4 ? "PASS" : "FAIL");
             }, duration);
+        }, interval);
     }
     expect: {
         var count = 0;
         var timer = setInterval(function() {
-            console.log(++count);
-        }, 1000);
-        setTimeout(function() {
+            if (!count++) setTimeout(function() {
                 clearInterval(timer);
+                console.log(count <= 4 ? "PASS" : "FAIL");
             }, 3210);
+        }, 1000);
     }
-    expect_stdout: [
-        "1",
-        "2",
-        "3",
-    ]
+    expect_stdout: "PASS"
     node_version: ">=0.12"
 }
 

test/compress/sequences.js

@@ -289,8 +289,34 @@ iife: {
         typeof function g() {}();
     }
     expect: {
-        x = 42, function a() {}(), function b() {}(), function c() {}(),
-        function d() {}(), function e() {}(), function f() {}(), function g() {}();
+        x = 42,
+        function a() {}(),
+        !function b() {}(),
+        ~function c() {}(),
+        +function d() {}(),
+        -function e() {}(),
+        void function f() {}(),
+        typeof function g() {}();
+    }
+}
+
+iife_drop_side_effect_free: {
+    options = {
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        x = 42;
+        (function a() {})();
+        !function b() {}();
+        ~function c() {}();
+        +function d() {}();
+        -function e() {}();
+        void function f() {}();
+        typeof function g() {}();
+    }
+    expect: {
+        x = 42;
     }
 }
 
@@ -774,7 +800,7 @@ side_effects_cascade_3: {
     }
     expect: {
         function f(a, b) {
-            (b += a) || (b = a) || (b -= a, b ^= a),
+            (b += a) || (b = a) || (b = b - a ^ a),
             a--;
         }
     }
@@ -910,9 +936,7 @@ hoist_decl: {
         var d;
     }
     expect: {
-        var a;
-        w();
-        var b = x(), c, d;
+        var a, b = (w(), x()), c, d;
         for (y(); 0;) z();
     }
 }
@@ -1047,11 +1071,102 @@ call: {
         b.c = function() {
             console.log(this === b ? "bar" : "baz");
         },
+        a,
         b(),
+        a,
         b.c(),
         (a, b.c)(),
+        a,
         b["c"](),
         (a, b["c"])(),
+        a,
+        function() {
+            console.log(this === a);
+        }(),
+        a,
+        new b(),
+        a,
+        new b.c(),
+        a,
+        new b.c(),
+        a,
+        new b["c"](),
+        a,
+        new b["c"](),
+        a,
+        new function() {
+            console.log(this === a);
+        }(),
+        console.log((a, typeof b.c)),
+        console.log((a, typeof b["c"]));
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+        "bar",
+        "baz",
+        "true",
+        "foo",
+        "baz",
+        "baz",
+        "baz",
+        "baz",
+        "false",
+        "function",
+        "function",
+    ]
+}
+
+call_drop_side_effect_free: {
+    options = {
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = function() {
+            return this;
+        }();
+        function b() {
+            console.log("foo");
+        }
+        b.c = function() {
+            console.log(this === b ? "bar" : "baz");
+        };
+        (a, b)();
+        (a, b).c();
+        (a, b.c)();
+        (a, b)["c"]();
+        (a, b["c"])();
+        (a, function() {
+            console.log(this === a);
+        })();
+        new (a, b)();
+        new (a, b).c();
+        new (a, b.c)();
+        new (a, b)["c"]();
+        new (a, b["c"])();
+        new (a, function() {
+            console.log(this === a);
+        })();
+        console.log(typeof (a, b).c);
+        console.log(typeof (a, b)["c"]);
+    }
+    expect: {
+        var a = function() {
+            return this;
+        }();
+        function b() {
+            console.log("foo");
+        }
+        b.c = function() {
+            console.log(this === b ? "bar" : "baz");
+        },
+        b(),
+        b.c(),
+        (0, b.c)(),
+        b["c"](),
+        (0, b["c"])(),
         function() {
             console.log(this === a);
         }(),
@@ -1063,8 +1178,8 @@ call: {
         new function() {
             console.log(this === a);
         }(),
-        console.log((a, typeof b.c)),
-        console.log((a, typeof b["c"]));
+        console.log(typeof b.c),
+        console.log(typeof b["c"]);
     }
     expect_stdout: [
         "foo",
@@ -1099,6 +1214,26 @@ missing_link: {
     expect: {
         var a = 100;
         a,
+        a++ + (0, 1),
+        console.log(a);
+    }
+}
+
+missing_link_drop_side_effect_free: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 100;
+        a;
+        a++ + (0 ? 2 : 1);
+        console.log(a);
+    }
+    expect: {
+        var a = 100;
         a++,
         console.log(a);
     }
@@ -1162,10 +1297,8 @@ issue_3490_1: {
     }
     expect: {
         var b = 42, c = "FAIL";
-        if (function() {
         var a;
-            a && a.p;
-        }(), c = "PASS", b) while ("" == typeof d);
+        if (a && a.p, c = "PASS", b) while ("" == typeof d);
         console.log(c, b);
     }
     expect_stdout: "PASS 42"
@@ -1195,9 +1328,8 @@ issue_3490_2: {
     }
     expect: {
         var b = 42, c = "FAIL";
-        for (function() {
         var a;
-        }(), c = "PASS", b; "" == typeof d;);
+        for (c = "PASS"; "" == typeof d;);
         console.log(c, b);
     }
     expect_stdout: "PASS 42"

test/compress/side_effects.js

@@ -318,6 +318,32 @@ unsafe_string_replace: {
     expect_stdout: "PASS"
 }
 
+unsafe_Object_call: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        var o = {
+            f: function(a) {
+                console.log(a ? this.p : "FAIL 1");
+            },
+            p: "FAIL 2",
+        }, p = "PASS";
+        Object(o.f)(42);
+    }
+    expect: {
+        var o = {
+            f: function(a) {
+                console.log(a ? this.p : "FAIL 1");
+            },
+            p: "FAIL 2",
+        }, p = "PASS";
+        (0, o.f)(42);
+    }
+    expect_stdout: "PASS"
+}
+
 drop_value: {
     options = {
         side_effects: true,
@@ -617,7 +643,7 @@ issue_4730_2: {
     }
     expect: {
         var a;
-        !console.log("PASS") || a && a[a.p];
+        console.log("PASS") && a && a[a.p];
     }
     expect_stdout: "PASS"
 }
@@ -645,3 +671,299 @@ issue_4751: {
     }
     expect_stdout: "PASS"
 }
+
+drop_instanceof: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        42 instanceof function() {};
+        console.log("PASS");
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+drop_instanceof_reference: {
+    options = {
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        function f() {}
+        42 instanceof f;
+        console.log("PASS");
+    }
+    expect: {
+        function f() {}
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+retain_instanceof: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        try {
+            42 instanceof "foo";
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            0 instanceof "foo";
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+drop_access: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {};
+        o.p;
+        try {
+            (function() {
+                o.q;
+            })();
+            console.log("PASS");
+        } catch (e) {
+            console.log("FAIL");
+        }
+    }
+    expect: {
+        var o = {};
+        o.p;
+        try {
+            console.log("PASS");
+        } catch (e) {
+            console.log("FAIL");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+keep_access: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {};
+        o.p;
+        o = null;
+        try {
+            (function() {
+                o.q;
+            })();
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        var o = {};
+        o.p;
+        o = null;
+        try {
+            (function() {
+                o.q;
+            })();
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+keep_access_after_call: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {};
+        o.p;
+        o.q;
+        f();
+        try {
+            o.r;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+        function f() {
+            o = null;
+        }
+    }
+    expect: {
+        var o = {};
+        o.p;
+        f();
+        try {
+            o.r;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+        function f() {
+            o = null;
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5860_drop_1: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        var a = {};
+        a.p;
+        var a;
+        a.q;
+        console.log("PASS");
+    }
+    expect: {
+        var a = {};
+        a.p;
+        var a;
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5860_drop_2: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        a = {};
+        a.p;
+        var a;
+        a.q;
+        console.log("PASS");
+    }
+    expect: {
+        a = {};
+        a.p;
+        var a;
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5860_keep_1: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        var a = {};
+        a.p;
+        a.q;
+        var a = null;
+        try {
+            a.r;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        var a = {};
+        a.p;
+        var a = null;
+        try {
+            a.r;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5860_keep_2: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        a = {};
+        a.p;
+        a.q;
+        var a = null;
+        try {
+            a.r;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        a = {};
+        a.p;
+        var a = null;
+        try {
+            a.r;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5860_keep_3: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        var a = {};
+        a.p;
+        a.q;
+        a = null;
+        try {
+            a.r;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        var a = {};
+        a.p;
+        a = null;
+        try {
+            a.r;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/spreads.js

@@ -1,3 +1,12 @@
+decimal: {
+    input: {
+        console.log({... 0.42});
+    }
+    expect_exact: "console.log({....42});"
+    expect_stdout: "{}"
+    node_version: ">=8.3.0"
+}
+
 collapse_vars_1: {
     options = {
         collapse_vars: true,
@@ -147,7 +156,7 @@ dont_inline: {
     node_version: ">=6"
 }
 
-do_inline: {
+do_inline_1: {
     options = {
         inline: true,
         spreads: true,
@@ -164,6 +173,46 @@ do_inline: {
     node_version: ">=6"
 }
 
+do_inline_2: {
+    options = {
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        (function() {
+            (function() {
+                console.log("PASS");
+            })(..."");
+        })();
+    }
+    expect: {
+        [] = [ ..."" ],
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+do_inline_3: {
+    options = {
+        if_return: true,
+        inline: true,
+    }
+    input: {
+        (function() {
+            (function() {
+                while (console.log("PASS"));
+            })(..."");
+        })();
+    }
+    expect: {
+        var [] = [ ..."" ];
+        while (console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 drop_empty_call_1: {
     options = {
         side_effects: true,
@@ -201,7 +250,29 @@ drop_empty_call_2: {
     node_version: ">=6"
 }
 
-convert_hole: {
+convert_hole_array: {
+    options = {
+        spreads: true,
+    }
+    input: {
+        [ ...[ "PASS", , 42 ] ].forEach(function(a) {
+            console.log(a);
+        });
+    }
+    expect: {
+        [ "PASS", void 0, 42 ].forEach(function(a) {
+            console.log(a);
+        });
+    }
+    expect_stdout: [
+        "PASS",
+        "undefined",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+convert_hole_call: {
     options = {
         spreads: true,
     }
@@ -341,7 +412,7 @@ convert_setter: {
             console.log(k, o[k]);
     }
     expect_stdout: "PASS undefined"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_getter_1: {
@@ -370,7 +441,7 @@ keep_getter_1: {
         });
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_getter_2: {
@@ -399,7 +470,7 @@ keep_getter_2: {
         "foo",
         "bar",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_getter_3: {
@@ -429,7 +500,7 @@ keep_getter_3: {
         });
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_getter_4: {
@@ -460,7 +531,7 @@ keep_getter_4: {
         });
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_accessor: {
@@ -508,7 +579,7 @@ keep_accessor: {
         "q undefined",
         "r null",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 object_key_order_1: {
@@ -538,7 +609,7 @@ object_key_order_1: {
         "a 3",
         "b 2",
     ]
-    node_version: ">=8 <=10"
+    node_version: ">=8.3.0 <=10"
 }
 
 object_key_order_2: {
@@ -568,7 +639,7 @@ object_key_order_2: {
         "a 3",
         "b 2",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 object_key_order_3: {
@@ -598,7 +669,7 @@ object_key_order_3: {
         "a 3",
         "b 2",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 object_key_order_4: {
@@ -628,7 +699,7 @@ object_key_order_4: {
         "a 3",
         "b 2",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 object_spread_array: {
@@ -654,7 +725,7 @@ object_spread_array: {
         "0 foo",
         "1 bar",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 object_spread_string: {
@@ -681,7 +752,7 @@ object_spread_string: {
         "1 o",
         "2 o",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 unused_var_side_effects: {
@@ -711,7 +782,7 @@ unused_var_side_effects: {
         });
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 unsafe_join_1: {
@@ -793,7 +864,7 @@ issue_4329: {
         }[0]);
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4331: {
@@ -871,7 +942,7 @@ issue_4345: {
         }[42]);
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4361: {
@@ -901,7 +972,7 @@ issue_4361: {
         "foo",
         "undefined",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4363: {
@@ -922,7 +993,7 @@ issue_4363: {
         });
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4556: {
@@ -994,7 +1065,7 @@ issue_4849: {
         }()));
     }
     expect_stdout: "object"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4882_1: {
@@ -1026,7 +1097,7 @@ issue_4882_1: {
         "PASS",
         "undefined",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4882_2: {
@@ -1052,7 +1123,7 @@ issue_4882_2: {
         "42",
         "PASS",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4882_3: {
@@ -1082,7 +1153,7 @@ issue_4882_3: {
         "PASS",
         "42",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_5006: {
@@ -1104,3 +1175,102 @@ issue_5006: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_5382: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            f() {
+                ({ ...this });
+            },
+            get p() {
+                console.log("PASS");
+            },
+        }).f();
+    }
+    expect: {
+        ({
+            f() {
+                ({ ...this });
+            },
+            get p() {
+                console.log("PASS");
+            },
+        }).f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8.3.0"
+}
+
+issue_5602: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        if_return: true,
+        inline: true,
+        passes: 2,
+        sequences: true,
+        spreads: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            try {
+                var b = function(c) {
+                    if (c)
+                        return FAIL;
+                    var d = 42;
+                }(...[ null, A = 0 ]);
+            } catch (e) {
+                b();
+            }
+        })();
+        console.log(A);
+    }
+    expect: {
+        (function() {
+            try {
+                var b = void (A = 0);
+            } catch (e) {
+                b();
+            }
+        })(),
+        console.log(A);
+    }
+    expect_stdout: "0"
+    expect_warnings: [
+        "INFO: Dropping unused variable d [test/compress/spreads.js:6,24]",
+        "INFO: Collapsing c [test/compress/spreads.js:4,24]",
+        "INFO: Dropping unused variable c [test/compress/spreads.js:3,33]",
+        "INFO: pass 0: last_count: Infinity, count: 27",
+        "WARN: Condition always false [test/compress/spreads.js:4,20]",
+        "INFO: Collapsing null [test/compress/spreads.js:7,23]",
+        "INFO: Collapsing 0 [test/compress/spreads.js:3,24]",
+        "INFO: pass 1: last_count: 27, count: 22",
+    ]
+    node_version: ">=6"
+}
+
+issue_5850: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = [ ..."FAIL" ];
+        a[0] = "P";
+        a[2] = a[3] = "S";
+        console.log(a.join(""));
+    }
+    expect: {
+        var a = [ ..."FAIL" ];
+        a[0] = "P";
+        a[2] = a[3] = "S";
+        console.log(a.join(""));
+    }
+    node_version: ">=6"
+}

test/compress/switches.js

@@ -1608,3 +1608,83 @@ issue_5012: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5543_1: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (false) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (false) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5543_2: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (42) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (42) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/templates.js

@@ -337,7 +337,7 @@ malformed_evaluate_4: {
         console.log("\\u00b5");
     }
     expect_stdout: "\\u00b5"
-    node_version: ">=8"
+    node_version: ">=8.10.0"
 }
 
 unsafe_evaluate: {
@@ -353,7 +353,7 @@ unsafe_evaluate: {
         console.log("\\uFo");
     }
     expect_stdout: "\\uFo"
-    node_version: ">=8"
+    node_version: ">=8.10.0"
 }
 
 side_effects_1: {

test/compress/transform.js

@@ -127,7 +127,7 @@ if_return: {
                 if (w) {
                     if (y) return;
                 } else if (z) return;
-                return x == y || (x && w(), y && z()), !0;
+                return x != y && (x && w(), y) && z(), !0;
             }
         }
     }

test/compress/typeof.js

@@ -307,7 +307,7 @@ typeof_defined_1: {
     }
     expect: {
         "undefined" == typeof A && A;
-        "undefined" != typeof A || A;
+        "undefined" == typeof A && A;
     }
 }
 
@@ -324,7 +324,7 @@ typeof_defined_2: {
     }
     expect: {
         "function" != typeof A && A;
-        "function" == typeof A || A;
+        "function" != typeof A && A;
     }
 }
 
@@ -355,16 +355,19 @@ typeof_defined_3: {
         "undefined" == typeof A && "undefined" == typeof B && (A, B);
         "undefined" == typeof A && "undefined" != typeof B && A;
         "undefined" != typeof A && "undefined" == typeof B && B;
+        // dropped
         "undefined" == typeof A && "undefined" == typeof B || (A, B);
         "undefined" == typeof A && "undefined" != typeof B || (A, B);
         "undefined" != typeof A && "undefined" == typeof B || (A, B);
         "undefined" != typeof A && "undefined" != typeof B || (A, B);
-        "undefined" == typeof A || "undefined" == typeof B && B;
-        "undefined" != typeof A || "undefined" == typeof B && (A, B);
-        "undefined" != typeof A || "undefined" != typeof B && A;
-        "undefined" == typeof A || "undefined" != typeof B || B;
-        "undefined" != typeof A || "undefined" == typeof B || A;
-        "undefined" != typeof A || "undefined" != typeof B || (A, B);
+        "undefined" != typeof A && "undefined" == typeof B && B;
+        // dropped
+        "undefined" == typeof A && "undefined" == typeof B && (A, B);
+        "undefined" == typeof A && "undefined" != typeof B && A;
+        // dropped
+        "undefined" != typeof A && "undefined" == typeof B && B;
+        "undefined" == typeof A && "undefined" != typeof B && A;
+        "undefined" == typeof A && "undefined" == typeof B && (A, B);
     }
 }
 
@@ -392,6 +395,7 @@ typeof_defined_4: {
         "object" != typeof A || "object" != typeof B || (A, B);
     }
     expect: {
+        // dropped
         "object" == typeof A && "object" != typeof B && B;
         "object" != typeof A && "object" == typeof B && A;
         "object" != typeof A && "object" != typeof B && (A, B);
@@ -399,12 +403,14 @@ typeof_defined_4: {
         "object" == typeof A && "object" != typeof B || (A, B);
         "object" != typeof A && "object" == typeof B || (A, B);
         "object" != typeof A && "object" != typeof B || (A, B);
-        "object" == typeof A || "object" == typeof B && A;
-        "object" == typeof A || "object" != typeof B && (A, B);
-        "object" != typeof A || "object" != typeof B && B;
-        "object" == typeof A || "object" == typeof B || (A, B);
-        "object" == typeof A || "object" != typeof B || A;
-        "object" != typeof A || "object" == typeof B || B;
+        "object" != typeof A && "object" == typeof B && A;
+        "object" != typeof A && "object" != typeof B && (A, B);
+        // dropped
+        "object" == typeof A && "object" != typeof B && B;
+        "object" != typeof A && "object" != typeof B && (A, B);
+        "object" != typeof A && "object" == typeof B && A;
+        "object" == typeof A && "object" != typeof B && B;
+        // dropped
     }
 }
 
@@ -436,6 +442,245 @@ emberjs_global: {
     expect_stdout: Error("PASS")
 }
 
+reassign: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A = void 0;
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A = void 0;
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+reassign_call: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        function f() {
+            A = void 0;
+        }
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            f();
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect: {
+        A = console;
+        function f() {
+            A = void 0;
+        }
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            f();
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+reassign_conditional: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A &&= void 0;
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A &&= void 0;
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+reassign_do: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        if_return: true,
+        passes: 2,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        (function() {
+            if ("undefined" == typeof A)
+                return;
+            var a = A, i = 2;
+            do {
+                console.log(void 0 === A, void 0 === a);
+                A = void 0;
+            } while (--i);
+        })();
+    }
+    expect: {
+        A = console;
+        (function() {
+            if ("undefined" != typeof A) {
+                var a = A, i = 2;
+                do {
+                    console.log(void 0 === A, (a, false));
+                    A = void 0;
+                } while (--i);
+            }
+        })();
+    }
+    expect_stdout: [
+        "false false",
+        "true false",
+    ]
+}
+
+reassign_for: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        typeofs: true,
+    }
+    input: {
+        if (A = console, "undefined" != typeof A)
+            for (var a = A, i = 0; i < 2; i++)
+                console.log(void 0 === A, void 0 === a),
+                A = void 0;
+    }
+    expect: {
+        if (A = console, "undefined" != typeof A)
+            for (var a = A, i = 0; i < 2; i++)
+                console.log(void 0 === A, (a, false)),
+                A = void 0;
+    }
+    expect_stdout: [
+        "false false",
+        "true false",
+    ]
+}
+
+reassign_for_in: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        (A = console) && "undefined" != typeof A && function(a) {
+            for (var k in [ a = A, 42 ]) {
+                console.log(void 0 === A, void 0 === a);
+                A = void 0;
+            }
+        }();
+    }
+    expect: {
+        (A = console) && "undefined" != typeof A && function(a) {
+            for (var k in [ a = A, 42 ]) {
+                console.log(void 0 === A, (a, false));
+                A = void 0;
+            }
+        }();
+    }
+    expect_stdout: [
+        "false false",
+        "true false",
+    ]
+}
+
+reassign_iife: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else (function() {
+            A = void 0;
+        })(console.log(void 0 === A ? "FAIL 2" : "PASS"));
+    }
+    expect: {
+        A = console;
+        "undefined" == typeof A ? console.log("FAIL 1") : function() {
+            A = void 0;
+        }(console.log((A, false) ? "FAIL 2" : "PASS"));
+    }
+    expect_stdout: "PASS"
+}
+
+reassign_property: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A.p = void 0;
+            console.log(void 0 === A ? "FAIL 2" : "PASS");
+        }
+    }
+    expect: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A.p = void 0;
+            console.log((A, false) ? "FAIL 2" : "PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
 issue_3817: {
     options = {
         comparisons: true,

test/compress/unicode.js

@@ -67,7 +67,8 @@ unicode_escaped_identifier_2: {
     }
     expect_exact: 'var a="foo";var \u{10000}="bar";console.log(a,\u{10000});'
     expect_stdout: "foo bar"
-    node_version: ">=4"
+    // non-BMP support is platform-dependent on Node.js v4
+    node_version: ">=6"
 }
 
 unicode_identifier_ascii_only: {
@@ -200,7 +201,8 @@ surrogate_pair: {
     }
     expect_exact: 'var \ud87e\udc00={"\ud87e\udc01":"\udbc0\udc00"};\ud87e\udc00.\ud87e\udc02="\udbc0\udc01";console.log(typeof \ud87e\udc00,\ud87e\udc00.\ud87e\udc01,\ud87e\udc00["\ud87e\udc02"]);'
     expect_stdout: "object \udbc0\udc00 \udbc0\udc01"
-    node_version: ">=4"
+    // non-BMP support is platform-dependent on Node.js v4
+    node_version: ">=6"
 }
 
 surrogate_pair_ascii: {
@@ -216,5 +218,6 @@ surrogate_pair_ascii: {
     }
     expect_exact: 'var \\u{2f800}={"\\ud87e\\udc01":"\\udbc0\\udc00"};\\u{2f800}.\\u{2f802}="\\udbc0\\udc01";console.log(typeof \\u{2f800},\\u{2f800}.\\u{2f801},\\u{2f800}["\\ud87e\\udc02"]);'
     expect_stdout: "object \udbc0\udc00 \udbc0\udc01"
-    node_version: ">=4"
+    // non-BMP support is platform-dependent on Node.js v4
+    node_version: ">=6"
 }

test/compress/varify.js

@@ -13,10 +13,10 @@ reduce_merge_const: {
         console.log(b);
     }
     expect: {
-        var b = console;
-        console.log(typeof b);
-        b = typeof b;
-        console.log(b);
+        var a = console;
+        console.log(typeof a);
+        a = typeof a;
+        console.log(a);
     }
     expect_stdout: [
         "object",
@@ -41,10 +41,10 @@ reduce_merge_let: {
     }
     expect: {
         "use strict";
-        var b = console;
-        console.log(typeof b);
-        b = typeof b;
-        console.log(b);
+        var a = console;
+        console.log(typeof a);
+        a = typeof a;
+        console.log(a);
     }
     expect_stdout: [
         "object",
@@ -111,7 +111,7 @@ hoist_props_const: {
         }
     }
     expect: {
-        var o = 0, o_p = "PASS";
+        var o, o_p = "PASS";
         console.log(o_p);
     }
     expect_stdout: "PASS"
@@ -194,6 +194,43 @@ scope_adjustment_let: {
     node_version: ">=4"
 }
 
+escaped_const: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        const log = console.log;
+        log("PASS");
+    }
+    expect: {
+        var log = console.log;
+        log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+escaped_let: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        let log = console.log;
+        log("PASS");
+    }
+    expect: {
+        "use strict";
+        var log = console.log;
+        log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 issue_4191_const: {
     options = {
         functions: true,
@@ -292,6 +329,42 @@ forin_const_2: {
     node_version: ">=6"
 }
 
+forin_const_3: {
+    options = {
+        module: true,
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        const o = {
+            p: 42,
+            q: "PASS",
+        };
+        for (const k in o)
+            (function f() {
+                console.log(k, o[k]);
+            })();
+    }
+    expect: {
+        "use strict";
+        let o = {
+            p: 42,
+            q: "PASS",
+        };
+        for (let k in o)
+            (function f() {
+                console.log(k, o[k]);
+            })();
+    }
+    expect_stdout: [
+        "p 42",
+        "q PASS",
+    ]
+    node_version: ">=4"
+}
+
 forin_let_1: {
     options = {
         join_vars: true,
@@ -613,3 +686,197 @@ issue_4954: {
     ]
     node_version: ">=4"
 }
+
+issue_5516: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        console.log(typeof function() {
+            {
+                let a;
+            }
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect: {
+        "use strict";
+        console.log(typeof function() {
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect_stdout: "function"
+    node_version: ">=4"
+}
+
+issue_5697_1: {
+    options = {
+        if_return: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        console.log(function() {
+            f();
+            return typeof a;
+            function f() {
+                (function() {
+                    for (var k in { foo: 42 }) {
+                        const a = k;
+                        console.log(a);
+                    }
+                })();
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            (function() {
+                for (var k in { foo: 42 }) {
+                    var a = k;
+                    console.log(a);
+                }
+            })();
+            return typeof a;
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "undefined",
+    ]
+}
+
+issue_5697_2: {
+    options = {
+        if_return: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        console.log(function() {
+            f();
+            return typeof a;
+            function f() {
+                (function() {
+                    for (var k in { foo: 42 }) {
+                        let a = k;
+                        console.log(a);
+                    }
+                })();
+            }
+        }());
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            (function() {
+                for (var k in { foo: 42 }) {
+                    var a = k;
+                    console.log(a);
+                }
+            })();
+            return typeof a;
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_5697_3: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        console.log(function() {
+            f();
+            return typeof a;
+            function f() {
+                (function() {
+                    for (var k in { foo: 42 }) {
+                        const a = k;
+                        console.log(a);
+                    }
+                })();
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            (function() {
+                for (var k in { foo: 42 }) {
+                    var a = k;
+                    console.log(a);
+                }
+            })();
+            return typeof a;
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "undefined",
+    ]
+}
+
+issue_5697_4: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        console.log(function() {
+            f();
+            return typeof a;
+            function f() {
+                (function() {
+                    for (var k in { foo: 42 }) {
+                        let a = k;
+                        console.log(a);
+                    }
+                })();
+            }
+        }());
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            (function() {
+                for (var k in { foo: 42 }) {
+                    var a = k;
+                    console.log(a);
+                }
+            })();
+            return typeof a;
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "undefined",
+    ]
+    node_version: ">=4"
+}

test/compress/webkit.js

@@ -107,3 +107,209 @@ function_name_mangle_ie8: {
     expect_exact: "(function(){console.log(typeof function n(o){})})();"
     expect_stdout: "function"
 }
+
+issue_1753: {
+    mangle = {
+        toplevel: false,
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}
+
+issue_1753_toplevel: {
+    mangle = {
+        toplevel: true,
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect: {
+        "use strict";
+        let l = null;
+        for (let e = 0; e < 1; e++)
+            console.log(e);
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}
+
+issue_5032_await: {
+    options = {
+        merge_vars: true,
+        webkit: false,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var a = log(a), c = a;
+            log(a);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=8"
+}
+
+issue_5032_await_webkit: {
+    options = {
+        merge_vars: true,
+        webkit: true,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=8"
+}
+
+issue_5032_yield: {
+    options = {
+        merge_vars: true,
+        webkit: false,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var a = log(a), c = a;
+            log(a);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=4"
+}
+
+issue_5032_yield_webkit: {
+    options = {
+        merge_vars: true,
+        webkit: true,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=4"
+}
+
+issue_5480: {
+    mangle = {
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        L: for (let a in console.log("PASS"));
+    }
+    expect: {
+        "use strict";
+        o: for (let o in console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/input/issue-3040/expect.js

@@ -38,4 +38,4 @@ var _require = require("bar"), foo = _require.foo;
 var _require2 = require("world"), hello = _require2.hello;
 
 foo.x.apply(foo, _toConsumableArray(foo.y(hello.z)));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImlucHV0LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImNvbnN0IHtmb299ID0gcmVxdWlyZShcImJhclwiKTtcbmNvbnN0IHtoZWxsb30gPSByZXF1aXJlKFwid29ybGRcIik7XG5cbmZvby54KC4uLmZvby55KGhlbGxvLnopKTtcbiJdLCJuYW1lcyI6WyJyZXF1aXJlIiwiZm9vIiwiaGVsbG8iLCJ4IiwiYXBwbHkiLCJfdG9Db25zdW1hYmxlQXJyYXkiLCJ5IiwieiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7ZUFBY0EsUUFBUSxRQUFmQyxNLFNBQUFBOztBLGdCQUNTRCxRQUFRLFVBQWpCRSxRLFVBQUFBOztBQUVQRCxJQUFJRSxFQUFKQyxNQUFBSCxLQUFHSSxtQkFBTUosSUFBSUssRUFBRUosTUFBTUsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImlucHV0LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImNvbnN0IHtmb299ID0gcmVxdWlyZShcImJhclwiKTtcbmNvbnN0IHtoZWxsb30gPSByZXF1aXJlKFwid29ybGRcIik7XG5cbmZvby54KC4uLmZvby55KGhlbGxvLnopKTtcbiJdLCJuYW1lcyI6WyJyZXF1aXJlIiwiZm9vIiwiaGVsbG8iLCJ4IiwiYXBwbHkiLCJfdG9Db25zdW1hYmxlQXJyYXkiLCJ5IiwieiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7ZUFBY0EsUUFBUSxLQUFELEdBQWRDLE0sU0FBQUE7O0EsZ0JBQ1NELFFBQVEsT0FBRCxHQUFoQkUsUSxVQUFBQTs7QUFFUEQsSUFBSUUsRUFBSkMsTUFBQUgsS0FBR0ksbUJBQU1KLElBQUlLLEVBQUVKLE1BQU1LLENBQVosQ0FBTixDQUFBIn0=

test/input/issue-3294/output.js

@@ -1,2 +1,2 @@
 console.log(3);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSxDQUFHIn0=

test/input/issue-505/output.js

@@ -1,5 +1,5 @@
 function test(a){
-"aaaaaaaaaaaaaaaa"
-;a(err,data),a(err,
+"aaaaaaaaaaaaaaaa";
+a(err,data),a(err,
 data)}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsidGVzdCIsImNhbGxiYWNrIiwiZXJyIiwiZGF0YSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsS0FBS0M7O0NBRVZBLEVBQVNDLElBQUtDLE1BQ2RGLEVBQVNDO0FBQUtDIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsidGVzdCIsImNhbGxiYWNrIiwiZXJyIiwiZGF0YSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0E7SEFBS0MsR0FDVjtBQUNBQTtoQkFBU0MsSUFBS0MsSUFBSSxFQUNsQkYsRUFBU0MsSUFBS0MsSUFBSSxDQUN0QiJ9

test/input/issue-520/output.js

@@ -1,2 +1,2 @@
 console.log(3);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSxDQUFHIn0=

test/input/module/expect.js

@@ -0,0 +1 @@
+function n(){return this||arguments[0]+arguments[1]}function o(){return this||arguments[0]+arguments[1]}console.log(n(n(1,3),5)),console.log(o(o(2,4),6));

test/input/module/input.js

@@ -0,0 +1,13 @@
+console.log(function() {
+    function sum(...params) {
+        return this || arguments[0] + arguments[1];
+    }
+    return sum(sum(1, 3), 5);
+}());
+console.log(function() {
+    "use strict";
+    function sum(...params) {
+        return this || arguments[0] + arguments[1];
+    }
+    return sum(sum(2, 4), 6);
+}());