v3.18.0

closes #5834
closes #5835

.github/workflows/build.yml

@@ -9,11 +9,11 @@ jobs:
       fail-fast: false
       matrix:
         options:
+          - '--ie -c'
           - '-mb braces'
-          - '--ie8 -c'
-          - '-mc'
-          - '-p acorn --toplevel -mco spidermonkey'
-          - '--toplevel -mc passes=3,pure_getters,unsafe'
+          - '--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,22 +7,18 @@ jobs:
   test:
     strategy:
       matrix:
-        node: [ '0.8', '0.10', '0.12', '4', '6', '8', '10', '12', '14', 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 ]
-        exclude:
-          - node: '0.8'
-            script: release/benchmark
-          - node: '0.8'
-            script: release/jetstream
     name: ${{ matrix.node }} ${{ matrix.os }} ${{ matrix.script }}
     runs-on: ${{ matrix.os }}
     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).
-    --ie8                       Support non-standard Internet Explorer 8.
-                                Equivalent to setting `ie8: true` in `minify()`
+    --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,7 +516,12 @@ if (result.error) throw result.error;
 - `compress` (default: `{}`) — pass `false` to skip compressing entirely.
   Pass an object to specify custom [compress options](#compress-options).
 
-- `ie8` (default: `false`) — set to `true` to support IE8.
+- `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
@@ -566,7 +589,6 @@ if (result.error) throw result.error;
     },
     nameCache: null, // or specify a name cache object
     toplevel: false,
-    ie8: false,
     warnings: false,
 }
 ```
@@ -625,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
 
@@ -708,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
 
@@ -724,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.
@@ -795,14 +825,14 @@ to be `false` and all symbol names will be omitted.
   variables (`"vars"`) in the top level scope (`false` by default, `true` to drop
   both unreferenced functions and variables)
 
-- `typeofs` (default: `true`) — Transforms `typeof foo == "undefined"` into
-  `foo === void 0`.  Note: recommend to set this value to `false` for IE10 and
-  earlier versions due to known issues.
+- `typeofs` (default: `true`) — compress `typeof` expressions, e.g.
+  `typeof foo == "undefined" → void 0 === foo`
 
 - `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.
@@ -823,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
@@ -863,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
@@ -891,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
@@ -909,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
@@ -1201,6 +1241,17 @@ To allow for better optimizations, the compiler makes various assumptions:
 - Object properties can be added, removed and modified (not prevented with
   `Object.defineProperty()`, `Object.defineProperties()`, `Object.freeze()`,
   `Object.preventExtensions()` or `Object.seal()`).
+- If array destructuring is present, index-like properties in `Array.prototype`
+  have not been overridden:
+  ```javascript
+  Object.prototype[0] = 42;
+  var [ a ] = [];
+  var { 0: b } = {};
+  // 42 undefined
+  console.log([][0], a);
+  // 42 42
+  console.log({}[0], b);
+  ```
 - Earlier versions of JavaScript will throw `SyntaxError` with the following:
   ```javascript
   ({
@@ -1312,10 +1363,8 @@ 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;
-      }
+  class A {
+      static p = await;
   }
   // SyntaxError: Unexpected reserved word
   ```
@@ -1327,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({
@@ -1336,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:
@@ -1354,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).",
-                "  --ie8                                    Support non-standard Internet Explorer 8.",
+                "  --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.",
@@ -110,6 +117,7 @@ function process_option(name, no_value) {
                 "  --source-map [options]                   Enable source map/specify source map options.",
                 "  --timings                                Display operations run time on STDERR.",
                 "  --toplevel                               Compress and/or mangle variables in toplevel scope.",
+                "  --v8                                     Support non-standard Chrome & Node.js.",
                 "  --validate                               Perform validation during AST manipulations.",
                 "  --verbose                                Print diagnostic messages.",
                 "  --warn                                   Print warning messages.",
@@ -145,9 +153,12 @@ function process_option(name, no_value) {
         options[name] = read_value();
         break;
       case "annotations":
+      case "expression":
+      case "ie":
       case "ie8":
       case "timings":
       case "toplevel":
+      case "v8":
       case "validate":
       case "webkit":
         options[name] = true;
@@ -155,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;
@@ -187,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, "{}"));
@@ -224,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;
@@ -264,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"]) {
@@ -278,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();
@@ -290,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);
+        }
+    } : function(chunk) {
         chunks.push(chunk);
-    }).on("end", function() {
+    }).once("end", function() {
         files = { STDIN: chunks.join("") };
         run();
     });
@@ -427,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) {
@@ -477,33 +498,42 @@ 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(/\*|\?/)) {
-        var dir = path.dirname(glob);
-        try {
-            var entries = fs.readdirSync(dir);
-        } catch (ex) {}
-        if (entries) {
-            var pattern = "^" + path.basename(glob)
-                .replace(/[.+^$[\]\\(){}]/g, "\\$&")
-                .replace(/\*/g, "[^/\\\\]*")
-                .replace(/\?/g, "[^/\\\\]") + "$";
-            var mod = process.platform === "win32" ? "i" : "";
-            var rx = new RegExp(pattern, mod);
-            var results = entries.sort().filter(function(name) {
-                return rx.test(name);
-            }).map(function(name) {
-                return path.join(dir, name);
-            });
-            if (results.length) return results;
+function simple_glob(paths) {
+    return paths.reduce(function(paths, glob) {
+        if (/\*|\?/.test(glob)) {
+            var dir = path.dirname(glob);
+            try {
+                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)
+                    .replace(/[.+^$[\]\\(){}]/g, "\\$&")
+                    .replace(/\*/g, "[^/\\\\]*")
+                    .replace(/\?/g, "[^/\\\\]") + "$";
+                var mod = process.platform === "win32" ? "i" : "";
+                var rx = new RegExp(pattern, mod);
+                var results = entries.filter(function(name) {
+                    return rx.test(name);
+                }).sort().map(function(name) {
+                    return path.join(dir, name);
+                });
+                if (results.length) {
+                    [].push.apply(paths, results);
+                    return paths;
+                }
+            }
         }
-    }
-    return [ glob ];
+        paths.push(glob);
+        return paths;
+    }, []);
 }
 
 function read_file(path, default_value) {
@@ -516,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
@@ -556,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/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,16 +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,
@@ -94,19 +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.ie8) set_shorthand("ie8", 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.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", "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,
-                ie8: false,
+                ie: false,
+                keep_fargs: false,
                 keep_fnames: false,
                 properties: false,
                 reserved: [],
@@ -130,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,
@@ -146,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") {
@@ -164,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;
@@ -185,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) {
@@ -201,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;
@@ -556,7 +598,9 @@
             return node;
         },
         ChainExpression: function(M) {
-            return from_moz(M.expression);
+            var node = from_moz(M.expression);
+            node.terminal = true;
+            return node;
         },
     };
 
@@ -597,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");
@@ -634,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 {
@@ -646,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",
@@ -712,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 {
@@ -729,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,
@@ -749,7 +813,6 @@
             type: "TryStatement",
             block: to_moz_block(M),
             handler: to_moz(M.bcatch),
-            guardedHandlers: [],
             finalizer: to_moz(M.bfinally),
         };
     });
@@ -758,7 +821,6 @@
         return {
             type: "CatchClause",
             param: to_moz(M.argname),
-            guard: null,
             body: to_moz_block(M),
         };
     });
@@ -767,6 +829,7 @@
         return {
             type: "ExportNamedDeclaration",
             declaration: to_moz(M.body),
+            specifiers: [],
         };
     });
 
@@ -778,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),
         };
     });
 
@@ -817,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),
         };
     });
 
@@ -868,7 +916,7 @@
 
     def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) {
         var computed = M instanceof AST_Sub;
-        return {
+        var expr = {
             type: "MemberExpression",
             object: to_moz(M.expression),
             computed: computed,
@@ -878,6 +926,10 @@
                 name: M.property,
             },
         };
+        return M.terminal ? {
+            type: "ChainExpression",
+            expression: expr,
+        } : expr;
     });
 
     def_to_moz(AST_Unary, function To_Moz_Unary(M) {
@@ -927,6 +979,8 @@
             type: "Property",
             kind: "init",
             computed: computed,
+            method: false,
+            shorthand: false,
             key: key,
             value: to_moz(M.value),
         };
@@ -963,6 +1017,7 @@
             kind: kind,
             computed: computed,
             method: M instanceof AST_ObjectMethod,
+            shorthand: false,
             key: key,
             value: to_moz(M.value),
         };
@@ -999,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",
@@ -1007,8 +1062,8 @@
             raw: value,
             regex: {
                 pattern: M.value.raw_source,
-                flags: flags
-            }
+                flags: flags,
+            },
         };
     });
 
@@ -1016,8 +1071,8 @@
         var value = M.value;
         return {
             type: "Literal",
-            bigint: value.slice(0, -1),
-            raw: value,
+            bigint: value,
+            raw: value + "n",
         };
     });
 
@@ -1197,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 = [];
@@ -1248,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,8 +55,9 @@ function OutputStream(options) {
         beautify         : false,
         braces           : false,
         comments         : false,
+        extendscript     : false,
         galio            : false,
-        ie8              : false,
+        ie               : false,
         indent_level     : 4,
         indent_start     : 0,
         inline_script    : true,
@@ -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;
     }
 
@@ -193,7 +202,7 @@ function OutputStream(options) {
               case "\t": return "\\t";
               case "\b": return "\\b";
               case "\f": return "\\f";
-              case "\x0B": return options.ie8 ? "\\x0B" : "\\v";
+              case "\x0B": return options.ie ? "\\x0B" : "\\v";
               case "\u2028": return "\\u2028";
               case "\u2029": return "\\u2029";
               case "\ufeff": return "\\ufeff";
@@ -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);
-        line_fixed = true;
-        flush_mappings();
+        if (current_col > options.max_line_len) {
+            insert_newlines(1);
+            line_fixed = true;
+        }
+        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;
-                    }
+                    // reset the semicolon flag, since we didn't print one
+                    // now and might still have to later
+                    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;
@@ -790,35 +784,26 @@ function OutputStream(options) {
         if (p instanceof AST_Unary) return true;
     });
 
-    function lhs_has_optional(node, output) {
-        var p = output.parent();
-        if (p instanceof AST_PropAccess && p.expression === node && is_lhs(p, output.parent(1))) {
-            // ++(foo?.bar).baz
-            // (foo?.()).bar = baz
-            do {
-                if (node.optional) return true;
-                node = node.expression;
-            } while (node.TYPE == "Call" || node instanceof AST_PropAccess);
-        }
+    function need_chain_parens(node, parent) {
+        if (!node.terminal) return false;
+        if (!(parent instanceof AST_Call || parent instanceof AST_PropAccess)) return false;
+        return parent.expression === node;
     }
 
     PARENS(AST_PropAccess, function(output) {
         var node = this;
         var p = output.parent();
-        if (p instanceof AST_New) {
-            if (p.expression !== node) return false;
-            // i.e. new (foo().bar)
-            //
-            // if there's one call into this subtree, then we need
-            // parens around it too, otherwise the call will be
-            // interpreted as passing the arguments to the upper New
-            // expression.
-            do {
-                node = node.expression;
-            } while (node instanceof AST_PropAccess);
-            return node.TYPE == "Call";
-        }
-        return lhs_has_optional(node, output);
+        // i.e. new (foo().bar)
+        //
+        // if there's one call into this subtree, then we need
+        // parens around it too, otherwise the call will be
+        // interpreted as passing the arguments to the upper New
+        // expression.
+        if (p instanceof AST_New && p.expression === node && root_expr(node).TYPE == "Call") return true;
+        // (foo?.bar)()
+        // (foo?.bar).baz
+        // new (foo?.bar)()
+        return need_chain_parens(node, p);
     });
 
     PARENS(AST_Call, function(output) {
@@ -833,7 +818,10 @@ function OutputStream(options) {
             var g = output.parent(1);
             if (g instanceof AST_Assign && g.left === p) return true;
         }
-        return lhs_has_optional(node, output);
+        // (foo?.())()
+        // (foo?.()).bar
+        // new (foo?.())()
+        return need_chain_parens(node, p);
     });
 
     PARENS(AST_New, function(output) {
@@ -889,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);
@@ -968,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) {
@@ -980,7 +970,6 @@ function OutputStream(options) {
     DEFPRINT(AST_Do, function(output) {
         var self = this;
         output.print("do");
-        output.space();
         make_block(self.body, output);
         output.space();
         output.print("while");
@@ -997,7 +986,6 @@ function OutputStream(options) {
         output.with_parens(function() {
             self.condition.print(output);
         });
-        output.space();
         force_statement(self.body, output);
     });
     DEFPRINT(AST_For, function(output) {
@@ -1009,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();
@@ -1027,7 +1015,6 @@ function OutputStream(options) {
                 self.step.print(output);
             }
         });
-        output.space();
         force_statement(self.body, output);
     });
     function print_for_enum(prefix, infix) {
@@ -1042,7 +1029,6 @@ function OutputStream(options) {
                 output.space();
                 self.object.print(output);
             });
-            output.space();
             force_statement(self.body, output);
         };
     }
@@ -1056,7 +1042,6 @@ function OutputStream(options) {
         output.with_parens(function() {
             self.expression.print(output);
         });
-        output.space();
         force_statement(self.body, output);
     });
     DEFPRINT(AST_ExportDeclaration, function(output) {
@@ -1081,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");
@@ -1088,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();
@@ -1100,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);
             }
         }
     });
@@ -1144,7 +1137,7 @@ function OutputStream(options) {
             output.print("from");
             output.space();
         }
-        output.print_string(self.path, self.quote);
+        self.path.print(output);
         output.semicolon();
     });
 
@@ -1163,8 +1156,9 @@ function OutputStream(options) {
         });
     }
     function print_arrow(self, output) {
-        if (self.argnames.length == 1 && self.argnames[0] instanceof AST_SymbolFunarg && !self.rest) {
-            self.argnames[0].print(output);
+        var argname = self.argnames.length == 1 && !self.rest && self.argnames[0];
+        if (argname instanceof AST_SymbolFunarg && argname.name != "yield") {
+            argname.print(output);
         } else {
             print_funargs(self, output);
         }
@@ -1273,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) {
@@ -1295,7 +1294,7 @@ function OutputStream(options) {
     function make_then(self, output) {
         var b = self.body;
         if (output.option("braces") && !(b instanceof AST_Const || b instanceof AST_Let)
-            || output.option("ie8") && b instanceof AST_Do)
+            || output.option("ie") && b instanceof AST_Do)
             return make_block(b, output);
         // The squeezer replaces "block"-s that contain only a single
         // statement with the statement itself; technically, the AST
@@ -1325,16 +1324,16 @@ function OutputStream(options) {
         output.with_parens(function() {
             self.condition.print(output);
         });
-        output.space();
         if (self.alternative) {
             make_then(self, output);
             output.space();
             output.print("else");
-            output.space();
-            if (self.alternative instanceof AST_If)
+            if (self.alternative instanceof AST_If) {
+                output.space();
                 self.alternative.print(output);
-            else
+            } else {
                 force_statement(self.alternative, output);
+            }
         } else {
             force_statement(self.body, output);
         }
@@ -1358,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();
@@ -1414,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);
@@ -1427,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;
@@ -1451,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);
         }
     });
 
@@ -1475,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) {
@@ -1520,11 +1517,12 @@ function OutputStream(options) {
         var expr = self.expression;
         expr.print(output);
         var prop = self.property;
-        if (output.option("ie8") && RESERVED_WORDS[prop]) {
-            output.print(self.optional ? "?.[" : "[");
-            output.add_mapping(self.end);
-            output.print_string(prop);
-            output.print("]");
+        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);
+            });
         } else {
             if (expr instanceof AST_Number && !/[ex.)]/i.test(output.last())) output.print(".");
             output.print(self.optional ? "?." : ".");
@@ -1536,9 +1534,10 @@ function OutputStream(options) {
     DEFPRINT(AST_Sub, function(output) {
         var self = this;
         self.expression.print(output);
-        output.print(self.optional ? "?.[" : "[");
-        self.property.print(output);
-        output.print("]");
+        if (self.optional) output.print("?.");
+        output.with_square(function() {
+            self.property.print(output);
+        });
     });
     DEFPRINT(AST_Spread, function(output) {
         output.print("...");
@@ -1557,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;
@@ -1634,12 +1635,25 @@ function OutputStream(options) {
         var self = this;
         var key = print_property_key(self, output);
         var value = self.value;
-        if (key && value instanceof AST_SymbolDeclaration && key == get_symbol_name(value)) return;
+        if (key) {
+            if (value instanceof AST_DefaultValue) {
+                if (value.name instanceof AST_Symbol && key == get_symbol_name(value.name)) {
+                    output.space();
+                    output.print("=");
+                    output.space();
+                    value.value.print(output);
+                    return;
+                }
+            } else if (value instanceof AST_Symbol) {
+                if (key == get_symbol_name(value)) return;
+            }
+        }
         output.colon();
         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) {
@@ -1659,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;
@@ -1674,7 +1688,7 @@ function OutputStream(options) {
                 prop.print(output);
             });
             output.newline();
-        });
+        }, self.end);
         else print_braced_empty(self, output);
     }
     DEFPRINT(AST_Object, function(output) {
@@ -1683,28 +1697,21 @@ function OutputStream(options) {
 
     function print_property_key(self, output) {
         var key = self.key;
-        if (key instanceof AST_Node) {
-            output.with_square(function() {
-                key.print(output);
-            });
-        } else if (output.option("quote_keys")) {
-            output.print_string(key);
+        if (key instanceof AST_Node) return output.with_square(function() {
+            key.print(output);
+        });
+        var quote = self.start && self.start.quote;
+        if (output.option("quote_keys") || quote && output.option("keep_quoted_props")) {
+            output.print_string(key, quote);
         } else if ("" + +key == key && key >= 0) {
             output.print(make_num(key));
+        } else if (self.private) {
+            output.print_name(key);
+        } else if (RESERVED_WORDS[key] ? !output.option("ie") : is_identifier_string(key)) {
+            output.print_name(key);
+            return key;
         } else {
-            var quote = self.start && self.start.quote;
-            if (self.private) {
-                output.print_name(key);
-            } else if (RESERVED_WORDS[key] ? !output.option("ie8") : is_identifier_string(key)) {
-                if (quote && output.option("keep_quoted_props")) {
-                    output.print_string(key, quote);
-                } else {
-                    output.print_name(key);
-                    return key;
-                }
-            } else {
-                output.print_string(key, quote);
-            }
+            output.print_string(key, quote);
         }
     }
     DEFPRINT(AST_ObjectKeyVal, function(output) {
@@ -1743,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();
@@ -1776,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);
     });
@@ -1825,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) {
@@ -1836,6 +1843,7 @@ function OutputStream(options) {
         } else if (stat instanceof AST_EmptyStatement) {
             output.force_semicolon();
         } else {
+            output.space();
             stat.print(output);
         }
     }
@@ -1874,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));
@@ -1884,6 +1892,7 @@ function OutputStream(options) {
     }
 
     function make_block(stmt, output) {
+        output.space();
         if (stmt instanceof AST_EmptyStatement) {
             print_braced_empty(stmt, output);
         } else if (stmt instanceof AST_BlockStatement) {
@@ -1892,7 +1901,7 @@ function OutputStream(options) {
             output.indent();
             stmt.print(output);
             output.newline();
-        });
+        }, stmt.end);
     }
 
     /* -----[ source map generators ]----- */
@@ -1915,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

@@ -44,10 +44,10 @@
 
 "use strict";
 
-var KEYWORDS = "break case catch class const continue debugger default delete do else extends finally for function if in instanceof let new return switch throw try typeof var void while with";
+var KEYWORDS = "break case catch class const continue debugger default delete do else extends finally for function if in instanceof new return switch throw try typeof var void while with";
 var KEYWORDS_ATOM = "false null true";
 var RESERVED_WORDS = [
-    "abstract async await boolean byte char double enum export final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile yield",
+    "abstract async await boolean byte char double enum export final float goto implements import int interface let long native package private protected public short static super synchronized this throws transient volatile yield",
     KEYWORDS_ATOM,
     KEYWORDS,
 ].join(" ");
@@ -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,15 +240,14 @@ 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 (;;) {
-                var ch = next(true, true);
+                var ch = read();
                 switch (ch) {
                   case "\\":
-                    ch += next(true, true);
+                    ch += read();
                     break;
                   case "`":
                     strings.push(s);
@@ -260,6 +262,11 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
                 }
                 s += ch;
             }
+
+            function read() {
+                var ch = next(true, true);
+                return ch == "\r" ? "\n" : ch;
+            }
         }),
     };
     var prev_was_dot = false;
@@ -387,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) {
@@ -548,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() {
@@ -630,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;
@@ -694,6 +689,7 @@ function parse($TEXT, options) {
         expression     : false,
         filename       : null,
         html5_comments : true,
+        module         : false,
         shebang        : true,
         strict         : false,
         toplevel       : null,
@@ -790,7 +786,7 @@ function parse($TEXT, options) {
         else if (!optional && !can_insert_semicolon()) expect(";");
     }
 
-    function parenthesised() {
+    function parenthesized() {
         expect("(");
         var exp = expression();
         expect(")");
@@ -815,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":
@@ -854,14 +850,23 @@ 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_();
+              case "let":
+                if (is_vardefs()) {
                     next();
-                    return import_();
+                    var node = let_();
+                    semicolon();
+                    return node;
                 }
+                break;
               case "yield":
                 if (S.in_generator) return simple_statement();
                 break;
@@ -919,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":
@@ -947,12 +952,6 @@ function parse($TEXT, options) {
                 next();
                 return if_();
 
-              case "let":
-                next();
-                var node = let_();
-                semicolon();
-                return node;
-
               case "return":
                 if (S.in_function == 0 && !options.bare_returns)
                     croak("'return' outside of function");
@@ -964,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":
@@ -981,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();
@@ -1001,8 +996,8 @@ function parse($TEXT, options) {
                 }
                 next();
                 return new AST_With({
-                    expression : parenthesised(),
-                    body       : statement()
+                    expression : parenthesized(),
+                    body       : statement(),
                 });
             }
         }
@@ -1061,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();
     }
 
@@ -1097,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);
@@ -1116,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", "(")) {
@@ -1186,19 +1193,19 @@ 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("keyword", "let")
+                : is("name", "let") && is_vardefs()
                 ? (next(), let_(true))
                 : is("keyword", "var")
                 ? (next(), var_(true))
                 : expression(true);
             var ctor;
-            if (await) {
+            if (await_token) {
                 expect_token("name", "of");
                 ctor = AST_ForAwaitOf;
             } else if (is("operator", "in")) {
@@ -1308,6 +1315,11 @@ function parse($TEXT, options) {
         }
         if (node instanceof AST_SymbolFunarg) return node;
         if (node instanceof AST_SymbolRef) return new AST_SymbolFunarg(node);
+        if (node instanceof AST_Yield) return new AST_SymbolFunarg({
+            start: node.start,
+            name: "yield",
+            end: node.end,
+        });
         token_error(node.start, "Invalid arrow parameter");
     }
 
@@ -1327,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 {
@@ -1399,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);
@@ -1409,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", "{")) {
@@ -1457,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();
@@ -1484,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;
                 }),
             });
@@ -1535,12 +1554,18 @@ function parse($TEXT, options) {
     }
 
     var export_decl = embed_tokens(function() {
-        if (is("name", "async")) {
+        if (is("name")) switch (S.token.value) {
+          case "async":
             next();
             expect_token("keyword", "function");
             if (!is("operator", "*")) return function_(AST_AsyncDefun);
             next();
             return function_(AST_AsyncGeneratorDefun);
+          case "let":
+            next();
+            var node = let_();
+            semicolon();
+            return node;
         } else if (is("keyword")) switch (S.token.value) {
           case "class":
             next();
@@ -1555,11 +1580,6 @@ function parse($TEXT, options) {
             if (!is("operator", "*")) return function_(AST_Defun);
             next();
             return function_(AST_GeneratorDefun);
-          case "let":
-            next();
-            var node = let_();
-            semicolon();
-            return node;
           case "var":
             next();
             var node = var_();
@@ -1573,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(",");
@@ -1601,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,
         });
     }
 
@@ -1720,6 +1752,11 @@ function parse($TEXT, options) {
         return a;
     }
 
+    function is_vardefs() {
+        var token = peek();
+        return is_token(token, "name") || is_token(token, "punc", "[") || is_token(token, "punc", "{");
+    }
+
     var const_ = function(no_in) {
         return new AST_Const({
             start       : prev(),
@@ -1782,7 +1819,7 @@ function parse($TEXT, options) {
             ret = new AST_BigInt({ value: value });
             break;
           case "string":
-            ret = new AST_String({ value : value, quote : tok.quote });
+            ret = new AST_String({ value: value, quote: tok.quote });
             break;
           case "regexp":
             ret = new AST_RegExp({ value: value });
@@ -1818,10 +1855,7 @@ function parse($TEXT, options) {
         if (is("punc")) {
             switch (start.value) {
               case "`":
-                var tmpl = template(null);
-                tmpl.start = start;
-                tmpl.end = prev();
-                return subscripts(tmpl, allow_calls);
+                return subscripts(template(null), allow_calls);
               case "(":
                 next();
                 if (is("punc", ")")) {
@@ -2133,13 +2167,13 @@ function parse($TEXT, options) {
     }
 
     function strict_verify_symbol(sym) {
-        if (sym.name == "arguments" || sym.name == "eval")
+        if (sym.name == "arguments" || sym.name == "eval" || sym.name == "let")
             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);
@@ -2230,6 +2264,7 @@ function parse($TEXT, options) {
     }
 
     function template(tag) {
+        var start = tag ? tag.start : S.token;
         var read = S.input.context().read_template;
         var strings = [];
         var expressions = [];
@@ -2240,72 +2275,73 @@ function parse($TEXT, options) {
         }
         next();
         return new AST_Template({
+            start: start,
             expressions: expressions,
             strings: strings,
             tag: tag,
+            end: prev(),
         });
     }
 
-    var subscripts = function(expr, allow_calls, optional) {
+    function subscripts(expr, allow_calls) {
         var start = expr.start;
-        if (is("punc", "[")) {
-            next();
-            var prop = expression();
-            expect("]");
-            return subscripts(new AST_Sub({
-                start: start,
-                optional: optional,
-                expression: expr,
-                property: prop,
-                end: prev(),
-            }), allow_calls);
-        }
-        if (allow_calls && is("punc", "(")) {
-            next();
-            var call = new AST_Call({
-                start: start,
-                optional: optional,
-                expression: expr,
-                args: expr_list(")", !options.strict),
-                end: prev(),
-            });
-            return subscripts(call, true);
-        }
-        if (optional || is("punc", ".")) {
-            if (!optional) next();
-            return subscripts(new AST_Dot({
-                start: start,
-                optional: optional,
-                expression: expr,
-                property: as_name(),
-                end: prev(),
-            }), allow_calls);
-        }
-        if (is("punc", "`")) {
-            var tmpl = template(expr);
-            tmpl.start = expr.start;
-            tmpl.end = prev();
-            return subscripts(tmpl, allow_calls);
-        }
-        if (is("operator", "?") && is_token(peek(), "punc", ".")) {
-            next();
-            next();
-            return subscripts(expr, allow_calls, true);
+        var optional = null;
+        while (true) {
+            if (is("operator", "?") && is_token(peek(), "punc", ".")) {
+                next();
+                next();
+                optional = expr;
+            }
+            if (is("punc", "[")) {
+                next();
+                var prop = expression();
+                expect("]");
+                expr = new AST_Sub({
+                    start: start,
+                    optional: optional === expr,
+                    expression: expr,
+                    property: prop,
+                    end: prev(),
+                });
+            } else if (allow_calls && is("punc", "(")) {
+                next();
+                expr = new AST_Call({
+                    start: start,
+                    optional: optional === expr,
+                    expression: expr,
+                    args: expr_list(")", !options.strict),
+                    end: prev(),
+                });
+            } else if (optional === expr || is("punc", ".")) {
+                if (optional !== expr) next();
+                expr = new AST_Dot({
+                    start: start,
+                    optional: optional === expr,
+                    expression: expr,
+                    property: as_name(),
+                    end: prev(),
+                });
+            } else if (is("punc", "`")) {
+                if (optional) croak("Invalid template on optional chain");
+                expr = template(expr);
+            } else {
+                break;
+            }
         }
+        if (optional) expr.terminal = true;
         if (expr instanceof AST_Call && !expr.pure) {
             var start = expr.start;
             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;
                 }
             }
         }
         return expr;
-    };
+    }
 
     function maybe_unary(no_in) {
         var start = S.token;
@@ -2373,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;
     };
@@ -2532,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) {
@@ -118,7 +134,7 @@ function is_lhs(node, parent) {
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     options = defaults(options, {
         cache: null,
-        ie8: false,
+        ie: false,
     });
 
     // pass 1: setup scope chaining and handle definitions
@@ -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.ie8) 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();
@@ -351,10 +372,11 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     self.walk(tw);
 
     // pass 3: fix up any scoping issue with IE8
-    if (options.ie8) self.walk(new TreeWalker(function(node) {
+    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;
-                }
-                scopes.push(scope);
-            } else break;
+            if (member(scope, scopes)) break;
+            names_in_use(scope, options).each(function(marker, name) {
+                names.set(name, marker);
+            });
+            scopes.push(scope);
         } 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;
 }
 
@@ -572,7 +605,8 @@ AST_Symbol.DEFMETHOD("definition", function() {
 function _default_mangler_options(options) {
     options = defaults(options, {
         eval        : false,
-        ie8         : 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; }
@@ -143,9 +139,11 @@ 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;
+    return text.replace(/\{([^{}]+)\}/g, function(str, p) {
+        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.13.10",
+  "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,14 +97,14 @@ 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 }),
         }));
     }
 
     function read_string(stat) {
         if (stat.TYPE == "SimpleStatement") {
             var body = stat.body;
-            switch(body.TYPE) {
+            switch (body.TYPE) {
               case "String":
                 return body.value;
               case "Array":
@@ -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 (node instanceof U.AST_SimpleStatement && node.body instanceof U.AST_String) {
-            return new U.AST_Directive(node.body);
-        } else {
+        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);
+            }
             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"
@@ -556,6 +578,75 @@ reduce_iife_3: {
     node_version: ">=4"
 }
 
+reduce_lambda_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            console.log(a, b);
+        };
+        var a = "foo", b = 42;
+        f();
+        b = "bar";
+        f();
+    }
+    expect: {
+        var f = () => {
+            console.log("foo", b);
+        };
+        var b = 42;
+        f();
+        b = "bar";
+        f();
+    }
+    expect_stdout: [
+        "foo 42",
+        "foo bar",
+    ]
+    node_version: ">=4"
+}
+
+reduce_lambda_2: {
+    options = {
+        evaluate: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function(f, a, b) {
+            f = () => {
+                console.log(a, b);
+            };
+            a = "foo", b = 42;
+            f();
+            b = "bar";
+            f();
+        })();
+    }
+    expect: {
+        (function(f, a, b) {
+            f = () => {
+                console.log("foo", b);
+            };
+            b = 42;
+            f();
+            b = "bar";
+            f();
+        })();
+    }
+    expect_stdout: [
+        "foo 42",
+        "foo bar",
+    ]
+    node_version: ">=4"
+}
+
 single_use_recursive: {
     options = {
         reduce_vars: true,
@@ -577,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,
@@ -815,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 console, +{};
+        })());
+    }
+    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,
@@ -550,6 +629,24 @@ logical_side_effects: {
     node_version: ">=15"
 }
 
+evaluate_lazy_assignment: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 42;
+        console.log(a &&= "PASS");
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
 issue_4815_1: {
     options = {
         evaluate: true,
@@ -615,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"
@@ -746,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,
@@ -406,6 +450,65 @@ conditional_chain: {
     expect_stdout: "PASS"
 }
 
+negated_if: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(a) {
+            if (!a)
+                return a ? "FAIL" : "PASS";
+        }(!console));
+    }
+    expect: {
+        console.log(function(a) {
+            if (!a)
+                return "PASS";
+        }(!console));
+    }
+    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,
@@ -634,3 +737,130 @@ issue_5028_3: {
     }
     expect_stdout: "-1"
 }
+
+issue_5041_1: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        var a = 42;
+        if (a)
+            if ([ a = null ])
+                if (a)
+                    console.log("FAIL");
+                else
+                    console.log("PASS");
+    }
+    expect: {
+        var a = 42;
+        a && [ a = null ] && (a ? console.log("FAIL") : console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5041_2: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (!a)
+            if (a = 42)
+                if (a)
+                    console.log("PASS");
+                else
+                    console.log("FAIL");
+    }
+    expect: {
+        var a;
+        a || (a = 42) && (a ? console.log("PASS") : console.log("FAIL"));
+    }
+    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,
@@ -289,3 +306,18 @@ issue_3689: {
     }
     expect_stdout: "00"
 }
+
+issue_5145: {
+    options = {
+        strings: true,
+    }
+    input: {
+        var a = [];
+        console.log("" + a + ((a[0] = 4) + "2"));
+    }
+    expect: {
+        var a = [];
+        console.log("" + a + (a[0] = 4) + "2");
+    }
+    expect_stdout: "42"
+}

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,
@@ -486,7 +586,7 @@ do_continue: {
 
 catch_ie8_1: {
     options = {
-        ie8: true,
+        ie: true,
         unused: true,
     }
     input: {
@@ -506,7 +606,7 @@ catch_ie8_1: {
 catch_ie8_2: {
     options = {
         dead_code: true,
-        ie8: true,
+        ie: true,
         passes: 2,
         toplevel: true,
         unused: 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;
@@ -727,7 +856,7 @@ issue_4193: {
 
 issue_4195: {
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         console.log(function f(a) {
@@ -838,12 +967,10 @@ issue_4202: {
     expect: {
         {
             const o = {};
-            (function() {
-                function f() {
-                    o.p = 42;
-                }
-                f(f);
-            })();
+            function f() {
+                o.p = 42;
+            }
+            f(f);
             console.log(o.p++);
         }
     }
@@ -1131,7 +1258,7 @@ issue_4225: {
 
 issue_4229: {
     options = {
-        ie8: true,
+        ie: true,
         side_effects: true,
     }
     input: {
@@ -1151,7 +1278,7 @@ issue_4229: {
 
 issue_4231: {
     options = {
-        ie8: true,
+        ie: true,
         side_effects: true,
     }
     input: {
@@ -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);
     }
@@ -1633,3 +1631,102 @@ issue_5030: {
     expect_stdout: "PASS"
     node_version: ">=0.12"
 }
+
+issue_5106_1: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(typeof function(a) {
+            return a = arguments;
+        }("FAIL")[0]);
+    }
+    expect: {
+        console.log(typeof function(a) {
+            return a = arguments;
+        }("FAIL")[0]);
+    }
+    expect_stdout: "object"
+}
+
+issue_5106_2: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        "use strict";
+        console.log(function(a) {
+            return a = arguments;
+        }("PASS")[0]);
+    }
+    expect: {
+        "use strict";
+        console.log(function(a) {
+            return arguments;
+        }("PASS")[0]);
+    }
+    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,
@@ -795,9 +914,9 @@ issue_1656: {
         beautify: true,
     }
     input: {
-        for(var a=0;;);
+        for (var a=0;;);
     }
-    expect_exact: "for (;;) ;"
+    expect_exact: "for (;;);"
 }
 
 issue_1709: {
@@ -1110,7 +1229,7 @@ issue_1838: {
     }
     expect_exact: [
         "function f() {",
-        "    for (a; c; ) ;",
+        "    for (a; c; );",
         "}",
     ]
 }
@@ -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"
 }
@@ -1557,9 +1679,9 @@ issue_2665: {
     }
     expect: {
         var a = 1;
-        !function g() {
+        (function g() {
             a-- && g();
-        }();
+        })();
         console.log(a);
     }
     expect_stdout: "-1"
@@ -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,
@@ -2345,7 +2468,7 @@ function_argument_reference: {
 
 function_parameter_ie8: {
     options = {
-        ie8: true,
+        ie: true,
         reduce_vars: true,
         unused: 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",
@@ -2916,7 +3061,7 @@ issue_4133: {
         console.log(a);
     }
     expect: {
-        var b = 1;
+        var a = 1;
         console.log(0);
     }
     expect_stdout: "0"
@@ -3062,7 +3207,7 @@ issue_4184: {
     expect_stdout: "42"
 }
 
-issue_4235: {
+issue_4235_1: {
     options = {
         inline: true,
         reduce_vars: true,
@@ -3087,6 +3232,31 @@ issue_4235: {
     expect_stdout: "undefined"
 }
 
+issue_4235_2: {
+    options = {
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        (function() {
+            {
+                const f = 0;
+            }
+            (function f() {
+                var f = console.log(f);
+            })();
+        })();
+    }
+    expect: {
+        console.log(void 0);
+    }
+    expect_stdout: "undefined"
+}
+
 issue_4404: {
     options = {
         pure_getters: "strict",
@@ -3219,7 +3389,7 @@ issue_4558_1: {
     expect: {
         var a = 0;
         var b = c >>>= a;
-        var c;
+        var c = 0;
         b && a++,
         console.log(a);
     }
@@ -3229,7 +3399,7 @@ issue_4558_1: {
 issue_4558_2: {
     options = {
         evaluate: true,
-        ie8: true,
+        ie: true,
         reduce_vars: true,
         unused: true,
     }
@@ -3305,6 +3475,7 @@ issue_4806_1: {
 issue_4806_2: {
     options = {
         sequences: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -3378,7 +3549,7 @@ issue_4834: {
     }
     expect: {
         try {
-            void b.p;
+            b.p;
         } catch (e) {
             console.log("PASS");
         }
@@ -3468,3 +3639,178 @@ issue_4912_3: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5079: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        do {
+            (a = 123456).p = a;
+            a.q = null;
+        } while (console.log("PASS"));
+    }
+    expect: {
+        do {
+            0, 0, null;
+        } while (console.log("PASS"));
+    }
+    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

@@ -684,26 +684,47 @@ prototype_function: {
         side_effects: true,
     }
     input: {
-        var a = ({valueOf: 0}) < 1;
-        var b = ({toString: 0}) < 1;
-        var c = ({valueOf: 0}) + "";
-        var d = ({toString: 0}) + "";
-        var e = (({valueOf: 0}) + "")[2];
-        var f = (({toString: 0}) + "")[2];
-        var g = ({valueOf: 0}).valueOf();
-        var h = ({toString: 0}).toString();
+        function v() {
+            return this.valueOf === v ? "PASS" : "FAIL";
+        }
+        console.log(({ valueOf: v }) < 1);
+        console.log(({ valueOf: v }) + "");
+        console.log((( {valueOf: v }) + "")[2]);
+        console.log(({ valueOf: v }).valueOf());
+        function t() {
+            return this.toString === t ? "PASS" : "FAIL";
+        }
+        console.log(({ toString: t }) < 1);
+        console.log(({ toString: t }) + "");
+        console.log((( {toString: t }) + "")[2]);
+        console.log(({ toString: t }).toString());
     }
     expect: {
-        var a = ({valueOf: 0}) < 1;
-        var b = ({toString: 0}) < 1;
-        var c = ({valueOf: 0}) + "";
-        var d = ({toString: 0}) + "";
-        var e = (({valueOf: 0}) + "")[2];
-        var f = (({toString: 0}) + "")[2];
-        var g = 0();
-        var h = 0();
+        function v() {
+            return this.valueOf === v ? "PASS" : "FAIL";
+        }
+        console.log(({ valueOf: v }) < 1);
+        console.log(({ valueOf: v }) + "");
+        console.log((( {valueOf: v }) + "")[2]);
+        console.log(({ valueOf: v }).valueOf());
+        function t() {
+            return this.toString === t ? "PASS" : "FAIL";
+        }
+        console.log(({ toString: t }) < 1);
+        console.log(({ toString: t }) + "");
+        console.log((( {toString: t }) + "")[2]);
+        console.log(({ toString: t }).toString());
     }
-    expect_stdout: true
+    expect_stdout: [
+        "false",
+        "PASS",
+        "S",
+        "PASS",
+        "false",
+        "PASS",
+        "S",
+        "PASS",
+    ]
 }
 
 call_args: {
@@ -724,7 +745,7 @@ call_args: {
     expect: {
         var a = 1;
         console.log(1);
-        +(1, 1);
+        1, 1;
     }
     expect_stdout: true
 }
@@ -748,7 +769,7 @@ call_args_drop_param: {
     }
     expect: {
         console.log(1);
-        +(b, 1);
+        b, 1;
     }
     expect_stdout: true
 }
@@ -867,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,
@@ -2731,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;
         }();
     }
@@ -3182,7 +3235,7 @@ issue_4552: {
     expect_stdout: "NaN"
 }
 
-issue_4886: {
+issue_4886_1: {
     options = {
         evaluate: true,
         unsafe: true,
@@ -3201,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,7 +99,7 @@ issue_4664: {
     expect: {
         (function f() {
             new function(a) {
-                console.log(typeof f, 1073741824, typeof this);
+                console.log(typeof f, 2 ** 30, typeof this);
             }(A = 0);
         })();
     }

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, { foo: a } = 42;
+        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

@@ -217,7 +217,8 @@ name_collision_1: {
         var obj_foo = 1;
         var obj_bar = 2;
         function f() {
-            var obj_foo$0 = 3,
+            var obj,
+                obj_foo$0 = 3,
                 obj_bar = 4,
                 obj_b_r = 5,
                 obj_b_r$0 = 6,
@@ -249,7 +250,8 @@ name_collision_2: {
         console.log(o.p === o.p, o["+"](4), o["-"](5), o__$0, o__$1);
     }
     expect: {
-        var o_p = 1,
+        var o,
+            o_p = 1,
             o__ = function(x) {
                 return x;
             },
@@ -283,7 +285,8 @@ name_collision_3: {
         console.log(o.p === o.p, o["+"](4), o["-"](5));
     }
     expect: {
-        var o_p = 1,
+        var o,
+            o_p = 1,
             o__ = function(x) {
                 return x;
             },
@@ -315,7 +318,7 @@ name_collision_4: {
     }
     expect: {
         console.log(function() {
-            var o_p$0 = 0, o_q = "PASS";
+            var o, o_p$0 = 0, o_q = "PASS";
             return function(o_p) {
                 if (!o_p$0) return o_p;
             }(o_q);
@@ -459,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: {
@@ -481,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: {
@@ -506,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: {
@@ -532,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: {
@@ -768,7 +787,7 @@ issue_3046: {
     expect: {
         console.log(function(a) {
             do {
-                var b_c = a++;
+                var b, b_c = a++;
             } while (b_c && a);
             return a;
         }(0));
@@ -777,6 +796,32 @@ issue_3046: {
 }
 
 issue_3071_1: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        join_vars: true,
+        passes: 3,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var obj = {};
+            obj.one = 1;
+            obj.two = 2;
+            console.log(obj.one, obj.two);
+        })();
+    }
+    expect: {
+        console.log(1, 2);
+    }
+    expect_stdout: "1 2"
+}
+
+issue_3071_1_toplevel: {
     options = {
         evaluate: true,
         hoist_props: true,
@@ -905,7 +950,7 @@ issue_3411: {
     expect: {
         var c = 1;
         !function f() {
-            var o_p = --c && f();
+            var o, o_p = --c && f();
             +{} || console.log("PASS");
         }();
     }
@@ -1016,9 +1061,7 @@ issue_3945_1: {
     expect: {
         function f() {
             o.p;
-            var o = {
-                q: 0,
-            };
+            var o, o_q = 0;
         }
     }
 }
@@ -1037,9 +1080,7 @@ issue_3945_2: {
     }
     expect: {
         console.log(typeof o);
-        var o = {
-            p: 0,
-        };
+        var o, o_p = 0;
     }
     expect_stdout: "undefined"
 }
@@ -1094,3 +1135,108 @@ object_super: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_4985: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = { p: 42 };
+        console.log(function() {
+            a;
+        }());
+    }
+    expect: {
+        var a, a_p = 42;
+        console.log(function() {
+            ({});
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_5182: {
+    options = {
+        hoist_props: true,
+        merge_vars: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = console;
+        log = o.log;
+        o = {
+            p: function(a) {
+                console.log(a ? "PASS" : "FAIL");
+                return a;
+            },
+        };
+        log(o.p(42));
+    }
+    expect: {
+        var o = console;
+        log = o.log;
+        o = function(a) {
+            console.log(a ? "PASS" : "FAIL");
+            return a;
+        };
+        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) {
@@ -135,10 +146,11 @@ issue_2295: {
     }
 }
 
-issue_4487: {
+issue_4487_1: {
     options = {
         functions: true,
         hoist_vars: true,
+        join_vars: true,
         keep_fnames: true,
         reduce_vars: true,
         toplevel: true,
@@ -150,6 +162,32 @@ issue_4487: {
         };
         var b = a();
     }
+    expect: {
+        var a = function f() {
+            var f = console.log(typeof f);
+        };
+        a();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4487_2: {
+    options = {
+        functions: true,
+        hoist_vars: true,
+        join_vars: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f() {
+            var f = console.log(typeof f);
+        };
+        var b = a();
+    }
     expect: {
         function a() {
             var f = console.log(typeof f);
@@ -159,6 +197,31 @@ issue_4487: {
     expect_stdout: "undefined"
 }
 
+issue_4487_3: {
+    options = {
+        functions: true,
+        hoist_vars: true,
+        join_vars: true,
+        keep_fnames: true,
+        passes: 3,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f() {
+            var f = console.log(typeof f);
+        };
+        var b = a();
+    }
+    expect: {
+        (function a() {
+            console.log(typeof void 0);
+        })();
+    }
+    expect_stdout: "undefined"
+}
+
 issue_4489: {
     options = {
         collapse_vars: true,
@@ -175,8 +238,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"
@@ -200,9 +262,7 @@ issue_4517: {
     }
     expect: {
         console.log(function() {
-            var a = 2;
-            A = a;
-            return A + typeof !1;
+            return (A = 2) + typeof !1;
         }());
     }
     expect_stdout: "2boolean"
@@ -213,6 +273,7 @@ issue_4736: {
         collapse_vars: true,
         evaluate: true,
         hoist_vars: true,
+        join_vars: true,
         merge_vars: true,
         reduce_vars: true,
         toplevel: true,
@@ -232,8 +293,8 @@ issue_4736: {
     expect: {
         (function() {
             (function() {
-                0,
-                console.log(1073741824);
+                0;
+                console.log(1 << 30);
             })();
         })();
     }
@@ -244,24 +305,25 @@ issue_4839: {
     options = {
         evaluate: true,
         hoist_vars: true,
+        join_vars: true,
         keep_fargs: false,
         reduce_vars: true,
         toplevel: true,
         unused: true,
     }
     input: {
-        var o = function(a, b) {
+        var log = console.log, o = function(a, b) {
             return b && b;
         }("foo");
         for (var k in o)
             throw "FAIL";
-        console.log("PASS");
+        log("PASS");
     }
     expect: {
-        var k, o = void 0;
-        for (k in o)
+        var k, log = console.log;
+        for (k in void 0)
             throw "FAIL";
-        console.log("PASS");
+        log("PASS");
     }
     expect_stdout: "PASS"
 }
@@ -270,6 +332,7 @@ issue_4859: {
     options = {
         evaluate: true,
         hoist_vars: true,
+        join_vars: true,
         keep_infinity: true,
         merge_vars: true,
         reduce_vars: true,
@@ -287,8 +350,7 @@ issue_4859: {
     }
     expect: {
         (function f(a) {
-            var d = 1 / 0, d = Infinity;
-            console.log(d);
+            console.log(2 + 1 / 0);
             return f;
         })();
     }
@@ -322,9 +384,7 @@ issue_4893_1: {
     expect: {
         try{
             (function f() {
-                var b;
-                b = null;
-                b.p += 42;
+                null.p += 42;
                 f;
             })();
         } catch (e) {
@@ -362,9 +422,9 @@ issue_4893_2: {
     expect: {
         try{
             (function() {
-                var b;
-                b = null;
-                b.p += 42;
+                var a;
+                a = null;
+                a.p += 42;
             })();
         } catch (e) {
             console.log("PASS");
@@ -396,3 +456,348 @@ issue_4898: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5187_1: {
+    options = {
+        hoist_props: true,
+        hoist_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 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;
+            do {
+                b = { 0: a++ };
+            } while (console.log(b[b ^= 0]));
+        })();
+    }
+    expect_stdout: "42"
+}
+
+issue_5195: {
+    options = {
+        hoist_props: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var a;
+            do {
+                var b = { p: a };
+            } while (console.log(b += ""));
+        }
+        f();
+    }
+    expect: {
+        (function() {
+            var a, b;
+            do {
+                b = { p: a };
+            } while (console.log(b += ""));
+        })();
+    }
+    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,
+        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/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

@@ -4,22 +4,21 @@ multiple_functions: {
         if_return: true,
     }
     input: {
-        ( function() {
-            if ( !window ) {
+        (function() {
+            if (!window)
                 return;
-            }
             function f() {}
             function g() {}
-        } )();
+        })();
     }
     expect: {
-        ( function() {
+        (function() {
             // NOTE: other compression steps will reduce this
             // down to just `window`.
-            if ( !window );
+            if (!window);
             function f() {}
             function g() {}
-        } )();
+        })();
     }
 }
 
@@ -29,18 +28,17 @@ single_function: {
         if_return: true,
     }
     input: {
-        ( function() {
-            if ( !window ) {
+        (function() {
+            if (!window)
                 return;
-            }
             function f() {}
-        } )();
+        })();
     }
     expect: {
-        ( function() {
-            if ( !window );
+        (function() {
+            if (!window);
             function f() {}
-        } )();
+        })();
     }
 }
 
@@ -50,28 +48,26 @@ deeply_nested: {
         if_return: true,
     }
     input: {
-        ( function() {
-            if ( !window ) {
+        (function() {
+            if (!window)
                 return;
-            }
             function f() {}
             function g() {}
-            if ( !document ) {
+            if (!document)
                 return;
-            }
             function h() {}
-        } )();
+        })();
     }
     expect: {
-        ( function() {
+        (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() {}
-        } )();
+        })();
     }
 }
 
@@ -81,18 +77,18 @@ not_hoisted_when_already_nested: {
         if_return: true,
     }
     input: {
-        ( function() {
-            if ( !window ) {
+        (function() {
+            if (!window)
                 return;
-            }
-            if ( foo ) function f() {}
-        } )();
+            if (foo) function f() {}
+        })();
     }
     expect: {
-        ( function() {
-            if ( window )
-                if ( foo ) function f() {}
-        } )();
+        (function() {
+            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);
+    }
+    expect: {
+        console.log((a = parseInt("100")) <= a);
+    }
+    expect_stdout: "true"
 }
-tranformation_sort_order_greater_or_equal: {
+
+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-1446.js

@@ -24,7 +24,7 @@ typeof_eq_undefined: {
 typeof_eq_undefined_ie8: {
     options = {
         comparisons: true,
-        ie8: true,
+        ie: true,
         typeofs: true,
     }
     input: {

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-1588.js

@@ -1,9 +1,9 @@
 screw_ie8: {
     options = {
-        ie8: false,
+        ie: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         try { throw "foo"; } catch (x) { console.log(x); }
@@ -16,10 +16,10 @@ screw_ie8: {
 
 support_ie8: {
     options = {
-        ie8: true,
+        ie: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         try { throw "foo"; } catch (x) { console.log(x); }

test/compress/issue-1704.js

@@ -1,10 +1,10 @@
 mangle_catch: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -22,11 +22,11 @@ mangle_catch: {
 
 mangle_catch_ie8: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -44,11 +44,11 @@ mangle_catch_ie8: {
 
 mangle_catch_var: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -66,11 +66,11 @@ mangle_catch_var: {
 
 mangle_catch_var_ie8: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -88,11 +88,11 @@ mangle_catch_var_ie8: {
 
 mangle_catch_toplevel: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -110,11 +110,11 @@ mangle_catch_toplevel: {
 
 mangle_catch_ie8_toplevel: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -132,11 +132,11 @@ mangle_catch_ie8_toplevel: {
 
 mangle_catch_var_toplevel: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -154,11 +154,11 @@ mangle_catch_var_toplevel: {
 
 mangle_catch_var_ie8_toplevel: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -176,11 +176,11 @@ mangle_catch_var_ie8_toplevel: {
 
 mangle_catch_redef_1: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -198,11 +198,11 @@ mangle_catch_redef_1: {
 
 mangle_catch_redef_1_ie8: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -220,11 +220,11 @@ mangle_catch_redef_1_ie8: {
 
 mangle_catch_redef_1_toplevel: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -242,11 +242,11 @@ mangle_catch_redef_1_toplevel: {
 
 mangle_catch_redef_1_ie8_toplevel: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -264,11 +264,11 @@ mangle_catch_redef_1_ie8_toplevel: {
 
 mangle_catch_redef_2: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -285,11 +285,11 @@ mangle_catch_redef_2: {
 
 mangle_catch_redef_2_ie8: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -306,11 +306,11 @@ mangle_catch_redef_2_ie8: {
 
 mangle_catch_redef_2_toplevel: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -327,11 +327,11 @@ mangle_catch_redef_2_toplevel: {
 
 mangle_catch_redef_2_ie8_toplevel: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -348,7 +348,7 @@ mangle_catch_redef_2_ie8_toplevel: {
 
 mangle_catch_redef_3: {
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -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,12 +367,13 @@ 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: {
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -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,12 +392,13 @@ 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: {
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -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,12 +417,13 @@ 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: {
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -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-1733.js

@@ -1,6 +1,6 @@
 function_iife_catch: {
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         function f(n) {
@@ -21,7 +21,7 @@ function_iife_catch: {
 
 function_iife_catch_ie8: {
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         function f(n) {
@@ -42,7 +42,7 @@ function_iife_catch_ie8: {
 
 function_catch_catch: {
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         var o = 0;
@@ -70,7 +70,7 @@ function_catch_catch: {
 
 function_catch_catch_ie8: {
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         var o = 0;

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: 2,
+        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);
+        })(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,17 +1,18 @@
 keep_var_for_in: {
     options = {
         hoist_vars: true,
+        join_vars: true,
         unused: true,
     }
     input: {
-        (function(obj){
+        (function(obj) {
             var foo = 5;
             for (var i in obj)
                 return foo;
         })();
     }
     expect: {
-        (function(obj){
+        (function(obj) {
             var i, foo = 5;
             for (i in obj)
                 return foo;

test/compress/issue-979.js

@@ -1,4 +1,4 @@
-issue979_reported: {
+reported: {
     options = {
         booleans: true,
         comparisons: true,
@@ -17,29 +17,26 @@ 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();
+            1 != a && 2 != b || foo();
         }
         function f2() {
-            1!=a&&2!=b||foo();
+            1 != a && 2 != b || foo();
         }
     }
 }
 
-issue979_test_negated_is_best: {
+test_negated_is_best: {
     options = {
         booleans: true,
         comparisons: true,
@@ -58,53 +55,47 @@ 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();
+            1 == a | 2 == b && foo();
         }
         function f4() {
-            1==a|2==b&&foo();
+            1 == a | 2 == b && foo();
         }
         function f5() {
-            1==a&&2==b&&foo();
+            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 = [("foo", "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,
@@ -489,6 +588,160 @@ join_object_assignments_regex: {
     expect_stdout: "1"
 }
 
+chained_assignments: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var a, b = a = {};
+        b.p = "PASS";
+        console.log(a.p);
+    }
+    expect: {
+        var a, b = a = {
+            p: "PASS",
+        };
+        console.log(a.p);
+    }
+    expect_stdout: "PASS"
+}
+
+folded_assignments_1: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        var a = {};
+        a[a.PASS = 42] = "PASS";
+        console.log(a[42], a.PASS);
+    }
+    expect: {
+        var a = {
+            PASS: 42,
+            42: "PASS",
+        };
+        console.log(a[42], a.PASS);
+    }
+    expect_stdout: "PASS 42"
+}
+
+folded_assignments_2: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = {};
+        a[42] = "FAIL";
+        a[a.PASS = 42] = "PASS";
+        console.log(a[42], a.PASS);
+    }
+    expect: {
+        "use strict";
+        var a = {
+            42: "FAIL",
+            PASS: 42,
+        };
+        a[42] = "PASS";
+        console.log(a[42], a.PASS);
+    }
+    expect_stdout: "PASS 42"
+}
+
+inlined_assignments: {
+    options = {
+        join_vars: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        (a = {}).p = "PASS";
+        console.log(a.p);
+    }
+    expect: {
+        var a = {
+            p: "PASS",
+        };
+        console.log(a.p);
+    }
+    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 = {
+        assignments: true,
+        collapse_vars: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        join_vars: true,
+        passes: 4,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var Enum;
+        (function (Enum) {
+            Enum[Enum.PASS = 42] = "PASS";
+        })(Enum || (Enum = {}));
+        console.log(Enum[42], Enum.PASS);
+    }
+    expect: {
+        console.log("PASS", 42);
+    }
+    expect_stdout: "PASS 42"
+}
+
 issue_2816: {
     options = {
         join_vars: true,
@@ -990,7 +1243,7 @@ conditional_assignments_3: {
     expect_stdout: "PASS"
 }
 
-issue_3856: {
+issue_3856_1: {
     options = {
         booleans: true,
         conditionals: true,
@@ -1015,9 +1268,46 @@ issue_3856: {
         console.log(function() {
             (function() {
                 var a, b;
-                if (a) return a, 1;
-                for (a = 0; !console;);
-                return 0;
+                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;);
             })();
         }());
     }
@@ -1172,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: [
@@ -1183,3 +1470,41 @@ assign_sequence_var: {
         "1 2 3",
     ]
 }
+
+issue_5175: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        function log(f) {
+            console.log(f(), A.p);
+        }
+        log(function() {
+            return (A = {}).p = "PASS";
+        });
+    }
+    expect: {
+        function log(f) {
+            console.log(f(), A.p);
+        }
+        log(function() {
+            return (A = {}).p = "PASS";
+        });
+    }
+    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"
+}

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,
@@ -951,7 +973,7 @@ function_name_mangle_ie8: {
         unused: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -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

@@ -83,8 +83,9 @@ labels_5: {
         conditionals: true,
         dead_code: true,
         if_return: true,
+        unused: true,
     }
-    // should keep the break-s in the following
+    // should keep `break`s below
     input: {
         while (foo) {
             if (bar) break;
@@ -100,8 +101,8 @@ labels_5: {
             if (bar) break;
             console.log("foo");
         }
-        out: while (foo) {
-            if (bar) break out;
+        while (foo) {
+            if (bar) break;
             console.log("foo");
         }
     }
@@ -110,6 +111,7 @@ labels_5: {
 labels_6: {
     options = {
         dead_code: true,
+        unused: true,
     }
     input: {
         out: break out;
@@ -189,23 +191,75 @@ labels_10: {
         conditionals: true,
         dead_code: true,
         if_return: true,
+        unused: true,
     }
     input: {
-        out: while (foo) {
-            x();
-            y();
+        out: while (42) {
+            console.log("PASS");
             break out;
-            z();
-            k();
+            console.log("FAIL");
         }
     };
     expect: {
-        out: while (foo) {
-            x();
-            y();
-            break out;
+        while (42) {
+            console.log("PASS");
+            break;
         }
     }
+    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: {
@@ -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/loops.js

@@ -193,9 +193,9 @@ evaluate: {
         } while (false);
     }
     expect: {
-        for(;;)
+        for (;;)
             a();
-        for(;;)
+        for (;;)
             c();
         d();
     }
@@ -265,7 +265,7 @@ issue_1532_2: {
 issue_186: {
     beautify = {
         beautify: false,
-        ie8: false,
+        ie: false,
     }
     input: {
         var x = 3;
@@ -284,7 +284,7 @@ issue_186: {
 issue_186_ie8: {
     beautify = {
         beautify: false,
-        ie8: true,
+        ie: true,
     }
     input: {
         var x = 3;
@@ -303,7 +303,7 @@ issue_186_ie8: {
 issue_186_beautify: {
     beautify = {
         beautify: true,
-        ie8: false,
+        ie: false,
     }
     input: {
         var x = 3;
@@ -330,7 +330,7 @@ issue_186_beautify: {
 issue_186_beautify_ie8: {
     beautify = {
         beautify: true,
-        ie8: true,
+        ie: true,
     }
     input: {
         var x = 3;
@@ -360,7 +360,7 @@ issue_186_braces: {
     beautify = {
         beautify: false,
         braces: true,
-        ie8: false,
+        ie: false,
     }
     input: {
         var x = 3;
@@ -380,7 +380,7 @@ issue_186_braces_ie8: {
     beautify = {
         beautify: false,
         braces: true,
-        ie8: true,
+        ie: true,
     }
     input: {
         var x = 3;
@@ -400,7 +400,7 @@ issue_186_beautify_braces: {
     beautify = {
         beautify: true,
         braces: true,
-        ie8: false,
+        ie: false,
     }
     input: {
         var x = 3;
@@ -432,7 +432,7 @@ issue_186_beautify_braces_ie8: {
     beautify = {
         beautify: true,
         braces: true,
-        ie8: true,
+        ie: true,
     }
     input: {
         var x = 3;

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(){
+        (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,17 +204,49 @@ negate_iife_5: {
         sequences: true,
     }
     input: {
-        if ((function(){ return t })()) {
+        if (function() {
+            return t;
+        }()) {
             foo(true);
         } else {
             bar(false);
         }
-        (function(){
+        (function() {
             console.log("something");
         })();
     }
     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,10 +262,34 @@ 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,
-        ie8: true,
+        ie: true,
     }
     input: {
         var a;
@@ -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

@@ -58,7 +58,7 @@ assign_parentheses_dot: {
     input: {
         (console?.log).name.p = console.log("PASS");
     }
-    expect_exact: '(console?.log.name).p=console.log("PASS");'
+    expect_exact: '(console?.log).name.p=console.log("PASS");'
     expect_stdout: "PASS"
     node_version: ">=14"
 }
@@ -72,6 +72,26 @@ assign_no_parentheses: {
     node_version: ">=14"
 }
 
+call_parentheses: {
+    input: {
+        (function(o) {
+            console.log(o.f("FAIL"), (o.f)("FAIL"), (0, o.f)(42));
+            console.log(o?.f("FAIL"), (o?.f)("FAIL"), (0, o?.f)(42));
+        })({
+            a: "PASS",
+            f(b) {
+                return this.a || b;
+            },
+        });
+    }
+    expect_exact: '(function(o){console.log(o.f("FAIL"),o.f("FAIL"),(0,o.f)(42));console.log(o?.f("FAIL"),(o?.f)("FAIL"),(0,o?.f)(42))})({a:"PASS",f(b){return this.a||b}});'
+    expect_stdout: [
+        "PASS PASS 42",
+        "PASS PASS 42",
+    ]
+    node_version: ">=14"
+}
+
 unary_parentheses: {
     input: {
         var o = { p: 41 };
@@ -237,6 +257,99 @@ trim_2: {
     node_version: ">=14"
 }
 
+trim_dot_call_1: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+    }
+    input: {
+        console.log(null?.f());
+    }
+    expect: {
+        console.log(void 0);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+trim_dot_call_2: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+        unsafe: true,
+    }
+    input: {
+        try {
+            (null?.p)();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (void 0)();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+trim_dot_call_3: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+        unsafe: true,
+    }
+    input: {
+        try {
+            ({ p: null })?.p();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            null();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+trim_dot_sub: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+    }
+    input: {
+        console.log(null?.p[42]);
+    }
+    expect: {
+        console.log(void 0);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+trim_sub_call_call: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+    }
+    input: {
+        console.log(null?.[42]()());
+    }
+    expect: {
+        console.log(void 0);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
 issue_4906: {
     options = {
         toplevel: true,
@@ -248,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"
@@ -256,7 +371,7 @@ issue_4906: {
 
 issue_4928: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
         unused: true,
     }
@@ -305,3 +420,200 @@ issue_4947_2: {
     expect_stdout: "PASS"
     node_version: ">=14"
 }
+
+issue_5039: {
+    options = {
+        ie: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = a?.[function f() {
+            f;
+            a;
+        }];
+        console.log("PASS");
+    }
+    expect: {
+        var a = a?.[function f() {}];
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_5091: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a) {
+            var b = a.p;
+            var c;
+            b?.[c = "FAIL 2"];
+            return b || c;
+        }
+        console.log(f("FAIL 1") || "PASS");
+    }
+    expect: {
+        function f(a) {
+            var a = a.p;
+            var 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"
+}

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

@@ -17,7 +17,7 @@ dot_properties: {
         properties: true,
     }
     beautify = {
-        ie8: true,
+        ie: true,
     }
     input: {
         a["foo"] = "bar";
@@ -43,7 +43,7 @@ dot_properties_es5: {
         properties: true,
     }
     beautify = {
-        ie8: false,
+        ie: false,
     }
     input: {
         a["foo"] = "bar";
@@ -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: {
@@ -1463,3 +1552,278 @@ issue_4888: {
     }
     expect_stdout: "object"
 }
+
+issue_5093: {
+    beautify = {
+        keep_quoted_props: true,
+    }
+    input: {
+        console.log({
+            a: true,
+            '42': "PASS",
+            "null": [],
+        }[6 * 7]);
+    }
+    expect_exact: 'console.log({a:true,"42":"PASS","null":[]}[6*7]);'
+    expect_stdout: "PASS"
+}
+
+issue_5093_quote_keys: {
+    beautify = {
+        keep_quoted_props: true,
+        quote_keys: true,
+    }
+    input: {
+        console.log({
+            a: true,
+            '42': "PASS",
+            "null": [],
+        }[6 * 7]);
+    }
+    expect_exact: 'console.log({"a":true,"42":"PASS","null":[]}[6*7]);'
+    expect_stdout: "PASS"
+}
+
+issue_5093_quote_style: {
+    beautify = {
+        keep_quoted_props: true,
+        quote_style: 3,
+    }
+    input: {
+        console.log({
+            a: true,
+            '42': "PASS",
+            "null": [],
+        }[6 * 7]);
+    }
+    expect_exact: 'console.log({a:true,\'42\':"PASS","null":[]}[6*7]);'
+    expect_stdout: "PASS"
+}
+
+object_methods: {
+    options = {
+        properties: true,
+    }
+    input: {
+        ({
+            p() {
+                console.log("FAIL 1");
+            },
+            *q() {
+                console.log("FAIL 2");
+            },
+            async r() {
+                console.log("FAIL 3");
+            },
+            async *s() {
+                console.log("PASS");
+            },
+        }).s().next();
+    }
+    expect: {
+        [
+            () => {
+                console.log("FAIL 1");
+            },
+            function*() {
+                console.log("FAIL 2");
+            },
+            async () => {
+                console.log("FAIL 3");
+            },
+            async function*() {
+                console.log("PASS");
+            },
+        ][3]().next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=10"
+}
+
+issue_5177: {
+    options = {
+        properties: true,
+    }
+    input: {
+        var a = "FAIL";
+        var o = { a: "PASS" };
+        o.p = {
+            q() {
+                return this.a;
+            },
+        }.q;
+        console.log(o.p());
+    }
+    expect: {
+        var a = "FAIL";
+        var o = { a: "PASS" };
+        o.p = {
+            q() {
+                return this.a;
+            },
+        }.q;
+        console.log(o.p());
+    }
+    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;
@@ -1320,6 +1321,7 @@ issue_2878: {
 
 issue_3427: {
     options = {
+        assignments: true,
         evaluate: true,
         inline: true,
         pure_getters: "strict",
@@ -1362,9 +1364,8 @@ issue_3490_1: {
     }
     expect: {
         var b = 42, c = "FAIL";
-        if (function() {
-            var a;
-        }(), c = "PASS", b) while ("" == typeof d);
+        var a;
+        if (c = "PASS", b) while ("" == typeof d);
         console.log(c, b);
     }
     expect_stdout: "PASS 42"
@@ -1539,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 = {
@@ -1639,6 +1642,26 @@ nested_property_assignments_3: {
     expect_stdout: "PASS"
 }
 
+nested_property_assignments_4: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var n, o = { p: { q: { r: "PASS" } } };
+        (n = o.p).r = n.q.r;
+        console.log(o.p.r);
+    }
+    expect: {
+        var n, o = { p: { q: { r: "PASS" } } };
+        (n = o.p).r = n.q.r;
+        console.log(o.p.r);
+    }
+    expect_stdout: "PASS"
+}
+
 issue_4939: {
     options = {
         pure_getters: "strict",

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);
-        })();
+        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);
@@ -1292,6 +1291,7 @@ toplevel_on_loops_3: {
         loops: true,
         reduce_funcs: true,
         reduce_vars: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -2488,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"
@@ -2530,7 +2530,8 @@ pure_getters_2: {
         var a = a && a.b;
     }
     expect: {
-        var a = a && a.b;
+        var a;
+        a && a.b;
     }
 }
 
@@ -3092,7 +3093,7 @@ accessor_1: {
                 a = 2;
                 return a;
             },
-            b: 1
+            b: 1,
         }.b, a);
     }
     expect: {
@@ -3102,7 +3103,7 @@ accessor_1: {
                 a = 2;
                 return a;
             },
-            b: 1
+            b: 1,
         }.b, a);
     }
     expect_stdout: "1 1"
@@ -3122,7 +3123,7 @@ accessor_2: {
         var B = {
             get c() {
                 console.log(A);
-            }
+            },
         };
         B.c;
     }
@@ -3130,7 +3131,7 @@ accessor_2: {
         ({
             get c() {
                 console.log(1);
-            }
+            },
         }).c;
     }
     expect_stdout: "1"
@@ -3176,7 +3177,7 @@ obj_var_1: {
         var obj = {
             bar: function() {
                 return C + C;
-            }
+            },
         };
         console.log(obj.bar());
     }
@@ -3184,7 +3185,7 @@ obj_var_1: {
         console.log({
             bar: function() {
                 return 2;
-            }
+            },
         }.bar());
     }
     expect_stdout: "2"
@@ -3208,7 +3209,7 @@ obj_var_2: {
         var obj = {
             bar: function() {
                 return C + C;
-            }
+            },
         };
         console.log(obj.bar());
     }
@@ -4422,6 +4423,7 @@ perf_2: {
 
 perf_3: {
     options = {
+        passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
@@ -4430,10 +4432,10 @@ perf_3: {
     input: {
         var foo = function(x, y, z) {
             return x < y ? x * y + z : x * z - y;
-        }
+        };
         var indirect_foo = function(x, y, z) {
             return foo(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -4462,10 +4464,10 @@ perf_4: {
     input: {
         var foo = function(x, y, z) {
             return x < y ? x * y + z : x * z - y;
-        }
+        };
         var indirect_foo = function(x, y, z) {
             return foo(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -4474,10 +4476,10 @@ perf_4: {
     expect: {
         var foo = function(x, y, z) {
             return x < y ? x * y + z : x * z - y;
-        }
+        };
         var indirect_foo = function(x, y, z) {
             return foo(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -4566,9 +4568,9 @@ perf_7: {
         var indirect_foo = function(x, y, z) {
             var foo = function(x, y, z) {
                 return x < y ? x * y + z : x * z - y;
-            }
+            };
             return foo(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -4598,9 +4600,9 @@ perf_8: {
         var indirect_foo = function(x, y, z) {
             var foo = function(x, y, z) {
                 return x < y ? x * y + z : x * z - y;
-            }
+            };
             return foo(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -4611,7 +4613,7 @@ perf_8: {
             return function(x, y, z) {
                 return x < y ? x * y + z : x * z - y;
             }(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -5423,7 +5425,7 @@ issue_2774: {
             get a() {
                 var b;
                 (b = true) && b.c;
-                b = void 0;
+                void 0;
             }
         }.a);
     }
@@ -6669,6 +6671,7 @@ issues_3267_1: {
         dead_code: true,
         evaluate: true,
         inline: true,
+        negate_iife: true,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -6686,7 +6689,7 @@ issues_3267_1: {
         });
     }
     expect: {
-        !function(i) {
+        !function(x) {
             if (Object())
                 return console.log("PASS");
             throw "FAIL";
@@ -6703,6 +6706,7 @@ issues_3267_2: {
         evaluate: true,
         inline: true,
         keep_fargs: false,
+        negate_iife: true,
         passes: 2,
         reduce_vars: true,
         sequences: true,
@@ -7318,6 +7322,64 @@ local_assignment_loop: {
     expect_stdout: "PASS"
 }
 
+local_assignment_modified: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a;
+        (a = a || {}).p = 42;
+        console.log(a.p);
+    }
+    expect: {
+        var a;
+        (a = {}).p = 42;
+        console.log(a.p);
+    }
+    expect_stdout: "42"
+}
+
+local_declaration: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a;
+        a || console.log(a = "PASS");
+    }
+    expect: {
+        var a;
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+local_definition_modified: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = a || {};
+        a.p = 42;
+        console.log(a.p);
+    }
+    expect: {
+        var a = {};
+        a.p = 42;
+        console.log(a.p);
+    }
+    expect_stdout: "42"
+}
+
 issue_3957_1: {
     options = {
         evaluate: true,
@@ -7433,6 +7495,7 @@ issue_4030: {
         collapse_vars: true,
         evaluate: true,
         reduce_vars: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -7676,3 +7739,610 @@ issue_4949: {
     }
     expect_stdout: "0 1"
 }
+
+issue_5048: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = function() {
+                return a + 42;
+            };
+        }());
+    }
+    expect: {
+        console.log(function() {}());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_5050: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        function f() {
+            console.log(a);
+        }
+        this;
+        var a = 1;
+        f(console.log(2), f(), a = 3);
+    }
+    expect: {
+        function f() {
+            console.log(a);
+        }
+        this;
+        var a = 1;
+        f(console.log(2), f(), a = 3);
+    }
+    expect_stdout: [
+        "2",
+        "1",
+        "3",
+    ]
+}
+
+issue_5055_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        function f() {
+            console.log(a || "FAIL");
+        }
+        f(0 && (a = 0)(f(this)));
+    }
+    expect: {
+        var a = "PASS";
+        function f() {
+            console.log(a || "FAIL");
+        }
+        f(0);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5055_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        function f() {
+            console.log(a || "FAIL");
+        }
+        f(0 && (a = 0)(f(this)));
+    }
+    expect: {
+        var a = "PASS";
+        function f() {
+            console.log(a || "FAIL");
+        }
+        f(0 && (a = 0)(f()));
+    }
+    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

@@ -1,11 +1,11 @@
 mangle_catch: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -24,11 +24,11 @@ mangle_catch: {
 mangle_catch_ie8: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -47,11 +47,11 @@ mangle_catch_ie8: {
 mangle_catch_var: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -70,11 +70,11 @@ mangle_catch_var: {
 mangle_catch_var_ie8: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -93,11 +93,11 @@ mangle_catch_var_ie8: {
 mangle_catch_toplevel: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -116,11 +116,11 @@ mangle_catch_toplevel: {
 mangle_catch_ie8_toplevel: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -139,11 +139,11 @@ mangle_catch_ie8_toplevel: {
 mangle_catch_var_toplevel: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -162,11 +162,11 @@ mangle_catch_var_toplevel: {
 mangle_catch_var_ie8_toplevel: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -185,11 +185,11 @@ mangle_catch_var_ie8_toplevel: {
 mangle_catch_redef_1: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -208,11 +208,11 @@ mangle_catch_redef_1: {
 mangle_catch_redef_1_ie8: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -231,11 +231,11 @@ mangle_catch_redef_1_ie8: {
 mangle_catch_redef_1_toplevel: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -254,11 +254,11 @@ mangle_catch_redef_1_toplevel: {
 mangle_catch_redef_1_ie8_toplevel: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -277,11 +277,11 @@ mangle_catch_redef_1_ie8_toplevel: {
 mangle_catch_redef_2: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -299,11 +299,11 @@ mangle_catch_redef_2: {
 mangle_catch_redef_2_ie8: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -321,11 +321,11 @@ mangle_catch_redef_2_ie8: {
 mangle_catch_redef_2_toplevel: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -343,11 +343,11 @@ mangle_catch_redef_2_toplevel: {
 mangle_catch_redef_2_ie8_toplevel: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -365,7 +365,7 @@ mangle_catch_redef_2_ie8_toplevel: {
 issue_2120_1: {
     rename = true
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         "aaaaaaaa";
@@ -401,7 +401,7 @@ issue_2120_1: {
 issue_2120_2: {
     rename = true
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         "aaaaaaaa";
@@ -436,7 +436,7 @@ issue_2120_2: {
 function_iife_catch: {
     rename = true
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         function f(n) {
@@ -458,7 +458,7 @@ function_iife_catch: {
 function_iife_catch_ie8: {
     rename = true
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         function f(n) {
@@ -480,7 +480,7 @@ function_iife_catch_ie8: {
 function_catch_catch: {
     rename = true
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         var o = 0;
@@ -509,7 +509,7 @@ function_catch_catch: {
 function_catch_catch_ie8: {
     rename = true
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         var o = 0;
@@ -538,12 +538,12 @@ function_catch_catch_ie8: {
 function_do_catch_ie8: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         side_effects: true,
         unused: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -615,7 +615,7 @@ function_do_catch_ie8: {
 issue_3480: {
     rename = true,
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -647,7 +647,7 @@ issue_3480: {
 issue_3480_ie8: {
     rename = true,
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -679,7 +679,7 @@ issue_3480_ie8: {
 issue_3480_toplevel: {
     rename = true,
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -711,7 +711,7 @@ issue_3480_toplevel: {
 issue_3480_ie8_toplevel: {
     rename = true,
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -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/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);
+            if (!count++) setTimeout(function() {
+                clearInterval(timer);
+                console.log(count <= 4 ? "PASS" : "FAIL");
+            }, duration);
         }, interval);
-        setTimeout(function() {
-            clearInterval(timer);
-        }, duration);
     }
     expect: {
         var count = 0;
         var timer = setInterval(function() {
-            console.log(++count);
+            if (!count++) setTimeout(function() {
+                clearInterval(timer);
+                console.log(count <= 4 ? "PASS" : "FAIL");
+            }, 3210);
         }, 1000);
-        setTimeout(function() {
-            clearInterval(timer);
-        }, 3210);
     }
-    expect_stdout: [
-        "1",
-        "2",
-        "3",
-    ]
+    expect_stdout: "PASS"
     node_version: ">=0.12"
 }
 
@@ -201,3 +198,20 @@ issue_4811_2: {
     expect_stdout: "PASS [object global] true"
     node_version: ">=8"
 }
+
+issue_5197: {
+    rename = true
+    input: {
+        function f(async) {
+            async(")=>{}");
+        }
+        console.log("" + this.__proto__);
+    }
+    expect: {
+        function f(a) {
+            a(")=>{}");
+        }
+        console.log("" + this.__proto__);
+    }
+    expect_stdout: "[object global]"
+}

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);
+        var a;
+        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;);
+        var a;
+        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,56 @@ 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"
+}

test/compress/spreads.js

@@ -1,15 +1,24 @@
+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,
     }
     input: {
         var a;
-        [ ...a = "PASS", "PASS"].slice();
+        [ ...a = "PASS", "PASS" ].slice();
         console.log(a);
     }
     expect: {
         var a;
-        [ ...a = "PASS", "PASS"].slice();
+        [ ...a = "PASS", "PASS" ].slice();
         console.log(a);
     }
     expect_stdout: "PASS"
@@ -24,7 +33,7 @@ collapse_vars_2: {
         var a = "FAIL";
         try {
             a = "PASS";
-            [ ...42, "PASS"].slice();
+            [ ...42, "PASS" ].slice();
         } catch (e) {
             console.log(a);
         }
@@ -33,7 +42,7 @@ collapse_vars_2: {
         var a = "FAIL";
         try {
             a = "PASS";
-            [ ...42, "PASS"].slice();
+            [ ...42, "PASS" ].slice();
         } catch (e) {
             console.log(a);
         }
@@ -49,7 +58,7 @@ collapse_vars_3: {
     input: {
         var a = "FAIL";
         try {
-            [ ...(a = "PASS", 42), "PASS"].slice();
+            [ ...(a = "PASS", 42), "PASS" ].slice();
         } catch (e) {
             console.log(a);
         }
@@ -57,7 +66,7 @@ collapse_vars_3: {
     expect: {
         var a = "FAIL";
         try {
-            [ ...(a = "PASS", 42), "PASS"].slice();
+            [ ...(a = "PASS", 42), "PASS" ].slice();
         } catch (e) {
             console.log(a);
         }
@@ -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: {
@@ -945,78 +1016,6 @@ issue_4556: {
     node_version: ">=6"
 }
 
-issue_4560_1: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        toplevel: true,
-    }
-    input: {
-        var a = 0;
-        (function(...{
-            [a++]: {},
-        }) {})(2);
-        console.log(a);
-    }
-    expect: {
-        var a = 0;
-        (function(...{
-            [a++]: {},
-        }) {})(2);
-        console.log(a);
-    }
-    expect_stdout: "1"
-    node_version: ">=6"
-}
-
-issue_4560_2: {
-    options = {
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a = 0;
-        (function(...{
-            [a++]: {},
-        }) {})(2);
-        console.log(a);
-    }
-    expect: {
-        var a = 0;
-        (function(...{
-            [a++]: {},
-        }) {})(2);
-        console.log(a);
-    }
-    expect_stdout: "1"
-    node_version: ">=6"
-}
-
-issue_4560_3: {
-    options = {
-        collapse_vars: true,
-        reduce_vars: true,
-        toplevel: true,
-    }
-    input: {
-        var a = 0, b;
-        [ ...{
-            [a++]: b,
-        } ] = [ "PASS" ];
-        console.log(b);
-    }
-    expect: {
-        var a = 0, b;
-        [ ...{
-            [a++]: b,
-        } ] = [ "PASS" ];
-        console.log(b);
-    }
-    expect_stdout: "PASS"
-    node_version: ">=6"
-}
-
 issue_4614: {
     options = {
         pure_getters: "strict",
@@ -1066,7 +1065,7 @@ issue_4849: {
         }()));
     }
     expect_stdout: "object"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4882_1: {
@@ -1098,7 +1097,7 @@ issue_4882_1: {
         "PASS",
         "undefined",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4882_2: {
@@ -1124,7 +1123,7 @@ issue_4882_2: {
         "42",
         "PASS",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4882_3: {
@@ -1154,7 +1153,7 @@ issue_4882_3: {
         "PASS",
         "42",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_5006: {
@@ -1176,3 +1175,81 @@ 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"
+}

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

@@ -131,6 +131,105 @@ malformed_escape: {
     node_version: ">=4"
 }
 
+booleans: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        var a;
+        console.log(`$${a}${a}` ? "PASS" : "FAIL");
+    }
+    expect: {
+        var a;
+        console.log("$" + a + a ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+escape_placeholder_1: {
+    options = {
+        templates: true,
+    }
+    input: {
+        console.log(`\${\n`);
+    }
+    expect: {
+        console.log(`\${
+`);
+    }
+    expect_stdout: [
+        "${",
+        "",
+    ]
+    node_version: ">=4"
+}
+
+escape_placeholder_2: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\n${"${"}\n`);
+    }
+    expect: {
+        console.log(`
+\${
+`);
+    }
+    expect_stdout: [
+        "",
+        "${",
+        "",
+    ]
+    node_version: ">=4"
+}
+
+escape_placeholder_3: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\n$${"{"}\n`);
+    }
+    expect: {
+        console.log(`
+\${
+`);
+    }
+    expect_stdout: [
+        "",
+        "${",
+        "",
+    ]
+    node_version: ">=4"
+}
+
+escape_placeholder_4: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\n${"$"}${"{"}\n`);
+    }
+    expect: {
+        console.log(`
+\${
+`);
+    }
+    expect_stdout: [
+        "",
+        "${",
+        "",
+    ]
+    node_version: ">=4"
+}
+
 evaluate: {
     options = {
         evaluate: true,
@@ -174,7 +273,7 @@ partial_evaluate: {
         console.log(`${6 * 7} foo ${console ? `PA` + "SS" : `FA` + `IL`}`);
     }
     expect: {
-        console.log(`42 foo ${console ? "PASS" : "FAIL"}`);
+        console.log("42 foo " + (console ? "PASS" : "FAIL"));
     }
     expect_stdout: "42 foo PASS"
     node_version: ">=4"
@@ -204,7 +303,7 @@ malformed_evaluate_2: {
         console.log(`\u0${0}b${5}`);
     }
     expect: {
-        console.log(`\u0${0}b5`);
+        console.log(`\u00b` + 5);
     }
     expect_stdout: true
     node_version: ">=4"
@@ -238,7 +337,7 @@ malformed_evaluate_4: {
         console.log("\\u00b5");
     }
     expect_stdout: "\\u00b5"
-    node_version: ">=8"
+    node_version: ">=8.10.0"
 }
 
 unsafe_evaluate: {
@@ -254,7 +353,7 @@ unsafe_evaluate: {
         console.log("\\uFo");
     }
     expect_stdout: "\\uFo"
-    node_version: ">=8"
+    node_version: ">=8.10.0"
 }
 
 side_effects_1: {
@@ -357,13 +456,14 @@ issue_4604: {
 issue_4606: {
     options = {
         evaluate: true,
+        strings: true,
         templates: true,
     }
     input: {
         console.log(`${typeof A} ${"\r"} ${"\\"} ${"`"}`);
     }
     expect: {
-        console.log(`${typeof A} \r \\ \``);
+        console.log(typeof A + " \r \\ `");
     }
     expect_stdout: "undefined \r \\ `"
     node_version: ">=4"
@@ -434,3 +534,238 @@ issue_4931: {
     ]
     node_version: ">=4"
 }
+
+issue_5125_1: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`PASS ${typeof A}`);
+    }
+    expect: {
+        console.log("PASS " + typeof A);
+    }
+    expect_stdout: "PASS undefined"
+    node_version: ">=4"
+}
+
+issue_5125_2: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`PASS
+${typeof A}`);
+    }
+    expect: {
+        console.log(`PASS
+` + typeof A);
+    }
+    expect_stdout: [
+        "PASS",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_5125_3: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`PASS\n${typeof A}`);
+    }
+    expect: {
+        console.log(`PASS
+` + typeof A);
+    }
+    expect_stdout: [
+        "PASS",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_5125_4: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`PASS
+
+${typeof A}`);
+    }
+    expect: {
+        console.log(`PASS
+
+` + typeof A);
+    }
+    expect_stdout: [
+        "PASS",
+        "",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_5125_5: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`PASS\n\n${typeof A}`);
+    }
+    expect: {
+        console.log(`PASS
+
+` + typeof A);
+    }
+    expect_stdout: [
+        "PASS",
+        "",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_5125_6: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${typeof A} ${typeof B} PASS`);
+    }
+    expect: {
+        console.log(typeof A + ` ${typeof B} PASS`);
+    }
+    expect_stdout: "undefined undefined PASS"
+    node_version: ">=4"
+}
+
+issue_5125_7: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${typeof A} ${typeof B} ${typeof C} PASS`);
+    }
+    expect: {
+        console.log(typeof A + ` ${typeof B} ${typeof C} PASS`);
+    }
+    expect_stdout: "undefined undefined undefined PASS"
+    node_version: ">=4"
+}
+
+issue_5125_8: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${typeof A}${typeof B}${typeof C} PASS`);
+    }
+    expect: {
+        console.log(typeof A + typeof B + typeof C + " PASS");
+    }
+    expect_stdout: "undefinedundefinedundefined PASS"
+    node_version: ">=4"
+}
+
+issue_5136: {
+    options = {
+        templates: true,
+    }
+    input: {
+        console.log(`${A = []}${A[0] = 42}`);
+    }
+    expect: {
+        console.log(`` + (A = []) + (A[0] = 42));
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+issue_5145_1: {
+    options = {
+        strings: true,
+        templates: true,
+    }
+    input: {
+        var a = [];
+        console.log(`${a}${a[0] = 42}
+`);
+    }
+    expect: {
+        var a = [];
+        console.log(`${a}${a[0] = 42}
+`);
+    }
+    expect_stdout: [
+        "42",
+        "",
+    ]
+    node_version: ">=4"
+}
+
+issue_5145_2: {
+    options = {
+        strings: true,
+        templates: true,
+    }
+    input: {
+        var a = [];
+        console.log(`${a}${a}${a[0] = 42}
+`);
+    }
+    expect: {
+        var a = [];
+        console.log("" + a + a + (a[0] = 42) + `
+`);
+    }
+    expect_stdout: [
+        "42",
+        "",
+    ]
+    node_version: ">=4"
+}
+
+issue_5199: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function() {
+            console.log(typeof b);
+        }``;
+        {
+            const b = a;
+        }
+    }
+    expect: {
+        var a = function() {
+            console.log(typeof b);
+        }``;
+        {
+            const b = a;
+        }
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}

test/compress/transform.js

@@ -95,7 +95,7 @@ while_if_break: {
         }
     }
     expect: {
-        for(; a && (b && c && d, !e););
+        for (; a && (b && c && d, !e););
     }
 }
 
@@ -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_p = "PASS";
+        var o, o_p = "PASS";
         console.log(o_p);
     }
     expect_stdout: "PASS"
@@ -136,7 +136,7 @@ hoist_props_let: {
     }
     expect: {
         "use strict";
-        var 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

@@ -61,7 +61,7 @@ lambda_name_mangle: {
 
 lambda_name_mangle_ie8: {
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -95,7 +95,7 @@ function_name_mangle_ie8: {
         unused: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -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/invalid/optional-template.js

@@ -0,0 +1 @@
+console?.log``;

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=