v3.13.9

fixes #4992

.github/workflows/build.yml

@@ -0,0 +1,58 @@
+name: Build testing
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+jobs:
+  ufuzz:
+    strategy:
+      fail-fast: false
+      matrix:
+        options:
+          - '-mb braces'
+          - '--ie8 -c'
+          - '-mc'
+          - '-p acorn --toplevel -mco spidermonkey'
+          - '--toplevel -mc passes=3,pure_getters,unsafe'
+        script:
+          - acorn.sh
+          - bootstrap.sh
+          - buble.sh
+          - butternut.sh
+          - mathjs.sh
+          - rollup-es.sh
+          - rollup-ts.sh
+          - sucrase.sh
+          - web-tooling-benchmark.sh
+        include:
+          - node: '14'
+            script: acorn.sh
+          - node: '14'
+            script: bootstrap.sh
+          - node: '14'
+            script: buble.sh
+          - node: '14'
+            script: butternut.sh
+          - node: '14'
+            script: mathjs.sh
+          - node: '8'
+            script: rollup-es.sh
+          - node: '14'
+            script: rollup-ts.sh
+          - node: '14'
+            script: sucrase.sh
+          - node: '14'
+            script: web-tooling-benchmark.sh
+    name: ${{ matrix.script }} ${{ matrix.options }}
+    runs-on: ubuntu-latest
+    env:
+      NODE: ${{ matrix.node }}
+      OPTIONS: ${{ matrix.options }}
+      SCRIPT: ${{ matrix.script }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Perform uglify, build & test
+        shell: bash
+        run: |
+          . ./test/release/install.sh
+          ./test/release/$SCRIPT $OPTIONS

.github/workflows/ci.yml

@@ -7,7 +7,7 @@ jobs:
   test:
     strategy:
       matrix:
-        node: [ '0.8', '0.10', '0.12', '4', '6', '8', '10', '12', latest ]
+        node: [ '0.8', '0.10', '0.12', '4', '6', '8', '10', '12', '14', latest ]
         os: [ ubuntu-latest, windows-latest ]
         script: [ compress, mocha, release/benchmark, release/jetstream ]
         exclude:
@@ -29,20 +29,5 @@ jobs:
       - name: Perform tests
         shell: bash
         run: |
-          git clone --branch v1.6.0 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
-          while ! timeout 60 bash -c '. ~/.nvs/nvs.sh add $NODE && nvs use $NODE'; do
-            cd ~/.nvs
-            while !(git clean -xdf); do echo "'git clean' failed - retrying..."; done
-            cd -
-          done
-          . ~/.nvs/nvs.sh --version
-          nvs use $NODE
-          node --version
-          npm config set audit false
-          npm config set optional false
-          npm config set save false
-          npm config set strict-ssl false
-          npm config set update-notifier false
-          npm --version
-          while !(npm install); do echo "'npm install' failed - retrying..."; done
+          . ./test/release/install.sh
           node test/$TYPE

.github/workflows/ufuzz.yml

@@ -2,11 +2,14 @@ name: Fuzzing
 on:
   pull_request:
   schedule:
-    - cron: '*/5 * * * *'
+    - cron: '*/15 * * * *'
+  workflow_dispatch:
+  workflow_run:
+    branches: [ master ]
+    types: [ completed ]
+    workflows: [ 'Build testing', CI ]
 env:
   BASE_URL: https://api.github.com/repos/${{ github.repository }}
-  CAUSE: ${{ github.event_name }}
-  RUN_NUM: ${{ github.run_number }}
   TOKEN: ${{ github.token }}
 jobs:
   ufuzz:
@@ -30,32 +33,12 @@ jobs:
       NODE: ${{ matrix.node }}
     steps:
       - uses: actions/checkout@v2
-      - name: Install GNU Core Utilities
-        if: ${{ startsWith(matrix.os, 'macos') }}
-        shell: bash
-        run: |
-          brew install coreutils
       - name: Perform fuzzing
         shell: bash
         run: |
-          git clone --branch v1.6.0 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
-          while ! timeout 60 bash -c '. ~/.nvs/nvs.sh add $NODE && nvs use $NODE'; do
-            cd ~/.nvs
-            while !(git clean -xdf); do echo "'git clean' failed - retrying..."; done
-            cd -
-          done
-          . ~/.nvs/nvs.sh --version
-          nvs use $NODE
-          node --version
-          npm config set audit false
-          npm config set optional false
-          npm config set save false
-          npm config set strict-ssl false
-          npm config set update-notifier false
-          npm --version
-          while !(npm install); do echo "'npm install' failed - retrying..."; done
-          if [[ $CAUSE == "schedule" ]]; then
-            node test/ufuzz/job $BASE_URL $TOKEN $RUN_NUM
-          else
+          . ./test/release/install.sh
+          if [[ $GITHUB_EVENT_NAME == "pull_request" ]]; then
             node test/ufuzz/job 5000
+          else
+            node test/ufuzz/job $BASE_URL $TOKEN $GITHUB_RUN_NUMBER
           fi

README.md

@@ -4,12 +4,11 @@ UglifyJS 3
 UglifyJS is a JavaScript parser, minifier, compressor and beautifier toolkit.
 
 #### Note:
-- **`uglify-js@3` has a simplified [API](#api-reference) and [CLI](#command-line-usage)
-  that is not backwards compatible with [`uglify-js@2`](https://github.com/mishoo/UglifyJS/tree/v2.x)**.
-- **Documentation for UglifyJS `2.x` releases can be found [here](https://github.com/mishoo/UglifyJS/tree/v2.x)**.
-- `uglify-js` supports ECMAScript 5 and some newer language features.
-- To minify ECMAScript 2015 or above, you may need to transpile using tools like
-  [Babel](https://babeljs.io/).
+- `uglify-js` supports JavaScript and most language features in ECMAScript.
+- For more exotic parts of ECMAScript, process your source file with transpilers
+  like [Babel](https://babeljs.io/) before passing onto `uglify-js`.
+- `uglify-js@3` has a simplified [API](#api-reference) and [CLI](#command-line-usage)
+  that is not backwards compatible with [`uglify-js@2`](https://github.com/mishoo/UglifyJS/tree/v2.x).
 
 Install
 -------
@@ -86,13 +85,16 @@ a double dash to prevent input files being used as option arguments:
                                                1 - single
                                                2 - double
                                                3 - original
-                                `wrap_iife`  Wrap IIFEs in parenthesis. Note: you may
+                                `wrap_iife`  Wrap IIFEs in parentheses. Note: you may
                                              want to disable `negate_iife` under
                                              compressor options.
     -O, --output-opts [options] Specify output options (`beautify` disabled by default).
     -o, --output <file>         Output file path (default STDOUT). Specify `ast` or
                                 `spidermonkey` to write UglifyJS or SpiderMonkey AST
                                 as JSON to STDOUT respectively.
+    --annotations               Process and preserve comment annotations.
+                                (`/*@__PURE__*/` or `/*#__PURE__*/`)
+    --no-annotations            Ignore and discard comment annotations.
     --comments [filter]         Preserve copyright comments in the output. By
                                 default this works like Google Closure, keeping
                                 JSDoc-style comments that contain "@license" or
@@ -222,10 +224,10 @@ Example:
 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:
 
-- `eval` (default `false`) -- mangle names visible in scopes where `eval` or
+- `eval` (default: `false`) — mangle names visible in scopes where `eval` or
   `with` are used.
 
-- `reserved` (default: `[]`) -- when mangling is enabled but you want to
+- `reserved` (default: `[]`) — when mangling is enabled but you want to
   prevent certain names from being mangled, you can declare those names with
   `--mangle reserved` — pass a comma-separated list of names.  For example:
 
@@ -492,46 +494,51 @@ if (result.error) throw result.error;
 
 ## Minify options
 
-- `compress` (default `{}`) — pass `false` to skip compressing entirely.
+- `annotations` — pass `false` to ignore all comment annotations and elide them
+  from output. Useful when, for instance, external tools incorrectly applied
+  `/*@__PURE__*/` or `/*#__PURE__*/`. Pass `true` to both compress and retain
+  comment annotations in output to allow for further processing downstream.
+
+- `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.
+- `ie8` (default: `false`) — set to `true` to support IE8.
 
-- `keep_fnames` (default: `false`) -- pass `true` to prevent discarding or mangling
+- `keep_fnames` (default: `false`) — pass `true` to prevent discarding or mangling
   of function names.  Useful for code relying on `Function.prototype.name`.
 
-- `mangle` (default `true`) — pass `false` to skip mangling names, or pass
+- `mangle` (default: `true`) — pass `false` to skip mangling names, or pass
   an object to specify [mangle options](#mangle-options) (see below).
 
-  - `mangle.properties` (default `false`) — a subcategory of the mangle option.
+  - `mangle.properties` (default: `false`) — a subcategory of the mangle option.
     Pass an object to specify custom [mangle property options](#mangle-properties-options).
 
-- `nameCache` (default `null`) -- pass an empty object `{}` or a previously
+- `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
   a read/write property. `minify()` will read the name cache state of this
   object and update it during minification so that it may be
   reused or externally persisted by the user.
 
-- `output` (default `null`) — pass an object if you wish to specify
+- `output` (default: `null`) — pass an object if you wish to specify
   additional [output options](#output-options).  The defaults are optimized
   for best compression.
 
-- `parse` (default `{}`) — pass an object if you wish to specify some
+- `parse` (default: `{}`) — pass an object if you wish to specify some
   additional [parse options](#parse-options).
 
-- `sourceMap` (default `false`) -- pass an object if you wish to specify
+- `sourceMap` (default: `false`) — pass an object if you wish to specify
   [source map options](#source-map-options).
 
-- `toplevel` (default `false`) -- set to `true` if you wish to enable top level
+- `toplevel` (default: `false`) — set to `true` if you wish to enable top level
   variable and function name mangling and to drop unused variables and functions.
 
-- `v8` (default `false`) -- enable workarounds for Chrome & Node.js bugs.
+- `v8` (default: `false`) — enable workarounds for Chrome & Node.js bugs.
 
-- `warnings` (default `false`) — pass `true` to return compressor warnings
+- `warnings` (default: `false`) — pass `true` to return compressor warnings
   in `result.warnings`. Use the value `"verbose"` for more detailed warnings.
 
-- `webkit` (default `false`) -- enable workarounds for Safari/WebKit bugs.
+- `webkit` (default: `false`) — enable workarounds for Safari/WebKit bugs.
   PhantomJS users should set this option to `true`.
 
 ## Minify options structure
@@ -616,111 +623,121 @@ to be `false` and all symbol names will be omitted.
 
 ## Parse options
 
-- `bare_returns` (default `false`) -- support top level `return` statements
+- `bare_returns` (default: `false`) — support top level `return` statements
 
-- `html5_comments` (default `true`)
+- `html5_comments` (default: `true`)
 
-- `shebang` (default `true`) -- support `#!command` as the first line
+- `shebang` (default: `true`) — support `#!command` as the first line
 
 ## Compress options
 
-- `arguments` (default: `true`) -- replace `arguments[index]` with function
+- `annotations` (default: `true`) — Pass `false` to disable potentially dropping
+  functions marked as "pure".  A function call is marked as "pure" if a comment
+  annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
+  example: `/*@__PURE__*/foo();`
+
+- `arguments` (default: `true`) — replace `arguments[index]` with function
   parameter name whenever possible.
 
-- `arrows` (default: `true`) -- apply optimizations to arrow functions
+- `arrows` (default: `true`) — apply optimizations to arrow functions
 
-- `assignments` (default: `true`) -- apply optimizations to assignment expressions
+- `assignments` (default: `true`) — apply optimizations to assignment expressions
 
-- `awaits` (default: `true`) -- apply optimizations to `await` expressions
+- `awaits` (default: `true`) — apply optimizations to `await` expressions
 
-- `booleans` (default: `true`) -- various optimizations for boolean context,
+- `booleans` (default: `true`) — various optimizations for boolean context,
   for example `!!a ? b : c → a ? b : c`
 
-- `collapse_vars` (default: `true`) -- Collapse single-use non-constant variables,
+- `collapse_vars` (default: `true`) — Collapse single-use non-constant variables,
   side effects permitting.
 
-- `comparisons` (default: `true`) -- apply certain optimizations to binary nodes,
+- `comparisons` (default: `true`) — apply certain optimizations to binary nodes,
   e.g. `!(a <= b) → a > b`, attempts to negate binary nodes, e.g.
   `a = !b && !c && !d && !e → a=!(b||c||d||e)` etc.
 
-- `conditionals` (default: `true`) -- apply optimizations for `if`-s and conditional
+- `conditionals` (default: `true`) — apply optimizations for `if`-s and conditional
   expressions
 
-- `dead_code` (default: `true`) -- remove unreachable code
+- `dead_code` (default: `true`) — remove unreachable code
 
-- `default_values` (default: `true`) -- drop overshadowed default values
+- `default_values` (default: `true`) — drop overshadowed default values
 
-- `directives` (default: `true`) -- remove redundant or non-standard directives
+- `directives` (default: `true`) — remove redundant or non-standard directives
 
-- `drop_console` (default: `false`) -- Pass `true` to discard calls to
+- `drop_console` (default: `false`) — Pass `true` to discard calls to
   `console.*` functions. If you wish to drop a specific function call
   such as `console.info` and/or retain side effects from function arguments
   after dropping the function call then use `pure_funcs` instead.
 
-- `drop_debugger` (default: `true`) -- remove `debugger;` statements
+- `drop_debugger` (default: `true`) — remove `debugger;` statements
 
-- `evaluate` (default: `true`) -- Evaluate expression for shorter constant
+- `evaluate` (default: `true`) — Evaluate expression for shorter constant
   representation. Pass `"eager"` to always replace function calls whenever
   possible, or a positive integer to specify an upper bound for each individual
   evaluation in number of characters.
 
-- `expression` (default: `false`) -- Pass `true` to preserve completion values
+- `expression` (default: `false`) — Pass `true` to preserve completion values
   from terminal statements without `return`, e.g. in bookmarklets.
 
-- `functions` (default: `true`) -- convert declarations from `var`to `function`
+- `functions` (default: `true`) — convert declarations from `var` to `function`
   whenever possible.
 
-- `global_defs` (default: `{}`) -- see [conditional compilation](#conditional-compilation)
+- `global_defs` (default: `{}`) — see [conditional compilation](#conditional-compilation)
 
-- `hoist_funs` (default: `false`) -- hoist function declarations
+- `hoist_exports` (default: `true`) — hoist `export` statements to facilitate
+  various `compress` and `mangle` optimizations.
 
-- `hoist_props` (default: `true`) -- hoist properties from constant object and
+- `hoist_funs` (default: `false`) — hoist function declarations
+
+- `hoist_props` (default: `true`) — hoist properties from constant object and
   array literals into regular variables subject to a set of constraints. For example:
   `var o={p:1, q:2}; f(o.p, o.q);` is converted to `f(1, 2);`. Note: `hoist_props`
   works best with `toplevel` and `mangle` enabled, alongside with `compress` option
   `passes` set to `2` or higher.
 
-- `hoist_vars` (default: `false`) -- hoist `var` declarations (this is `false`
+- `hoist_vars` (default: `false`) — hoist `var` declarations (this is `false`
   by default because it seems to increase the size of the output in general)
 
-- `if_return` (default: `true`) -- optimizations for if/return and if/continue
+- `if_return` (default: `true`) — optimizations for if/return and if/continue
 
-- `inline` (default: `true`) -- inline calls to function with simple/`return` statement:
-  - `false` -- same as `0`
-  - `0` -- disabled inlining
-  - `1` -- inline simple functions
-  - `2` -- inline functions with arguments
-  - `3` -- inline functions with arguments and variables
-  - `true` -- same as `3`
+- `imports` (default: `true`) — drop unreferenced import symbols when used with `unused`
 
-- `join_vars` (default: `true`) -- join consecutive `var` statements
+- `inline` (default: `true`) — inline calls to function with simple/`return` statement:
+  - `false` — same as `0`
+  - `0` — disabled inlining
+  - `1` — inline simple functions
+  - `2` — inline functions with arguments
+  - `3` — inline functions with arguments and variables
+  - `true` — same as `3`
 
-- `keep_fargs` (default: `false`) -- discard unused function arguments except
+- `join_vars` (default: `true`) — join consecutive `var` statements
+
+- `keep_fargs` (default: `false`) — discard unused function arguments except
   when unsafe to do so, e.g. code which relies on `Function.prototype.length`.
   Pass `true` to always retain function arguments.
 
-- `keep_infinity` (default: `false`) -- Pass `true` to prevent `Infinity` from
+- `keep_infinity` (default: `false`) — Pass `true` to prevent `Infinity` from
   being compressed into `1/0`, which may cause performance issues on Chrome.
 
-- `loops` (default: `true`) -- optimizations for `do`, `while` and `for` loops
+- `loops` (default: `true`) — optimizations for `do`, `while` and `for` loops
   when we can statically determine the condition.
 
-- `merge_vars` (default: `true`) -- combine and reuse variables.
+- `merge_vars` (default: `true`) — combine and reuse variables.
 
-- `negate_iife` (default: `true`) -- negate "Immediately-Called Function Expressions"
+- `negate_iife` (default: `true`) — negate "Immediately-Called Function Expressions"
   where the return value is discarded, to avoid the parens that the
   code generator would insert.
 
-- `objects` (default: `true`) -- compact duplicate keys in object literals.
+- `objects` (default: `true`) — compact duplicate keys in object literals.
 
-- `passes` (default: `1`) -- The maximum number of times to run compress.
+- `passes` (default: `1`) — The maximum number of times to run compress.
   In some cases more than one pass leads to further compressed code.  Keep in
   mind more passes will take more time.
 
-- `properties` (default: `true`) -- rewrite property access using the dot notation, for
+- `properties` (default: `true`) — rewrite property access using the dot notation, for
   example `foo["bar"] → foo.bar`
 
-- `pure_funcs` (default: `null`) -- You can pass an array of names and
+- `pure_funcs` (default: `null`) — You can pass an array of names and
   UglifyJS will assume that those functions do not produce side
   effects.  DANGER: will not check if the name is redefined in scope.
   An example case here, for instance `var q = Math.floor(a/b)`.  If
@@ -732,24 +749,24 @@ to be `false` and all symbol names will be omitted.
   overhead (compression will be slower). Make sure symbols under `pure_funcs`
   are also under `mangle.reserved` to avoid mangling.
 
-- `pure_getters` (default: `"strict"`) -- If you pass `true` for
+- `pure_getters` (default: `"strict"`) — If you pass `true` for
   this, UglifyJS will assume that object property access
   (e.g. `foo.bar` or `foo["bar"]`) doesn't have any side effects.
   Specify `"strict"` to treat `foo.bar` as side-effect-free only when
   `foo` is certain to not throw, i.e. not `null` or `undefined`.
 
-- `reduce_funcs` (default: `true`) -- Allows single-use functions to be
+- `reduce_funcs` (default: `true`) — Allows single-use functions to be
   inlined as function expressions when permissible allowing further
   optimization.  Enabled by default.  Option depends on `reduce_vars`
   being enabled.  Some code runs faster in the Chrome V8 engine if this
   option is disabled.  Does not negatively impact other major browsers.
 
-- `reduce_vars` (default: `true`) -- Improve optimization on variables assigned with and
+- `reduce_vars` (default: `true`) — Improve optimization on variables assigned with and
   used as constant values.
 
-- `rests` (default: `true`) -- apply optimizations to rest parameters
+- `rests` (default: `true`) — apply optimizations to rest parameters
 
-- `sequences` (default: `true`) -- join consecutive simple statements using the
+- `sequences` (default: `true`) — join consecutive simple statements using the
   comma operator.  May be set to a positive integer to specify the maximum number
   of consecutive comma sequences that will be generated. If this option is set to
   `true` then the default `sequences` limit is `200`. Set option to `false` or `0`
@@ -758,65 +775,68 @@ to be `false` and all symbol names will be omitted.
   occasions the default sequences limit leads to very slow compress times in which
   case a value of `20` or less is recommended.
 
-- `side_effects` (default: `true`) -- Pass `false` to disable potentially dropping
-  functions marked as "pure".  A function call is marked as "pure" if a comment
-  annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
-  example: `/*@__PURE__*/foo();`
+- `side_effects` (default: `true`) — drop extraneous code which does not affect
+  outcome of runtime execution.
 
-- `spreads` (default: `true`) -- flatten spread expressions.
+- `spreads` (default: `true`) — flatten spread expressions.
 
-- `strings` (default: `true`) -- compact string concatenations.
+- `strings` (default: `true`) — compact string concatenations.
 
-- `switches` (default: `true`) -- de-duplicate and remove unreachable `switch` branches
+- `switches` (default: `true`) — de-duplicate and remove unreachable `switch` branches
 
-- `top_retain` (default: `null`) -- prevent specific toplevel functions and
+- `templates` (default: `true`) — compact template literals by embedding expressions
+  and/or converting to string literals, e.g. `` `foo ${42}` → "foo 42"``
+
+- `top_retain` (default: `null`) — prevent specific toplevel functions and
   variables from `unused` removal (can be array, comma-separated, RegExp or
   function. Implies `toplevel`)
 
-- `toplevel` (default: `false`) -- drop unreferenced functions (`"funcs"`) and/or
+- `toplevel` (default: `false`) — drop unreferenced functions (`"funcs"`) and/or
   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
+- `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.
 
-- `unsafe` (default: `false`) -- apply "unsafe" transformations (discussion below)
+- `unsafe` (default: `false`) — apply "unsafe" transformations (discussion below)
 
-- `unsafe_comps` (default: `false`) -- compress expressions like `a <= b` assuming
+- `unsafe_comps` (default: `false`) — compress expressions like `a <= b` assuming
   none of the operands can be (coerced to) `NaN`.
 
-- `unsafe_Function` (default: `false`) -- compress and mangle `Function(args, code)`
+- `unsafe_Function` (default: `false`) — compress and mangle `Function(args, code)`
   when both `args` and `code` are string literals.
 
-- `unsafe_math` (default: `false`) -- optimize numerical expressions like
+- `unsafe_math` (default: `false`) — optimize numerical expressions like
   `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
 
-- `unsafe_proto` (default: `false`) -- optimize expressions like
+- `unsafe_proto` (default: `false`) — optimize expressions like
   `Array.prototype.slice.call(a)` into `[].slice.call(a)`
 
-- `unsafe_regexp` (default: `false`) -- enable substitutions of variables with
+- `unsafe_regexp` (default: `false`) — enable substitutions of variables with
   `RegExp` values the same way as if they are constants.
 
-- `unsafe_undefined` (default: `false`) -- substitute `void 0` if there is a
+- `unsafe_undefined` (default: `false`) — substitute `void 0` if there is a
   variable named `undefined` in scope (variable name will be mangled, typically
   reduced to a single character)
 
-- `unused` (default: `true`) -- drop unreferenced functions and variables (simple
+- `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 declaractions into `var`
   whenever safe to do so
 
+- `yields` (default: `true`) — apply optimizations to `yield` expressions
+
 ## Mangle options
 
-- `eval` (default `false`) -- Pass `true` to mangle names visible in scopes
+- `eval` (default: `false`) — Pass `true` to mangle names visible in scopes
   where `eval` or `with` are used.
 
-- `reserved` (default `[]`) -- Pass an array of identifiers that should be
+- `reserved` (default: `[]`) — Pass an array of identifiers that should be
   excluded from mangling. Example: `["foo", "bar"]`.
 
-- `toplevel` (default `false`) -- Pass `true` to mangle names declared in the
+- `toplevel` (default: `false`) — Pass `true` to mangle names declared in the
   top level scope.
 
 Examples:
@@ -843,18 +863,18 @@ UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
 
 ### Mangle properties options
 
-- `builtins` (default: `false`) -- Use `true` to allow the mangling of builtin
+- `builtins` (default: `false`) — Use `true` to allow the mangling of builtin
   DOM properties. Not recommended to override this setting.
 
-- `debug` (default: `false`) -— Mangle names with the original name still present.
+- `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.
 
-- `keep_quoted` (default: `false`) -— Only mangle unquoted property names.
+- `keep_quoted` (default: `false`) — Only mangle unquoted property names.
 
-- `regex` (default: `null`) -— Pass a RegExp literal to only mangle property
+- `regex` (default: `null`) — Pass a RegExp literal to only mangle property
   names matching the regular expression.
 
-- `reserved` (default: `[]`) -- Do not mangle property names listed in the
+- `reserved` (default: `[]`) — Do not mangle property names listed in the
   `reserved` array.
 
 ## Output options
@@ -863,19 +883,23 @@ The code generator tries to output shortest code possible by default.  In
 case you want beautified output, pass `--beautify` (`-b`).  Optionally you
 can pass additional arguments that control the code output:
 
-- `ascii_only` (default `false`) -- escape Unicode characters in strings and
+- `annotations` (default: `false`) — pass `true` to retain comment annotations
+  `/*@__PURE__*/` or `/*#__PURE__*/`, otherwise they will be discarded even if
+  `comments` is set.
+
+- `ascii_only` (default: `false`) — escape Unicode characters in strings and
   regexps (affects directives with non-ascii characters becoming invalid)
 
-- `beautify` (default `true`) -- whether to actually beautify the output.
+- `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.
 
-- `braces` (default `false`) -- always insert braces in `if`, `for`,
+- `braces` (default: `false`) — always insert braces in `if`, `for`,
   `do`, `while` or `with` statements, even if their body is a single
   statement.
 
-- `comments` (default `false`) -- pass `true` or `"all"` to preserve all
+- `comments` (default: `false`) — pass `true` or `"all"` to preserve all
   comments, `"some"` to preserve multi-line comments that contain `@cc_on`,
   `@license`, or `@preserve` (case-insensitive), a regular expression string
   (e.g. `/^!/`), or a function which returns `boolean`, e.g.
@@ -885,53 +909,53 @@ can pass additional arguments that control the code output:
   }
   ```
 
-- `galio` (default `false`) -- enable workarounds for ANT Galio bugs
+- `galio` (default: `false`) — enable workarounds for ANT Galio bugs
 
-- `indent_level` (default `4`)
+- `indent_level` (default: `4`)
 
-- `indent_start` (default `0`) -- prefix all lines by that many spaces
+- `indent_start` (default: `0`) — prefix all lines by that many spaces
 
-- `inline_script` (default `true`) -- escape HTML comments and the slash in
+- `inline_script` (default: `true`) — escape HTML comments and the slash in
   occurrences of `</script>` in strings
 
-- `keep_quoted_props` (default `false`) -- when turned on, prevents stripping
+- `keep_quoted_props` (default: `false`) — when turned on, prevents stripping
   quotes from property names in object literals.
 
-- `max_line_len` (default `false`) -- maximum line length (for uglified code)
+- `max_line_len` (default: `false`) — maximum line length (for uglified code)
 
-- `preamble` (default `null`) -- when passed it must be a string and
+- `preamble` (default: `null`) — when passed it must be a string and
   it will be prepended to the output literally.  The source map will
   adjust for this text.  Can be used to insert a comment containing
   licensing information, for example.
 
-- `preserve_line` (default `false`) -- pass `true` to retain line numbering on
+- `preserve_line` (default: `false`) — pass `true` to retain line numbering on
   a best effort basis.
 
-- `quote_keys` (default `false`) -- pass `true` to quote all keys in literal
+- `quote_keys` (default: `false`) — pass `true` to quote all keys in literal
   objects
 
-- `quote_style` (default `0`) -- preferred quote style for strings (affects
+- `quote_style` (default: `0`) — preferred quote style for strings (affects
   quoted property names and directives as well):
-  - `0` -- prefers double quotes, switches to single quotes when there are
+  - `0` — prefers double quotes, switches to single quotes when there are
     more double quotes in the string itself. `0` is best for gzip size.
-  - `1` -- always use single quotes
-  - `2` -- always use double quotes
-  - `3` -- always use the original quotes
+  - `1` — always use single quotes
+  - `2` — always use double quotes
+  - `3` — always use the original quotes
 
-- `semicolons` (default `true`) -- separate statements with semicolons.  If
+- `semicolons` (default: `true`) — separate statements with semicolons.  If
   you pass `false` then whenever possible we will use a newline instead of a
   semicolon, leading to more readable output of uglified code (size before
   gzip could be smaller; size after gzip insignificantly larger).
 
-- `shebang` (default `true`) -- preserve shebang `#!` in preamble (bash scripts)
+- `shebang` (default: `true`) — preserve shebang `#!` in preamble (bash scripts)
 
-- `width` (default `80`) -- only takes effect when beautification is on, this
+- `width` (default: `80`) — only takes effect when beautification is on, this
   specifies an (orientative) line width that the beautifier will try to
   obey.  It refers to the width of the line text (excluding indentation).
   It doesn't work very well currently, but it does make the code generated
   by UglifyJS more readable.
 
-- `wrap_iife` (default `false`) -- pass `true` to wrap immediately invoked
+- `wrap_iife` (default: `false`) — pass `true` to wrap immediately invoked
   function expressions. See
   [#640](https://github.com/mishoo/UglifyJS/issues/640) for more details.
 
@@ -1132,18 +1156,14 @@ in total it's a bit more than just using UglifyJS's own parser.
 It's not well known, but whitespace removal and symbol mangling accounts
 for 95% of the size reduction in minified code for most JavaScript - not
 elaborate code transforms. One can simply disable `compress` to speed up
-Uglify builds by 3 to 4 times. In this fast `mangle`-only mode Uglify has
-comparable minify speeds and gzip sizes to
-[`butternut`](https://www.npmjs.com/package/butternut):
+Uglify builds by 3 to 5 times.
 
 | d3.js | minify size | gzip size | minify time (seconds) |
 | --- | ---: | ---: | ---: |
-| original | 451,131 | 108,733 | - |
-| uglify-js@3.0.24 mangle=false, compress=false | 316,600 | 85,245 | 0.70 |
-| uglify-js@3.0.24 mangle=true, compress=false | 220,216 | 72,730 | 1.13 |
-| butternut@0.4.6 | 217,568 | 72,738 | 1.41 |
-| uglify-js@3.0.24 mangle=true, compress=true | 212,511 | 71,560 | 3.36 |
-| babili@0.1.4 | 210,713 | 72,140 | 12.64 |
+| original | 511,371 | 119,932 | - |
+| uglify-js@3.13.0 mangle=false, compress=false | 363,988 | 95,695 | 0.56 |
+| uglify-js@3.13.0 mangle=true, compress=false | 253,305 | 81,281 | 0.99 |
+| uglify-js@3.13.0 mangle=true, compress=true | 244,436 | 79,854 | 5.30 |
 
 To enable fast minify mode from the CLI use:
 ```
@@ -1254,3 +1274,83 @@ To allow for better optimizations, the compiler makes various assumptions:
   }()) => b)());
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
+- Some arithmetic operations with `BigInt` may throw `TypeError`:
+  ```javascript
+  1n + 1;
+  // TypeError: can't convert BigInt to number
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of JavaScript will throw `SyntaxError` with the
+  following:
+  ```javascript
+  console.log(String.raw`\uFo`);
+  // SyntaxError: Invalid Unicode escape sequence
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of JavaScript will throw `SyntaxError` with the
+  following:
+  ```javascript
+  try {} catch (e) {
+      for (var e of []);
+  }
+  // SyntaxError: Identifier 'e' has already been declared
+  ```
+  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
+  console.log({
+      ...{
+          set 42(v) {},
+          42: "PASS",
+      },
+  });
+  // Expected: { '42': 'PASS' }
+  // Actual:   { '42': undefined }
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  var await;
+  async function f() {
+      class A {
+          static p = await;
+      }
+  }
+  // SyntaxError: Unexpected reserved word
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  var async;
+  for (async of []);
+  // 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
+  following:
+  ```javascript
+  console.log({
+      ...console,
+      get 42() {
+          return "FAIL";
+      },
+      [42]: "PASS",
+  }[42]);
+  // Expected: "PASS"
+  // Actual:   "FAIL"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Earlier versions of JavaScript will throw `TypeError` with the following:
+  ```javascript
+  (function() {
+      {
+          const a = "foo";
+      }
+      {
+          const a = "bar";
+      }
+  })();
+  // TypeError: const 'a' has already been declared
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.

bin/uglifyjs

@@ -10,7 +10,7 @@ var info = require("../package.json");
 var path = require("path");
 var UglifyJS = require("../tools/node");
 
-var skip_keys = [ "cname", "inlined", "parent_scope", "scope", "uses_eval", "uses_with" ];
+var skip_keys = [ "cname", "fixed", "inlined", "parent_scope", "scope", "uses_eval", "uses_with" ];
 var files = {};
 var options = {};
 var short_forms = {
@@ -95,6 +95,8 @@ function process_option(name, no_value) {
                 "  -b, --beautify [options]                 Beautify output/specify output options.",
                 "  -O, --output-opts <options>              Output options (beautify disabled).",
                 "  -o, --output <file>                      Output file (default STDOUT).",
+                "  --annotations                            Process and preserve comment annotations.",
+                "  --no-annotations                         Ignore and discard comment annotations.",
                 "  --comments [filter]                      Preserve copyright comments in the output.",
                 "  --config-file <file>                     Read minify() options from JSON file.",
                 "  -d, --define <expr>[=value]              Global definitions.",
@@ -113,6 +115,9 @@ function process_option(name, no_value) {
                 "  --warn                                   Print warning messages.",
                 "  --webkit                                 Support non-standard Safari/Webkit.",
                 "  --wrap <name>                            Embed everything as a function with “exports” corresponding to “name” globally.",
+                "",
+                "(internal debug use only)",
+                "  --in-situ                                Warning: replaces original source files with minified output.",
                 "  --reduce-test                            Reduce a standalone test case (assumes cloned repository).",
             ].join("\n"));
         }
@@ -139,6 +144,7 @@ function process_option(name, no_value) {
       case "enclose":
         options[name] = read_value();
         break;
+      case "annotations":
       case "ie8":
       case "timings":
       case "toplevel":
@@ -146,6 +152,9 @@ function process_option(name, no_value) {
       case "webkit":
         options[name] = true;
         break;
+      case "no-annotations":
+        options.annotations = false;
+        break;
       case "keep-fnames":
         options.keep_fnames = true;
         break;
@@ -194,6 +203,7 @@ function process_option(name, no_value) {
       case "no-rename":
         options.rename = false;
         break;
+      case "in-situ":
       case "reduce-test":
       case "self":
         break;
@@ -225,10 +235,11 @@ if (options.mangle && options.mangle.properties) {
         });
     }
 }
-if (output == "ast") options.output = {
-    ast: true,
-    code: false,
-};
+if (/^ast|spidermonkey$/.test(output)) {
+    if (typeof options.output != "object") options.output = {};
+    options.output.ast = true;
+    options.output.code = false;
+}
 if (options.parse && (options.parse.acorn || options.parse.spidermonkey)
     && options.sourceMap && options.sourceMap.content == "inline") {
     fatal("inline source map only works with built-in parser");
@@ -254,15 +265,32 @@ if (specified["self"]) {
     if (!options.wrap) options.wrap = "UglifyJS";
     paths = UglifyJS.FILES;
 }
-if (paths.length) {
+if (specified["in-situ"]) {
+    if (output && output != "spidermonkey" || specified["reduce-test"] || specified["self"]) {
+        fatal("incompatible options specified");
+    }
+    paths.forEach(function(name) {
+        print(name);
+        if (/^ast|spidermonkey$/.test(name)) fatal("invalid file name specified");
+        files = {};
+        files[convert_path(name)] = read_file(name);
+        output = name;
+        run();
+    });
+} else if (paths.length) {
     simple_glob(paths).forEach(function(name) {
         files[convert_path(name)] = read_file(name);
     });
     run();
 } else {
+    var timerId = process.stdin.isTTY && process.argv.length < 3 && setTimeout(function() {
+        print_error("Waiting for input... (use `--help` to print usage information)");
+    }, 1500);
     var chunks = [];
     process.stdin.setEncoding("utf8");
-    process.stdin.on("data", function(chunk) {
+    process.stdin.once("data", function() {
+        clearTimeout(timerId);
+    }).on("data", function(chunk) {
         chunks.push(chunk);
     }).on("end", function() {
         files = { STDIN: chunks.join("") };
@@ -286,13 +314,43 @@ function run() {
     try {
         if (options.parse) {
             if (options.parse.acorn) {
+                var annotations = Object.create(null);
                 files = convert_ast(function(toplevel, name) {
-                    return require("acorn").parse(files[name], {
+                    var content = files[name];
+                    var list = annotations[name] = [];
+                    var prev = -1;
+                    return require("acorn").parse(content, {
+                        allowHashBang: true,
+                        ecmaVersion: "latest",
                         locations: true,
+                        onComment: function(block, text, start, end) {
+                            var match = /[@#]__PURE__/.exec(text);
+                            if (!match) {
+                                if (start != prev) return;
+                                match = [ list[prev] ];
+                            }
+                            while (/\s/.test(content[end])) end++;
+                            list[end] = match[0];
+                            prev = end;
+                        },
+                        preserveParens: true,
                         program: toplevel,
-                        sourceFile: name
+                        sourceFile: name,
+                        sourceType: "module",
                     });
                 });
+                files.walk(new UglifyJS.TreeWalker(function(node) {
+                    if (!(node instanceof UglifyJS.AST_Call)) return;
+                    var list = annotations[node.start.file];
+                    var pure = list[node.start.pos];
+                    if (!pure) {
+                        var pos = node.start.parens;
+                        if (pos) for (var i = 0; !pure && i < pos.length; i++) {
+                            pure = list[pos[i]];
+                        }
+                    }
+                    if (pure) node.pure = pure;
+                }));
             } else if (options.parse.spidermonkey) {
                 files = convert_ast(function(toplevel, name) {
                     var obj = JSON.parse(files[name]);
@@ -360,14 +418,14 @@ function run() {
         }
         print(JSON.stringify(result.ast, function(key, value) {
             if (value) switch (key) {
-              case "thedef":
-                return symdef(value);
               case "enclosed":
                 return value.length ? value.map(symdef) : undefined;
-              case "variables":
               case "functions":
               case "globals":
+              case "variables":
                 return value.size() ? value.map(symdef) : undefined;
+              case "thedef":
+                return symdef(value);
             }
             if (skip_key(key)) return;
             if (value instanceof UglifyJS.AST_Token) return;
@@ -384,16 +442,19 @@ function run() {
             return value;
         }, 2));
     } else if (output == "spidermonkey") {
-        print(JSON.stringify(UglifyJS.minify(result.code, {
-            compress: false,
-            mangle: false,
-            output: {
-                ast: true,
-                code: false
-            },
-        }).ast.to_mozilla_ast(), null, 2));
+        print(JSON.stringify(result.ast.to_mozilla_ast(), null, 2));
     } else if (output) {
-        fs.writeFileSync(output, result.code);
+        var code;
+        if (result.ast) {
+            var opts = {};
+            for (var name in options.output) {
+                if (!/^ast|code$/.test(name)) opts[name] = options.output[name];
+            }
+            code = UglifyJS.AST_Node.from_mozilla_ast(result.ast.to_mozilla_ast()).print_to_string(opts);
+        } else {
+            code = result.code;
+        }
+        fs.writeFileSync(output, code);
         if (result.map) fs.writeFileSync(output + ".map", result.map);
     } else {
         print(result.code);

lib/ast.js

@@ -55,9 +55,10 @@ function DEFNODE(type, props, methods, base) {
     props.forEach(function(prop) {
         code.push("this.", prop, "=props.", prop, ";");
     });
+    code.push("}");
     var proto = base && new base;
     if (proto && proto.initialize || methods && methods.initialize) code.push("this.initialize();");
-    code.push("}}");
+    code.push("}");
     var ctor = new Function(code.join(""))();
     if (proto) {
         ctor.prototype = proto;
@@ -113,7 +114,9 @@ var AST_Node = DEFNODE("Node", "start end", {
     walk: function(visitor) {
         visitor.visit(this);
     },
-    _validate: noop,
+    _validate: function() {
+        if (this.TYPE == "Node") throw new Error("should not instantiate AST_Node");
+    },
     validate: function() {
         var ctor = this.CTOR;
         do {
@@ -137,7 +140,7 @@ var AST_Node = DEFNODE("Node", "start end", {
 }, null);
 
 (AST_Node.log_function = function(fn, verbose) {
-    if (!fn) {
+    if (typeof fn != "function") {
         AST_Node.info = AST_Node.warn = noop;
         return;
     }
@@ -187,19 +190,26 @@ AST_Node.disable_validation = function() {
 
 var AST_Statement = DEFNODE("Statement", null, {
     $documentation: "Base class of all statements",
+    _validate: function() {
+        if (this.TYPE == "Statement") throw new Error("should not instantiate AST_Statement");
+    },
 });
 
 var AST_Debugger = DEFNODE("Debugger", null, {
     $documentation: "Represents a debugger statement",
 }, AST_Statement);
 
-var AST_Directive = DEFNODE("Directive", "value quote", {
+var AST_Directive = DEFNODE("Directive", "quote value", {
     $documentation: "Represents a directive, like \"use strict\";",
     $propdoc: {
+        quote: "[string?] the original quote character",
         value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
-        quote: "[string] the original quote character"
     },
     _validate: function() {
+        if (this.quote != null) {
+            if (typeof this.quote != "string") throw new Error("quote must be string");
+            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
+        }
         if (typeof this.value != "string") throw new Error("value must be string");
     },
 }, AST_Statement);
@@ -208,6 +218,12 @@ var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
     $documentation: "The empty statement (empty block or simply a semicolon)"
 }, AST_Statement);
 
+function is_statement(node) {
+    return node instanceof AST_Statement
+        && !(node instanceof AST_ClassExpression)
+        && !(node instanceof AST_LambdaExpression);
+}
+
 function validate_expression(value, prop, multiple, allow_spread, allow_hole) {
     multiple = multiple ? "contain" : "be";
     if (!(value instanceof AST_Node)) throw new Error(prop + " must " + multiple + " AST_Node");
@@ -215,9 +231,7 @@ function validate_expression(value, prop, multiple, allow_spread, allow_hole) {
     if (value instanceof AST_Destructured) throw new Error(prop + " cannot " + multiple + " AST_Destructured");
     if (value instanceof AST_Hole && !allow_hole) throw new Error(prop + " cannot " + multiple + " AST_Hole");
     if (value instanceof AST_Spread && !allow_spread) throw new Error(prop + " cannot " + multiple + " AST_Spread");
-    if (value instanceof AST_Statement && !is_function(value)) {
-        throw new Error(prop + " cannot " + multiple + " AST_Statement");
-    }
+    if (is_statement(value)) throw new Error(prop + " cannot " + multiple + " AST_Statement");
     if (value instanceof AST_SymbolDeclaration) {
         throw new Error(prop + " cannot " + multiple + " AST_SymbolDeclaration");
     }
@@ -230,7 +244,7 @@ function must_be_expression(node, prop) {
 var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
     $documentation: "A statement consisting of an expression, i.e. a = 1 + 2",
     $propdoc: {
-        body: "[AST_Node] an expression node (should not be instanceof AST_Statement)"
+        body: "[AST_Node] an expression node (should not be instanceof AST_Statement)",
     },
     walk: function(visitor) {
         var node = this;
@@ -247,9 +261,9 @@ var AST_BlockScope = DEFNODE("BlockScope", "enclosed functions make_def parent_s
     $documentation: "Base class for all statements introducing a lexical scope",
     $propdoc: {
         enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
-        functions: "[Object/S] like `variables`, but only lists function declarations",
+        functions: "[Dictionary/S] like `variables`, but only lists function declarations",
         parent_scope: "[AST_Scope?/S] link to the parent scope",
-        variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
+        variables: "[Dictionary/S] a map of name ---> SymbolDef for all variables/functions defined in this scope",
     },
     clone: function(deep) {
         var node = this._clone(deep);
@@ -265,6 +279,7 @@ var AST_BlockScope = DEFNODE("BlockScope", "enclosed functions make_def parent_s
         return this.parent_scope.resolve();
     },
     _validate: function() {
+        if (this.TYPE == "BlockScope") throw new Error("should not instantiate AST_BlockScope");
         if (this.parent_scope == null) return;
         if (!(this.parent_scope instanceof AST_BlockScope)) throw new Error("parent_scope must be AST_BlockScope");
         if (!(this.resolve() instanceof AST_Scope)) throw new Error("must be contained within AST_Scope");
@@ -289,9 +304,9 @@ var AST_Block = DEFNODE("Block", "body", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "Block") throw new Error("should not instantiate AST_Block");
         this.body.forEach(function(node) {
-            if (!(node instanceof AST_Statement)) throw new Error("body must be AST_Statement[]");
-            if (is_function(node)) throw new Error("body cannot contain AST_Function");
+            if (!is_statement(node)) throw new Error("body must contain AST_Statement");
         });
     },
 }, AST_BlockScope);
@@ -306,8 +321,8 @@ var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
         body: "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
     },
     _validate: function() {
-        if (!(this.body instanceof AST_Statement)) throw new Error("body must be AST_Statement");
-        if (is_function(this.body)) throw new Error("body cannot be AST_Function");
+        if (this.TYPE == "StatementWithBody") throw new Error("should not instantiate AST_StatementWithBody");
+        if (!is_statement(this.body)) throw new Error("body must be AST_Statement");
     },
 }, AST_BlockScope);
 
@@ -346,7 +361,10 @@ var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
 }, AST_StatementWithBody);
 
 var AST_IterationStatement = DEFNODE("IterationStatement", null, {
-    $documentation: "Internal class.  All loops inherit from it."
+    $documentation: "Internal class.  All loops inherit from it.",
+    _validate: function() {
+        if (this.TYPE == "IterationStatement") throw new Error("should not instantiate AST_IterationStatement");
+    },
 }, AST_StatementWithBody);
 
 var AST_DWLoop = DEFNODE("DWLoop", "condition", {
@@ -355,6 +373,7 @@ var AST_DWLoop = DEFNODE("DWLoop", "condition", {
         condition: "[AST_Node] the loop condition.  Should not be instanceof AST_Statement"
     },
     _validate: function() {
+        if (this.TYPE == "DWLoop") throw new Error("should not instantiate AST_DWLoop");
         must_be_expression(this, "condition");
     },
 }, AST_IterationStatement);
@@ -400,8 +419,7 @@ var AST_For = DEFNODE("For", "init condition step", {
     _validate: function() {
         if (this.init != null) {
             if (!(this.init instanceof AST_Node)) throw new Error("init must be AST_Node");
-            if (this.init instanceof AST_Statement
-                && !(this.init instanceof AST_Definitions || is_function(this.init))) {
+            if (is_statement(this.init) && !(this.init instanceof AST_Definitions)) {
                 throw new Error("init cannot be AST_Statement");
             }
         }
@@ -410,11 +428,11 @@ var AST_For = DEFNODE("For", "init condition step", {
     },
 }, AST_IterationStatement);
 
-var AST_ForIn = DEFNODE("ForIn", "init object", {
-    $documentation: "A `for ... in` statement",
+var AST_ForEnumeration = DEFNODE("ForEnumeration", "init object", {
+    $documentation: "Base class for enumeration loops, i.e. `for ... in`, `for ... of` & `for await ... of`",
     $propdoc: {
-        init: "[AST_Node] the `for/in` initialization code",
-        object: "[AST_Node] the object that we're looping through"
+        init: "[AST_Node] the assignment target during iteration",
+        object: "[AST_Node] the object to iterate over"
     },
     walk: function(visitor) {
         var node = this;
@@ -425,6 +443,7 @@ var AST_ForIn = DEFNODE("ForIn", "init object", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "ForEnumeration") throw new Error("should not instantiate AST_ForEnumeration");
         if (this.init instanceof AST_Definitions) {
             if (this.init.definitions.length != 1) throw new Error("init must have single declaration");
         } else {
@@ -438,6 +457,18 @@ var AST_ForIn = DEFNODE("ForIn", "init object", {
     },
 }, AST_IterationStatement);
 
+var AST_ForIn = DEFNODE("ForIn", null, {
+    $documentation: "A `for ... in` statement",
+}, AST_ForEnumeration);
+
+var AST_ForOf = DEFNODE("ForOf", null, {
+    $documentation: "A `for ... of` statement",
+}, AST_ForEnumeration);
+
+var AST_ForAwaitOf = DEFNODE("ForAwaitOf", null, {
+    $documentation: "A `for await ... of` statement",
+}, AST_ForOf);
+
 var AST_With = DEFNODE("With", "expression", {
     $documentation: "A `with` statement",
     $propdoc: {
@@ -467,12 +498,15 @@ var AST_Scope = DEFNODE("Scope", "uses_eval uses_with", {
         return this.uses_eval || this.uses_with;
     },
     resolve: return_this,
+    _validate: function() {
+        if (this.TYPE == "Scope") throw new Error("should not instantiate AST_Scope");
+    },
 }, AST_Block);
 
 var AST_Toplevel = DEFNODE("Toplevel", "globals", {
     $documentation: "The toplevel scope",
     $propdoc: {
-        globals: "[Object/S] a map of name -> SymbolDef for all undeclared names",
+        globals: "[Dictionary/S] a map of name ---> SymbolDef for all undeclared names",
     },
     wrap: function(name) {
         var body = this.body;
@@ -517,8 +551,9 @@ var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest uses_arguments", {
     $documentation: "Base class for functions",
     $propdoc: {
         argnames: "[(AST_DefaultValue|AST_Destructured|AST_SymbolFunarg)*] array of function arguments and/or destructured literals",
+        length_read: "[boolean/S] whether length property of this function is accessed",
         rest: "[(AST_Destructured|AST_SymbolFunarg)?] rest parameter, or null if absent",
-        uses_arguments: "[boolean/S] tells whether this function accesses the arguments array",
+        uses_arguments: "[boolean/S] whether this function accesses the arguments array",
     },
     each_argname: function(visit) {
         var tw = new TreeWalker(function(node) {
@@ -549,6 +584,7 @@ var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest uses_arguments", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "Lambda") throw new Error("should not instantiate AST_Lambda");
         this.argnames.forEach(function(node) {
             validate_destructured(node, function(node) {
                 if (!(node instanceof AST_SymbolFunarg)) throw new Error("argnames must be AST_SymbolFunarg[]");
@@ -567,12 +603,33 @@ var AST_Accessor = DEFNODE("Accessor", null, {
     },
 }, AST_Lambda);
 
+var AST_LambdaExpression = DEFNODE("LambdaExpression", "inlined", {
+    $documentation: "Base class for function expressions",
+    $propdoc: {
+        inlined: "[boolean/S] whether this function has been inlined",
+    },
+    _validate: function() {
+        if (this.TYPE == "LambdaExpression") throw new Error("should not instantiate AST_LambdaExpression");
+    },
+}, AST_Lambda);
+
 function is_arrow(node) {
-    return node instanceof AST_AsyncArrow || node instanceof AST_Arrow;
+    return node instanceof AST_Arrow || node instanceof AST_AsyncArrow;
 }
 
-function is_function(node) {
-    return is_arrow(node) || node instanceof AST_AsyncFunction || node instanceof AST_Function;
+function is_async(node) {
+    return node instanceof AST_AsyncArrow
+        || node instanceof AST_AsyncDefun
+        || node instanceof AST_AsyncFunction
+        || node instanceof AST_AsyncGeneratorDefun
+        || node instanceof AST_AsyncGeneratorFunction;
+}
+
+function is_generator(node) {
+    return node instanceof AST_AsyncGeneratorDefun
+        || node instanceof AST_AsyncGeneratorFunction
+        || node instanceof AST_GeneratorDefun
+        || node instanceof AST_GeneratorFunction;
 }
 
 function walk_lambda(node, tw) {
@@ -583,7 +640,7 @@ function walk_lambda(node, tw) {
     }
 }
 
-var AST_Arrow = DEFNODE("Arrow", "inlined value", {
+var AST_Arrow = DEFNODE("Arrow", "value", {
     $documentation: "An arrow function expression",
     $propdoc: {
         value: "[AST_Node?] simple return expression, or null if using function body.",
@@ -610,13 +667,9 @@ var AST_Arrow = DEFNODE("Arrow", "inlined value", {
             if (this.body.length) throw new Error("body must be empty if value exists");
         }
     },
-}, AST_Lambda);
+}, AST_LambdaExpression);
 
-function is_async(node) {
-    return node instanceof AST_AsyncArrow || node instanceof AST_AsyncDefun || node instanceof AST_AsyncFunction;
-}
-
-var AST_AsyncArrow = DEFNODE("AsyncArrow", "inlined value", {
+var AST_AsyncArrow = DEFNODE("AsyncArrow", "value", {
     $documentation: "An asynchronous arrow function expression",
     $propdoc: {
         value: "[AST_Node?] simple return expression, or null if using function body.",
@@ -643,60 +696,197 @@ var AST_AsyncArrow = DEFNODE("AsyncArrow", "inlined value", {
             if (this.body.length) throw new Error("body must be empty if value exists");
         }
     },
-}, AST_Lambda);
+}, AST_LambdaExpression);
 
-var AST_AsyncFunction = DEFNODE("AsyncFunction", "inlined name", {
+var AST_AsyncFunction = DEFNODE("AsyncFunction", "name", {
     $documentation: "An asynchronous function expression",
     $propdoc: {
-        name: "[AST_SymbolLambda?] the name of this function",
+        name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
     },
     _validate: function() {
         if (this.name != null) {
             if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
         }
     },
-}, AST_Lambda);
+}, AST_LambdaExpression);
 
-var AST_Function = DEFNODE("Function", "inlined name", {
+var AST_AsyncGeneratorFunction = DEFNODE("AsyncGeneratorFunction", "name", {
+    $documentation: "An asynchronous generator function expression",
+    $propdoc: {
+        name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
+    },
+    _validate: function() {
+        if (this.name != null) {
+            if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
+        }
+    },
+}, AST_LambdaExpression);
+
+var AST_Function = DEFNODE("Function", "name", {
     $documentation: "A function expression",
     $propdoc: {
-        name: "[AST_SymbolLambda?] the name of this function",
+        name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
     },
     _validate: function() {
         if (this.name != null) {
             if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
         }
     },
+}, AST_LambdaExpression);
+
+var AST_GeneratorFunction = DEFNODE("GeneratorFunction", "name", {
+    $documentation: "A generator function expression",
+    $propdoc: {
+        name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
+    },
+    _validate: function() {
+        if (this.name != null) {
+            if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
+        }
+    },
+}, AST_LambdaExpression);
+
+var AST_LambdaDefinition = DEFNODE("LambdaDefinition", "inlined name", {
+    $documentation: "Base class for function definitions",
+    $propdoc: {
+        inlined: "[boolean/S] whether this function has been inlined",
+        name: "[AST_SymbolDefun] the name of this function",
+    },
+    _validate: function() {
+        if (this.TYPE == "LambdaDefinition") throw new Error("should not instantiate AST_LambdaDefinition");
+        if (!(this.name instanceof AST_SymbolDefun)) throw new Error("name must be AST_SymbolDefun");
+    },
 }, AST_Lambda);
 
-function is_defun(node) {
-    return node instanceof AST_AsyncDefun || node instanceof AST_Defun;
-}
-
-var AST_AsyncDefun = DEFNODE("AsyncDefun", "inlined name", {
+var AST_AsyncDefun = DEFNODE("AsyncDefun", null, {
     $documentation: "An asynchronous function definition",
-    $propdoc: {
-        name: "[AST_SymbolDefun] the name of this function",
-    },
-    _validate: function() {
-        if (!(this.name instanceof AST_SymbolDefun)) throw new Error("name must be AST_SymbolDefun");
-    },
-}, AST_Lambda);
+}, AST_LambdaDefinition);
 
-var AST_Defun = DEFNODE("Defun", "inlined name", {
+var AST_AsyncGeneratorDefun = DEFNODE("AsyncGeneratorDefun", null, {
+    $documentation: "An asynchronous generator function definition",
+}, AST_LambdaDefinition);
+
+var AST_Defun = DEFNODE("Defun", null, {
     $documentation: "A function definition",
+}, AST_LambdaDefinition);
+
+var AST_GeneratorDefun = DEFNODE("GeneratorDefun", null, {
+    $documentation: "A generator function definition",
+}, AST_LambdaDefinition);
+
+/* -----[ classes ]----- */
+
+var AST_Class = DEFNODE("Class", "extends name properties", {
+    $documentation: "Base class for class literals",
     $propdoc: {
-        name: "[AST_SymbolDefun] the name of this function",
+        extends: "[AST_Node?] the super class, or null if not specified",
+        properties: "[AST_ClassProperty*] array of class properties",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.name) node.name.walk(visitor);
+            if (node.extends) node.extends.walk(visitor);
+            node.properties.forEach(function(prop) {
+                prop.walk(visitor);
+            });
+        });
     },
     _validate: function() {
-        if (!(this.name instanceof AST_SymbolDefun)) throw new Error("name must be AST_SymbolDefun");
+        if (this.TYPE == "Class") throw new Error("should not instantiate AST_Class");
+        if (this.extends != null) must_be_expression(this, "extends");
+        this.properties.forEach(function(node) {
+            if (!(node instanceof AST_ClassProperty)) throw new Error("properties must contain AST_ClassProperty");
+        });
     },
-}, AST_Lambda);
+}, AST_BlockScope);
+
+var AST_DefClass = DEFNODE("DefClass", null, {
+    $documentation: "A class definition",
+    $propdoc: {
+        name: "[AST_SymbolDefClass] the name of this class",
+    },
+    _validate: function() {
+        if (!(this.name instanceof AST_SymbolDefClass)) throw new Error("name must be AST_SymbolDefClass");
+    },
+}, AST_Class);
+
+var AST_ClassExpression = DEFNODE("ClassExpression", null, {
+    $documentation: "A class expression",
+    $propdoc: {
+        name: "[AST_SymbolClass?] the name of this class, or null if not specified",
+    },
+    _validate: function() {
+        if (this.name != null) {
+            if (!(this.name instanceof AST_SymbolClass)) throw new Error("name must be AST_SymbolClass");
+        }
+    },
+}, AST_Class);
+
+var AST_ClassProperty = DEFNODE("ClassProperty", "key private static value", {
+    $documentation: "Base class for `class` properties",
+    $propdoc: {
+        key: "[string|AST_Node] property name (AST_Node for computed property)",
+        private: "[boolean] whether this is a private property",
+        static: "[boolean] whether this is a static property",
+        value: "[AST_Node?] property value (AST_Accessor for getters/setters, AST_LambdaExpression for methods, null if not specified for fields)",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.key instanceof AST_Node) node.key.walk(visitor);
+            if (node.value) node.value.walk(visitor);
+        });
+    },
+    _validate: function() {
+        if (this.TYPE == "ClassProperty") throw new Error("should not instantiate AST_ClassProperty");
+        if (typeof this.key != "string") {
+            if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
+            must_be_expression(this, "key");
+        }
+        if(this.value != null) {
+            if (!(this.value instanceof AST_Node)) throw new Error("value must be AST_Node");
+        }
+    },
+});
+
+var AST_ClassField = DEFNODE("ClassField", null, {
+    $documentation: "A `class` field",
+    _validate: function() {
+        if(this.value != null) must_be_expression(this, "value");
+    },
+}, AST_ClassProperty);
+
+var AST_ClassGetter = DEFNODE("ClassGetter", null, {
+    $documentation: "A `class` getter",
+    _validate: function() {
+        if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor");
+    },
+}, AST_ClassProperty);
+
+var AST_ClassSetter = DEFNODE("ClassSetter", null, {
+    $documentation: "A `class` setter",
+    _validate: function() {
+        if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor");
+    },
+}, AST_ClassProperty);
+
+var AST_ClassMethod = DEFNODE("ClassMethod", null, {
+    $documentation: "A `class` method",
+    _validate: function() {
+        if (!(this.value instanceof AST_LambdaExpression)) throw new Error("value must be AST_LambdaExpression");
+        if (is_arrow(this.value)) throw new Error("value cannot be AST_Arrow or AST_AsyncArrow");
+        if (this.value.name != null) throw new Error("name of class method's lambda must be null");
+    },
+}, AST_ClassProperty);
 
 /* -----[ JUMPS ]----- */
 
 var AST_Jump = DEFNODE("Jump", null, {
-    $documentation: "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)"
+    $documentation: "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)",
+    _validate: function() {
+        if (this.TYPE == "Jump") throw new Error("should not instantiate AST_Jump");
+    },
 }, AST_Statement);
 
 var AST_Exit = DEFNODE("Exit", "value", {
@@ -709,7 +899,10 @@ var AST_Exit = DEFNODE("Exit", "value", {
         visitor.visit(node, function() {
             if (node.value) node.value.walk(visitor);
         });
-    }
+    },
+    _validate: function() {
+        if (this.TYPE == "Exit") throw new Error("should not instantiate AST_Exit");
+    },
 }, AST_Jump);
 
 var AST_Return = DEFNODE("Return", null, {
@@ -738,6 +931,7 @@ var AST_LoopControl = DEFNODE("LoopControl", "label", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "LoopControl") throw new Error("should not instantiate AST_LoopControl");
         if (this.label != null) {
             if (!(this.label instanceof AST_LabelRef)) throw new Error("label must be AST_LabelRef");
         }
@@ -771,8 +965,7 @@ var AST_If = DEFNODE("If", "condition alternative", {
     _validate: function() {
         must_be_expression(this, "condition");
         if (this.alternative != null) {
-            if (!(this.alternative instanceof AST_Statement)) throw new Error("alternative must be AST_Statement");
-            if (is_function(this.alternative)) throw new error("alternative cannot be AST_Function");
+            if (!is_statement(this.alternative)) throw new Error("alternative must be AST_Statement");
         }
     },
 }, AST_StatementWithBody);
@@ -801,6 +994,9 @@ var AST_Switch = DEFNODE("Switch", "expression", {
 
 var AST_SwitchBranch = DEFNODE("SwitchBranch", null, {
     $documentation: "Base class for `switch` branches",
+    _validate: function() {
+        if (this.TYPE == "SwitchBranch") throw new Error("should not instantiate AST_SwitchBranch");
+    },
 }, AST_Block);
 
 var AST_Default = DEFNODE("Default", null, {
@@ -889,6 +1085,7 @@ var AST_Definitions = DEFNODE("Definitions", "definitions", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "Definitions") throw new Error("should not instantiate AST_Definitions");
         if (this.definitions.length < 1) throw new Error("must have at least one definition");
     },
 }, AST_Statement);
@@ -949,6 +1146,129 @@ var AST_VarDef = DEFNODE("VarDef", "name value", {
 
 /* -----[ OTHER ]----- */
 
+var AST_ExportDeclaration = DEFNODE("ExportDeclaration", "body", {
+    $documentation: "An `export` statement",
+    $propdoc: {
+        body: "[AST_DefClass|AST_Definitions|AST_LambdaDefinition] the statement to export",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            node.body.walk(visitor);
+        });
+    },
+    _validate: function() {
+        if (!(this.body instanceof AST_DefClass
+            || this.body instanceof AST_Definitions
+            || this.body instanceof AST_LambdaDefinition)) {
+            throw new Error("body must be AST_DefClass, AST_Definitions or AST_LambdaDefinition");
+        }
+    },
+}, AST_Statement);
+
+var AST_ExportDefault = DEFNODE("ExportDefault", "body", {
+    $documentation: "An `export default` statement",
+    $propdoc: {
+        body: "[AST_Node] the default export",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            node.body.walk(visitor);
+        });
+    },
+    _validate: function() {
+        if (!(this.body instanceof AST_DefClass || this.body instanceof AST_LambdaDefinition)) {
+            must_be_expression(this, "body");
+        }
+    },
+}, AST_Statement);
+
+var AST_ExportForeign = DEFNODE("ExportForeign", "aliases keys path quote", {
+    $documentation: "An `export ... from '...'` statement",
+    $propdoc: {
+        aliases: "[string*] array of aliases to export",
+        keys: "[string*] array of keys to import",
+        path: "[string] the path to import module",
+        quote: "[string?] the original quote character",
+    },
+    _validate: function() {
+        if (this.aliases.length != this.keys.length) {
+            throw new Error("aliases:key length mismatch: " + this.aliases.length + " != " + this.keys.length);
+        }
+        this.aliases.forEach(function(name) {
+            if (typeof name != "string") throw new Error("aliases must contain string");
+        });
+        this.keys.forEach(function(name) {
+            if (typeof name != "string") throw new Error("keys must contain string");
+        });
+        if (typeof this.path != "string") throw new Error("path must be string");
+        if (this.quote != null) {
+            if (typeof this.quote != "string") throw new Error("quote must be string");
+            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
+        }
+    },
+}, AST_Statement);
+
+var AST_ExportReferences = DEFNODE("ExportReferences", "properties", {
+    $documentation: "An `export { ... }` statement",
+    $propdoc: {
+        properties: "[AST_SymbolExport*] array of aliases to export",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            node.properties.forEach(function(prop) {
+                prop.walk(visitor);
+            });
+        });
+    },
+    _validate: function() {
+        this.properties.forEach(function(prop) {
+            if (!(prop instanceof AST_SymbolExport)) throw new Error("properties must contain AST_SymbolExport");
+        });
+    },
+}, AST_Statement);
+
+var AST_Import = DEFNODE("Import", "all default path properties quote", {
+    $documentation: "An `import` statement",
+    $propdoc: {
+        all: "[AST_SymbolImport?] the imported namespace, or null if not specified",
+        default: "[AST_SymbolImport?] the alias for default `export`, or null if not specified",
+        path: "[string] the path to import module",
+        properties: "[(AST_SymbolImport*)?] array of aliases, or null if not specified",
+        quote: "[string?] the original quote character",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.all) node.all.walk(visitor);
+            if (node.default) node.default.walk(visitor);
+            if (node.properties) node.properties.forEach(function(prop) {
+                prop.walk(visitor);
+            });
+        });
+    },
+    _validate: function() {
+        if (this.all != null) {
+            if (!(this.all instanceof AST_SymbolImport)) throw new Error("all must be AST_SymbolImport");
+            if (this.properties != null) throw new Error("cannot import both * and {} in the same statement");
+        }
+        if (this.default != null) {
+            if (!(this.default instanceof AST_SymbolImport)) throw new Error("default must be AST_SymbolImport");
+            if (this.default.key !== "") throw new Error("invalid default key: " + this.default.key);
+        }
+        if (typeof this.path != "string") throw new Error("path must be string");
+        if (this.properties != null) this.properties.forEach(function(node) {
+            if (!(node instanceof AST_SymbolImport)) throw new Error("properties must contain AST_SymbolImport");
+        });
+        if (this.quote != null) {
+            if (typeof this.quote != "string") throw new Error("quote must be string");
+            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
+        }
+    },
+}, AST_Statement);
+
 var AST_DefaultValue = DEFNODE("DefaultValue", "name value", {
     $documentation: "A default value declaration",
     $propdoc: {
@@ -973,11 +1293,13 @@ function must_be_expressions(node, prop, allow_spread, allow_hole) {
     });
 }
 
-var AST_Call = DEFNODE("Call", "expression args pure", {
+var AST_Call = DEFNODE("Call", "args expression optional pure", {
     $documentation: "A function call expression",
     $propdoc: {
+        args: "[AST_Node*] array of arguments",
         expression: "[AST_Node] expression to invoke as function",
-        args: "[AST_Node*] array of arguments"
+        optional: "[boolean] whether the expression is optional chaining",
+        pure: "[string/S] marker for side-effect-free call expression",
     },
     walk: function(visitor) {
         var node = this;
@@ -995,7 +1317,10 @@ var AST_Call = DEFNODE("Call", "expression args pure", {
 });
 
 var AST_New = DEFNODE("New", null, {
-    $documentation: "An object instantiation.  Derives from a function call since it has exactly the same properties"
+    $documentation: "An object instantiation.  Derives from a function call since it has exactly the same properties",
+    _validate: function() {
+        if (this.optional) throw new Error("optional must be false");
+    },
 }, AST_Call);
 
 var AST_Sequence = DEFNODE("Sequence", "expressions", {
@@ -1017,11 +1342,12 @@ var AST_Sequence = DEFNODE("Sequence", "expressions", {
     },
 });
 
-var AST_PropAccess = DEFNODE("PropAccess", "expression property", {
+var AST_PropAccess = DEFNODE("PropAccess", "expression optional property", {
     $documentation: "Base class for property access expressions, i.e. `a.foo` or `a[\"foo\"]`",
     $propdoc: {
         expression: "[AST_Node] the “container” expression",
-        property: "[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node"
+        optional: "[boolean] whether the expression is optional chaining",
+        property: "[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node",
     },
     getProperty: function() {
         var p = this.property;
@@ -1036,6 +1362,7 @@ var AST_PropAccess = DEFNODE("PropAccess", "expression property", {
         return p;
     },
     _validate: function() {
+        if (this.TYPE == "PropAccess") throw new Error("should not instantiate AST_PropAccess");
         must_be_expression(this, "expression");
     },
 });
@@ -1096,6 +1423,7 @@ var AST_Unary = DEFNODE("Unary", "operator expression", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "Unary") throw new Error("should not instantiate AST_Unary");
         if (typeof this.operator != "string") throw new Error("operator must be string");
         must_be_expression(this, "expression");
     },
@@ -1183,6 +1511,27 @@ var AST_Await = DEFNODE("Await", "expression", {
     },
 });
 
+var AST_Yield = DEFNODE("Yield", "expression nested", {
+    $documentation: "A yield expression",
+    $propdoc: {
+        expression: "[AST_Node?] return value for iterator, or null if undefined",
+        nested: "[boolean] whether to iterate over expression as generator",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.expression) node.expression.walk(visitor);
+        });
+    },
+    _validate: function() {
+        if (this.expression != null) {
+            must_be_expression(this, "expression");
+        } else if (this.nested) {
+            throw new Error("yield* must contain expression");
+        }
+    },
+});
+
 /* -----[ LITERALS ]----- */
 
 var AST_Array = DEFNODE("Array", "elements", {
@@ -1208,6 +1557,9 @@ var AST_Destructured = DEFNODE("Destructured", "rest", {
     $propdoc: {
         rest: "[(AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef)?] rest parameter, or null if absent",
     },
+    _validate: function() {
+        if (this.TYPE == "Destructured") throw new Error("should not instantiate AST_Destructured");
+    },
 });
 
 function validate_destructured(node, check, allow_default) {
@@ -1319,6 +1671,7 @@ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "ObjectProperty") throw new Error("should not instantiate AST_ObjectProperty");
         if (typeof this.key != "string") {
             if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
             must_be_expression(this, "key");
@@ -1334,6 +1687,15 @@ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", null, {
     },
 }, AST_ObjectProperty);
 
+var AST_ObjectMethod = DEFNODE("ObjectMethod", null, {
+    $documentation: "A key(){} object property",
+    _validate: function() {
+        if (!(this.value instanceof AST_LambdaExpression)) throw new Error("value must be AST_LambdaExpression");
+        if (is_arrow(this.value)) throw new Error("value cannot be AST_Arrow or AST_AsyncArrow");
+        if (this.value.name != null) throw new Error("name of object method's lambda must be null");
+    },
+}, AST_ObjectKeyVal);
+
 var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
     $documentation: "An object setter property",
     _validate: function() {
@@ -1356,6 +1718,7 @@ var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
         thedef: "[SymbolDef/S] the definition of this symbol"
     },
     _validate: function() {
+        if (this.TYPE == "Symbol") throw new Error("should not instantiate AST_Symbol");
         if (typeof this.name != "string") throw new Error("name must be string");
     },
 });
@@ -1368,6 +1731,16 @@ var AST_SymbolConst = DEFNODE("SymbolConst", null, {
     $documentation: "Symbol defining a constant",
 }, AST_SymbolDeclaration);
 
+var AST_SymbolImport = DEFNODE("SymbolImport", "key", {
+    $documentation: "Symbol defined by an `import` statement",
+    $propdoc: {
+        key: "[string] the original `export` name",
+    },
+    _validate: function() {
+        if (typeof this.key != "string") throw new Error("key must be string");
+    },
+}, AST_SymbolConst);
+
 var AST_SymbolLet = DEFNODE("SymbolLet", null, {
     $documentation: "Symbol defining a lexical-scoped variable",
 }, AST_SymbolDeclaration);
@@ -1388,6 +1761,14 @@ var AST_SymbolLambda = DEFNODE("SymbolLambda", null, {
     $documentation: "Symbol naming a function expression",
 }, AST_SymbolDeclaration);
 
+var AST_SymbolDefClass = DEFNODE("SymbolDefClass", null, {
+    $documentation: "Symbol defining a class",
+}, AST_SymbolLet);
+
+var AST_SymbolClass = DEFNODE("SymbolClass", null, {
+    $documentation: "Symbol naming a class expression",
+}, AST_SymbolLet);
+
 var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
     $documentation: "Symbol naming the exception in catch",
 }, AST_SymbolDeclaration);
@@ -1407,28 +1788,97 @@ var AST_SymbolRef = DEFNODE("SymbolRef", "fixed in_arg redef", {
     $documentation: "Reference to some symbol (not definition/declaration)",
 }, AST_Symbol);
 
+var AST_SymbolExport = DEFNODE("SymbolExport", "alias", {
+    $documentation: "Reference in an `export` statement",
+    $propdoc: {
+        alias: "[string] the `export` alias",
+    },
+    _validate: function() {
+        if (typeof this.alias != "string") throw new Error("alias must be string");
+    },
+}, AST_SymbolRef);
+
 var AST_LabelRef = DEFNODE("LabelRef", null, {
     $documentation: "Reference to a label symbol",
 }, AST_Symbol);
 
-var AST_This = DEFNODE("This", null, {
-    $documentation: "The `this` symbol",
+var AST_ObjectIdentity = DEFNODE("ObjectIdentity", null, {
+    $documentation: "Base class for `super` & `this`",
     _validate: function() {
-        if (this.name !== "this") throw new Error('name must be "this"');
+        if (this.TYPE == "ObjectIdentity") throw new Error("should not instantiate AST_ObjectIdentity");
     },
 }, AST_Symbol);
 
-var AST_Constant = DEFNODE("Constant", null, {
-    $documentation: "Base class for all constants",
-});
+var AST_Super = DEFNODE("Super", null, {
+    $documentation: "The `super` symbol",
+    _validate: function() {
+        if (this.name !== "super") throw new Error('name must be "super"');
+    },
+}, AST_ObjectIdentity);
 
-var AST_String = DEFNODE("String", "value quote", {
-    $documentation: "A string literal",
-    $propdoc: {
-        value: "[string] the contents of this string",
-        quote: "[string] the original quote character"
+var AST_This = DEFNODE("This", null, {
+    $documentation: "The `this` symbol",
+    _validate: function() {
+        if (this.TYPE == "This" && this.name !== "this") throw new Error('name must be "this"');
+    },
+}, AST_ObjectIdentity);
+
+var AST_NewTarget = DEFNODE("NewTarget", null, {
+    $documentation: "The `new.target` symbol",
+    initialize: function() {
+        this.name = "new.target";
     },
     _validate: function() {
+        if (this.name !== "new.target") throw new Error('name must be "new.target": ' + this.name);
+    },
+}, AST_This);
+
+var AST_Template = DEFNODE("Template", "expressions strings tag", {
+    $documentation: "A template literal, i.e. tag`str1${expr1}...strN${exprN}strN+1`",
+    $propdoc: {
+        expressions: "[AST_Node*] the placeholder expressions",
+        strings: "[string*] the raw text segments",
+        tag: "[AST_Node] tag function, or null if absent",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.tag) node.tag.walk(visitor);
+            node.expressions.forEach(function(expr) {
+                expr.walk(visitor);
+            });
+        });
+    },
+    _validate: function() {
+        if (this.expressions.length + 1 != this.strings.length) {
+            throw new Error("malformed template with " + this.expressions.length + " placeholder(s) but " + this.strings.length + " text segment(s)");
+        }
+        must_be_expressions(this, "expressions");
+        this.strings.forEach(function(string) {
+            if (typeof string != "string") throw new Error("strings must contain string");
+        });
+        if (this.tag != null) must_be_expression(this, "tag");
+    },
+});
+
+var AST_Constant = DEFNODE("Constant", null, {
+    $documentation: "Base class for all constants",
+    _validate: function() {
+        if (this.TYPE == "Constant") throw new Error("should not instantiate AST_Constant");
+    },
+});
+
+var AST_String = DEFNODE("String", "quote value", {
+    $documentation: "A string literal",
+    $propdoc: {
+        quote: "[string?] the original quote character",
+        value: "[string] the contents of this string",
+    },
+    _validate: function() {
+        if (this.quote != null) {
+            if (typeof this.quote != "string") throw new Error("quote must be string");
+            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
+        }
         if (typeof this.value != "string") throw new Error("value must be string");
     },
 }, AST_Constant);
@@ -1440,6 +1890,19 @@ var AST_Number = DEFNODE("Number", "value", {
     },
     _validate: function() {
         if (typeof this.value != "number") throw new Error("value must be number");
+        if (!isFinite(this.value)) throw new Error("value must be finite");
+        if (this.value < 0) throw new Error("value cannot be negative");
+    },
+}, AST_Constant);
+
+var AST_BigInt = DEFNODE("BigInt", "value", {
+    $documentation: "A BigInt literal",
+    $propdoc: {
+        value: "[string] the numeric representation",
+    },
+    _validate: function() {
+        if (typeof this.value != "string") throw new Error("value must be string");
+        if (this.value[0] == "-") throw new Error("value cannot be negative");
     },
 }, AST_Constant);
 
@@ -1455,6 +1918,9 @@ var AST_RegExp = DEFNODE("RegExp", "value", {
 
 var AST_Atom = DEFNODE("Atom", null, {
     $documentation: "Base class for atoms",
+    _validate: function() {
+        if (this.TYPE == "Atom") throw new Error("should not instantiate AST_Atom");
+    },
 }, AST_Constant);
 
 var AST_Null = DEFNODE("Null", null, {
@@ -1484,6 +1950,9 @@ var AST_Infinity = DEFNODE("Infinity", null, {
 
 var AST_Boolean = DEFNODE("Boolean", null, {
     $documentation: "Base class for booleans",
+    _validate: function() {
+        if (this.TYPE == "Boolean") throw new Error("should not instantiate AST_Boolean");
+    },
 }, AST_Atom);
 
 var AST_False = DEFNODE("False", null, {
@@ -1522,7 +1991,8 @@ TreeWalker.prototype = {
         this.stack.push(node);
     },
     pop: function() {
-        if (this.stack.pop() instanceof AST_Lambda) {
+        var node = this.stack.pop();
+        if (node instanceof AST_Lambda) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
     },

lib/minify.js

@@ -47,14 +47,12 @@ function parse_source_map(content) {
 }
 
 function set_shorthand(name, options, keys) {
-    if (options[name]) {
-        keys.forEach(function(key) {
-            if (options[key]) {
-                if (typeof options[key] != "object") options[key] = {};
-                if (!(name in options[key])) options[key][name] = options[name];
-            }
-        });
-    }
+    keys.forEach(function(key) {
+        if (options[key]) {
+            if (typeof options[key] != "object") options[key] = {};
+            if (!(name in options[key])) options[key][name] = options[name];
+        }
+    });
 }
 
 function init_cache(cache) {
@@ -75,6 +73,7 @@ function to_json(cache) {
 function minify(files, options) {
     try {
         options = defaults(options, {
+            annotations: undefined,
             compress: {},
             enclose: false,
             ie8: false,
@@ -94,17 +93,14 @@ function minify(files, options) {
             wrap: false,
         }, 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;
-        }
-        set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
-        set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
-        set_shorthand("toplevel", options, [ "compress", "mangle" ]);
-        set_shorthand("v8", options, [ "mangle", "output" ]);
-        set_shorthand("webkit", options, [ "mangle", "output" ]);
+        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, [ "mangle", "output" ]);
         var quoted_props;
         if (options.mangle) {
             options.mangle = defaults(options.mangle, {
@@ -208,27 +204,29 @@ function minify(files, options) {
         if (options.mangle && options.mangle.properties) mangle_properties(toplevel, options.mangle.properties);
         if (timings) timings.output = Date.now();
         var result = {};
-        if (options.output.ast) {
-            result.ast = toplevel;
-        }
-        if (!HOP(options.output, "code") || options.output.code) {
+        var output = defaults(options.output, {
+            ast: false,
+            code: true,
+        });
+        if (output.ast) result.ast = toplevel;
+        if (output.code) {
             if (options.sourceMap) {
-                options.output.source_map = SourceMap(options.sourceMap);
+                output.source_map = SourceMap(options.sourceMap);
                 if (options.sourceMap.includeSources) {
                     if (files instanceof AST_Toplevel) {
                         throw new Error("original source content unavailable");
                     } else for (var name in files) if (HOP(files, name)) {
-                        options.output.source_map.setSourceContent(name, files[name]);
+                        output.source_map.setSourceContent(name, files[name]);
                     }
                 }
             }
-            delete options.output.ast;
-            delete options.output.code;
-            var stream = OutputStream(options.output);
+            delete output.ast;
+            delete output.code;
+            var stream = OutputStream(output);
             toplevel.print(stream);
             result.code = stream.get();
             if (options.sourceMap) {
-                result.map = options.output.source_map.toString();
+                result.map = output.source_map.toString();
                 var url = options.sourceMap.url;
                 if (url) {
                     result.code = result.code.replace(/\n\/\/# sourceMappingURL=\S+\s*$/, "");

lib/propmangle.js

@@ -81,7 +81,9 @@ var builtins = function() {
 
 function reserve_quoted_keys(ast, reserved) {
     ast.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_ObjectProperty) {
+        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);
         } else if (node instanceof AST_Sub) {
             addStrings(node.property, add);
@@ -163,6 +165,8 @@ 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_Dot) {
             add(node.property);
         } else if (node instanceof AST_ObjectProperty) {
@@ -193,6 +197,8 @@ 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_Dot) {
             node.property = mangle(node.property);
         } else if (node instanceof AST_ObjectProperty) {
@@ -222,13 +228,11 @@ function mangle_properties(ast, options) {
     }
 
     function mangle(name) {
-        if (!should_mangle(name)) {
-            return name;
-        }
+        if (!should_mangle(name)) return name;
         var mangled = cache.get(name);
         if (!mangled) {
             if (debug) {
-                // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.
+                // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo ---> o._$foo$NNN_.
                 var debug_mangled = "_$" + name + "$" + debug_suffix + "_";
                 if (can_mangle(debug_mangled)) mangled = debug_mangled;
             }
@@ -236,6 +240,7 @@ function mangle_properties(ast, options) {
             if (!mangled) do {
                 mangled = base54(++cname);
             } while (!can_mangle(mangled));
+            if (/^#/.test(name)) mangled = "#" + mangled;
             cache.set(name, mangled);
         }
         return mangled;

lib/scope.js

@@ -45,6 +45,7 @@
 
 function SymbolDef(id, scope, orig, init) {
     this.eliminated = 0;
+    this.exported = false;
     this.global = false;
     this.id = id;
     this.init = init;
@@ -79,28 +80,41 @@ SymbolDef.prototype = {
         }
     },
     redefined: function() {
-        var scope = this.defun;
+        var self = this;
+        var scope = self.defun;
         if (!scope) return;
-        var name = this.name;
+        var name = self.name;
         var def = scope.variables.get(name)
             || scope instanceof AST_Toplevel && scope.globals.get(name)
-            || this.orig[0] instanceof AST_SymbolConst && find_if(function(def) {
+            || self.orig[0] instanceof AST_SymbolConst && find_if(function(def) {
                 return def.name == name;
             }, scope.enclosed);
-        if (def && def !== this) return def.redefined() || def;
+        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_SymbolLambda
-                    || this.orig[0] instanceof AST_SymbolDefun);
+                && (this.orig[0] instanceof AST_SymbolClass
+                    || this.orig[0] instanceof AST_SymbolDefClass
+                    || this.orig[0] instanceof AST_SymbolDefun
+                    || this.orig[0] instanceof AST_SymbolLambda);
     },
 };
 
 var unary_side_effects = makePredicate("delete ++ --");
 
+function is_lhs(node, parent) {
+    if (parent instanceof AST_Assign) return parent.left === node && node;
+    if (parent instanceof AST_DefaultValue) return parent.name === node && node;
+    if (parent instanceof AST_Destructured) return node;
+    if (parent instanceof AST_DestructuredKeyVal) return node;
+    if (parent instanceof AST_ForEnumeration) return parent.init === node && node;
+    if (parent instanceof AST_Unary) return unary_side_effects[parent.operator] && parent.expression;
+}
+
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     options = defaults(options, {
         cache: null,
@@ -110,11 +124,35 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     // pass 1: setup scope chaining and handle definitions
     var self = this;
     var defun = null;
+    var exported = false;
     var next_def_id = 0;
     var scope = self.parent_scope = null;
     var tw = new TreeWalker(function(node, descend) {
-        if (is_defun(node)) {
+        if (node instanceof AST_DefClass) {
+            var save_exported = exported;
+            exported = tw.parent() instanceof AST_ExportDeclaration;
             node.name.walk(tw);
+            exported = save_exported;
+            walk_scope(function() {
+                if (node.extends) node.extends.walk(tw);
+                node.properties.forEach(function(prop) {
+                    prop.walk(tw);
+                });
+            });
+            return true;
+        }
+        if (node instanceof AST_Definitions) {
+            var save_exported = exported;
+            exported = tw.parent() instanceof AST_ExportDeclaration;
+            descend();
+            exported = save_exported;
+            return true;
+        }
+        if (node instanceof AST_LambdaDefinition) {
+            var save_exported = exported;
+            exported = tw.parent() instanceof AST_ExportDeclaration;
+            node.name.walk(tw);
+            exported = save_exported;
             walk_scope(function() {
                 node.argnames.forEach(function(argname) {
                     argname.walk(tw);
@@ -161,9 +199,12 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         if (node instanceof AST_SymbolCatch) {
             scope.def_variable(node).defun = defun;
         } else if (node instanceof AST_SymbolConst) {
-            scope.def_variable(node).defun = defun;
+            var def = scope.def_variable(node);
+            def.defun = defun;
+            if (exported) def.exported = true;
         } else if (node instanceof AST_SymbolDefun) {
-            defun.def_function(node, tw.parent());
+            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);
@@ -172,9 +213,11 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             var def = defun.def_function(node, node.name == "arguments" ? undefined : defun);
             if (options.ie8) def.defun = defun.parent_scope.resolve();
         } else if (node instanceof AST_SymbolLet) {
-            scope.def_variable(node);
+            var def = scope.def_variable(node);
+            if (exported) def.exported = true;
         } else if (node instanceof AST_SymbolVar) {
-            defun.def_variable(node, null);
+            var def = defun.def_variable(node, node instanceof AST_SymbolImport ? undefined : null);
+            if (exported) def.exported = true;
             entangle(defun, scope);
         }
 
@@ -231,16 +274,18 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             return true;
         }
         if (node instanceof AST_SymbolDeclaration) {
+            var def = node.definition();
+            def.preinit = def.references.length;
             if (node instanceof AST_SymbolCatch) {
                 // ensure mangling works if `catch` reuses a scope variable
-                var def = node.definition().redefined();
-                if (def) for (var s = node.scope; s; s = s.parent_scope) {
-                    push_uniq(s.enclosed, def);
-                    if (s === def.scope) break;
+                var redef = def.redefined();
+                if (redef) for (var s = node.scope; s; s = s.parent_scope) {
+                    push_uniq(s.enclosed, redef);
+                    if (s === redef.scope) break;
                 }
             } else if (node instanceof AST_SymbolConst) {
                 // ensure compression works if `const` reuses a scope variable
-                var redef = node.definition().redefined();
+                var redef = def.redefined();
                 if (redef) redef.const_redefs = true;
             }
             if (node.name != "arguments") return true;
@@ -269,8 +314,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
                 sym = self.def_global(node);
             } else if (name == "arguments" && is_arguments(sym)) {
                 var parent = tw.parent();
-                if (parent instanceof AST_Assign && parent.left === node
-                    || parent instanceof AST_Unary && unary_side_effects[parent.operator]) {
+                if (is_lhs(node, parent)) {
                     sym.scope.uses_arguments = 3;
                 } else if (sym.scope.uses_arguments < 2
                     && !(parent instanceof AST_PropAccess && parent.expression === node)) {
@@ -292,6 +336,13 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
                     self.uses_eval = true;
                 }
             }
+            if (sym.init instanceof AST_LambdaDefinition && sym.scope !== sym.init.name.scope) {
+                var scope = node.scope;
+                do {
+                    if (scope === sym.init.name.scope) break;
+                } while (scope = scope.parent_scope);
+                if (!scope) sym.init = undefined;
+            }
             node.thedef = sym;
             node.reference(options);
             return true;
@@ -346,13 +397,14 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         } else {
             new_def = scope.def_variable(node);
         }
+        if (new_def.undeclared) self.variables.set(name, new_def);
+        if (name == "arguments" && is_arguments(old_def) && node instanceof AST_SymbolLambda) return true;
         old_def.defun = new_def.scope;
         old_def.forEach(function(node) {
             node.redef = old_def;
             node.thedef = new_def;
             node.reference(options);
         });
-        if (new_def.undeclared) self.variables.set(name, new_def);
         return true;
     }
 });
@@ -392,6 +444,7 @@ AST_Scope.DEFMETHOD("init_vars", function(parent_scope) {
 });
 AST_Arrow.DEFMETHOD("init_vars", function(parent_scope) {
     init_scope_vars(this, parent_scope);
+    return this;
 });
 AST_AsyncArrow.DEFMETHOD("init_vars", function(parent_scope) {
     init_scope_vars(this, parent_scope);
@@ -411,7 +464,9 @@ 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 (options.keep_fnames) {
+        if (!options) {
+            delete s._var_names;
+        } else if (options.keep_fnames) {
             s.functions.each(function(d) {
                 push_uniq(def.scope.enclosed, d);
             });
@@ -432,7 +487,7 @@ AST_BlockScope.DEFMETHOD("find_variable", function(name) {
 
 AST_BlockScope.DEFMETHOD("def_function", function(symbol, init) {
     var def = this.def_variable(symbol, init);
-    if (!def.init || is_defun(def.init)) def.init = init;
+    if (!def.init || def.init instanceof AST_LambdaDefinition) def.init = init;
     this.functions.set(symbol.name, def);
     return def;
 });
@@ -441,7 +496,7 @@ AST_BlockScope.DEFMETHOD("def_variable", function(symbol, init) {
     var def = this.variables.get(symbol.name);
     if (def) {
         def.orig.push(symbol);
-        if (is_function(def.init)) def.init = init;
+        if (def.init instanceof AST_LambdaExpression) def.init = init;
     } else {
         def = this.make_def(symbol, init);
         this.variables.set(symbol.name, def);
@@ -747,6 +802,7 @@ var base54 = (function() {
     var leading = init("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_");
     var chars, frequency;
     function reset() {
+        chars = null;
         frequency = Object.create(freq);
     }
     base54.consider = function(str, delta) {
@@ -758,19 +814,15 @@ var base54 = (function() {
         return frequency[b] - frequency[a];
     }
     base54.sort = function() {
-        chars = leading.sort(compare).concat(digits.sort(compare));
+        chars = leading.sort(compare).concat(digits).sort(compare);
     };
     base54.reset = reset;
     reset();
     function base54(num) {
-        var ret = "", base = 54;
-        num++;
-        do {
-            num--;
-            ret += chars[num % base];
-            num = Math.floor(num / base);
-            base = 64;
-        } while (num > 0);
+        var ret = leading[num % 54];
+        for (num = Math.floor(num / 54); --num >= 0; num >>= 6) {
+            ret += chars[num & 0x3F];
+        }
         return ret;
     }
     return base54;

lib/transform.js

@@ -82,7 +82,7 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.step) self.step = self.step.transform(tw);
         self.body = self.body.transform(tw);
     });
-    DEF(AST_ForIn, function(self, tw) {
+    DEF(AST_ForEnumeration, function(self, tw) {
         self.init = self.init.transform(tw);
         self.object = self.object.transform(tw);
         self.body = self.body.transform(tw);
@@ -147,6 +147,15 @@ TreeTransformer.prototype = new TreeWalker;
     }
     DEF(AST_Arrow, transform_arrow);
     DEF(AST_AsyncArrow, transform_arrow);
+    DEF(AST_Class, function(self, tw) {
+        if (self.name) self.name = self.name.transform(tw);
+        if (self.extends) self.extends = self.extends.transform(tw);
+        self.properties = do_list(self.properties, tw);
+    });
+    DEF(AST_ClassProperty, function(self, tw) {
+        if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
+        if (self.value) self.value = self.value.transform(tw);
+    });
     DEF(AST_Call, function(self, tw) {
         self.expression = self.expression.transform(tw);
         self.args = do_list(self.args, tw);
@@ -157,6 +166,9 @@ TreeTransformer.prototype = new TreeWalker;
     DEF(AST_Await, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
+    DEF(AST_Yield, function(self, tw) {
+        if (self.expression) self.expression = self.expression.transform(tw);
+    });
     DEF(AST_Dot, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
@@ -201,6 +213,24 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
         self.value = self.value.transform(tw);
     });
+    DEF(AST_ExportDeclaration, function(self, tw) {
+        self.body = self.body.transform(tw);
+    });
+    DEF(AST_ExportDefault, function(self, tw) {
+        self.body = self.body.transform(tw);
+    });
+    DEF(AST_ExportReferences, function(self, tw) {
+        self.properties = do_list(self.properties, tw);
+    });
+    DEF(AST_Import, function(self, tw) {
+        if (self.all) self.all = self.all.transform(tw);
+        if (self.default) self.default = self.default.transform(tw);
+        if (self.properties) self.properties = do_list(self.properties, tw);
+    });
+    DEF(AST_Template, function(self, tw) {
+        if (self.tag) self.tag = self.tag.transform(tw);
+        self.expressions = do_list(self.expressions, tw);
+    });
 })(function(node, descend) {
     node.DEFMETHOD("transform", function(tw, in_list) {
         var x, y;

lib/utils.js

@@ -238,7 +238,7 @@ function HOP(obj, prop) {
 // return true if the node at the top of the stack (that means the
 // innermost node in the current output) is lexically the first in
 // a statement.
-function first_in_statement(stack, arrow) {
+function first_in_statement(stack, arrow, export_default) {
     var node = stack.parent(-1);
     for (var i = 0, p; p = stack.parent(i++); node = p) {
         if (is_arrow(p)) {
@@ -249,12 +249,16 @@ function first_in_statement(stack, arrow) {
             if (p.expression === node) continue;
         } else if (p instanceof AST_Conditional) {
             if (p.condition === node) continue;
+        } else if (p instanceof AST_ExportDefault) {
+            return export_default;
         } else if (p instanceof AST_PropAccess) {
             if (p.expression === node) continue;
         } else if (p instanceof AST_Sequence) {
             if (p.expressions[0] === node) continue;
-        } else if (p instanceof AST_Statement) {
-            return p.body === node;
+        } else if (p instanceof AST_SimpleStatement) {
+            return true;
+        } else if (p instanceof AST_Template) {
+            if (p.tag === node) continue;
         } else if (p instanceof AST_UnaryPostfix) {
             if (p.expression === node) continue;
         }

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

test/compress.js

@@ -10,33 +10,38 @@ var sandbox = require("./sandbox");
 var semver = require("semver");
 var U = require("./node");
 
-var file = process.argv[2];
+var batch = 50;
 var dir = path.resolve(path.dirname(module.filename), "compress");
-if (file) {
+if (process.argv.length > 3) {
+    var file = process.argv[2];
+    var start = process.argv[3] | 0;
     var minify_options = require("./ufuzz/options.json").map(JSON.stringify);
-    log("--- {file}", { file: file });
     var tests = parse_test(path.resolve(dir, file));
-    process.exit(Object.keys(tests).filter(function(name) {
+    process.exit(Object.keys(tests).slice(start, start + batch).filter(function(name) {
         return !test_case(tests[name]);
     }).length);
 } else {
-    var files = fs.readdirSync(dir).filter(function(name) {
+    var files = process.argv.length == 3 ? [ process.argv[2] ] : fs.readdirSync(dir).filter(function(name) {
         return /\.js$/i.test(name);
     });
     var failures = 0;
     var failed_files = Object.create(null);
-    (function next() {
-        var file = files.shift();
-        if (file) {
-            child_process.spawn(process.argv[0], [ process.argv[1], file ], {
+    (function next(file, start, length) {
+        if (start < length) {
+            child_process.spawn(process.argv[0], [ process.argv[1], file, start, batch ], {
                 stdio: [ "ignore", 1, 2 ]
             }).on("exit", function(code) {
                 if (code) {
                     failures += code;
-                    failed_files[file] = code;
+                    failed_files[file] = true;
                 }
-                next();
+                next(file, start + batch, length);
             });
+        } else if (file = files.shift()) {
+            log("--- {file}", { file: file });
+            start = 0;
+            length = Object.keys(parse_test(path.resolve(dir, file))).length;
+            next(file, start, length);
         } else if (failures) {
             console.error();
             console.error("!!! Failed " + failures + " test case(s).");
@@ -209,7 +214,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 = run_code(result.code, toplevel);
+            var actual = sandbox.run_code(result.code, toplevel);
             if (typeof expected != "string" && typeof actual != "string" && expected.name == actual.name) {
                 actual = expected;
             }
@@ -244,11 +249,6 @@ function reminify(orig_options, input_code, input_formatted, stdout) {
     return true;
 }
 
-function run_code(code, toplevel) {
-    var result = sandbox.run_code(code, toplevel);
-    return typeof result == "string" ? result.replace(/\u001b\[\d+m/g, "") : result;
-}
-
 function test_case(test) {
     log("    Running test [{name}]", { name: test.name });
     U.AST_Node.enable_validation();
@@ -262,6 +262,7 @@ function test_case(test) {
     var input = to_toplevel(test.input, test.mangle);
     var input_code = make_code(input);
     var input_formatted = make_code(test.input, {
+        annotations: true,
         beautify: true,
         comments: "all",
         keep_quoted_props: true,
@@ -380,7 +381,7 @@ function test_case(test) {
         }
     }
     if (test.expect_stdout && (!test.node_version || semver.satisfies(process.version, test.node_version))) {
-        var stdout = [ run_code(input_code), run_code(input_code, true) ];
+        var stdout = [ sandbox.run_code(input_code), sandbox.run_code(input_code, true) ];
         var toplevel = sandbox.has_toplevel({
             compress: test.options,
             mangle: test.mangle
@@ -409,7 +410,7 @@ function test_case(test) {
             });
             return false;
         }
-        actual = run_code(output_code, toplevel);
+        actual = sandbox.run_code(output_code, toplevel);
         if (!sandbox.same_stdout(test.expect_stdout, actual)) {
             log([
                 "!!! failed",

test/compress/annotations.js

@@ -0,0 +1,474 @@
+issue_2629_1: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ a();
+        /*@__PURE__*/ (b());
+        (/*@__PURE__*/ c)();
+        (/*@__PURE__*/ d());
+    }
+    expect_exact: "c();"
+}
+
+issue_2629_2: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ a(1)(2)(3);
+        /*@__PURE__*/ (b(1))(2)(3);
+        /*@__PURE__*/ (c(1)(2))(3);
+        /*@__PURE__*/ (d(1)(2)(3));
+        (/*@__PURE__*/ e)(1)(2)(3);
+        (/*@__PURE__*/ f(1))(2)(3);
+        (/*@__PURE__*/ g(1)(2))(3);
+        (/*@__PURE__*/ h(1)(2)(3));
+    }
+    expect_exact: [
+        "e(1)(2)(3);",
+        "f(1)(2)(3);",
+        "g(1)(2)(3);",
+    ]
+}
+
+issue_2629_3: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ a.x(1).y(2).z(3);
+        /*@__PURE__*/ (b.x)(1).y(2).z(3);
+        /*@__PURE__*/ (c.x(1)).y(2).z(3);
+        /*@__PURE__*/ (d.x(1).y)(2).z(3);
+        /*@__PURE__*/ (e.x(1).y(2)).z(3);
+        /*@__PURE__*/ (f.x(1).y(2).z)(3);
+        /*@__PURE__*/ (g.x(1).y(2).z(3));
+        (/*@__PURE__*/ h).x(1).y(2).z(3);
+        (/*@__PURE__*/ i.x)(1).y(2).z(3);
+        (/*@__PURE__*/ j.x(1)).y(2).z(3);
+        (/*@__PURE__*/ k.x(1).y)(2).z(3);
+        (/*@__PURE__*/ l.x(1).y(2)).z(3);
+        (/*@__PURE__*/ m.x(1).y(2).z)(3);
+        (/*@__PURE__*/ n.x(1).y(2).z(3));
+    }
+    expect_exact: [
+        "h.x(1).y(2).z(3);",
+        "i.x(1).y(2).z(3);",
+        "j.x(1).y(2).z(3);",
+        "k.x(1).y(2).z(3);",
+        "l.x(1).y(2).z(3);",
+        "m.x(1).y(2).z(3);",
+    ]
+}
+
+issue_2629_4: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    input: {
+        (/*@__PURE__*/ x(), y());
+        (w(), /*@__PURE__*/ x(), y());
+    }
+    expect: {
+        y();
+        w(), y();
+    }
+}
+
+issue_2629_5: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    input: {
+        [ /*@__PURE__*/ x() ];
+        [ /*@__PURE__*/ x(), y() ];
+        [ w(), /*@__PURE__*/ x(), y() ];
+    }
+    expect: {
+        y();
+        w(), y();
+    }
+}
+
+issue_2638: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/(g() || h())(x(), y());
+        (/*@__PURE__*/ (a() || b()))(c(), d());
+    }
+    expect_exact: [
+        "x(),y();",
+        "(a()||b())(c(),d());",
+    ]
+}
+
+issue_2705_1: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ new a();
+        /*@__PURE__*/ (new b());
+        new (/*@__PURE__*/ c)();
+        (/*@__PURE__*/ new d());
+    }
+    expect_exact: [
+        "new c;",
+    ]
+}
+
+issue_2705_2: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ new a(1)(2)(3);
+        /*@__PURE__*/ new (b(1))(2)(3);
+        /*@__PURE__*/ new (c(1)(2))(3);
+        /*@__PURE__*/ new (d(1)(2)(3));
+        new (/*@__PURE__*/ e)(1)(2)(3);
+        (/*@__PURE__*/ new f(1))(2)(3);
+        (/*@__PURE__*/ new g(1)(2))(3);
+        (/*@__PURE__*/ new h(1)(2)(3));
+    }
+    expect_exact: [
+        "new e(1)(2)(3);",
+        "new f(1)(2)(3);",
+        "new g(1)(2)(3);",
+    ]
+}
+
+issue_2705_3: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ new a.x(1).y(2).z(3);
+        /*@__PURE__*/ new (b.x)(1).y(2).z(3);
+        /*@__PURE__*/ new (c.x(1)).y(2).z(3);
+        /*@__PURE__*/ new (d.x(1).y)(2).z(3);
+        /*@__PURE__*/ new (e.x(1).y(2)).z(3);
+        /*@__PURE__*/ new (f.x(1).y(2).z)(3);
+        /*@__PURE__*/ new (g.x(1).y(2).z(3));
+        new (/*@__PURE__*/ h).x(1).y(2).z(3);
+        /* */ new (/*@__PURE__*/ i.x)(1).y(2).z(3);
+        (/*@__PURE__*/ new j.x(1)).y(2).z(3);
+        (/*@__PURE__*/ new k.x(1).y)(2).z(3);
+        (/*@__PURE__*/ new l.x(1).y(2)).z(3);
+        (/*@__PURE__*/ new m.x(1).y(2).z)(3);
+        (/*@__PURE__*/ new n.x(1).y(2).z(3));
+    }
+    expect_exact: [
+        "new h.x(1).y(2).z(3);",
+        "/* */new i.x(1).y(2).z(3);",
+        "new j.x(1).y(2).z(3);",
+        "new k.x(1).y(2).z(3);",
+        "new l.x(1).y(2).z(3);",
+        "new m.x(1).y(2).z(3);",
+    ]
+}
+
+issue_2705_4: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    input: {
+        (/*@__PURE__*/ new x(), y());
+        (w(), /*@__PURE__*/ new x(), y());
+    }
+    expect: {
+        y();
+        w(), y();
+    }
+}
+
+issue_2705_5: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    input: {
+        [ /*@__PURE__*/ new x() ];
+        [ /*@__PURE__*/ new x(), y() ];
+        [ w(), /*@__PURE__*/ new x(), y() ];
+    }
+    expect: {
+        y();
+        w(), y();
+    }
+}
+
+issue_2705_6: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/new (g() || h())(x(), y());
+        /* */ new (/*@__PURE__*/ (a() || b()))(c(), d());
+    }
+    expect_exact: [
+        "x(),y();",
+        "/* */new(a()||b())(c(),d());",
+    ]
+}
+
+issue_3858: {
+    options = {
+        annotations: true,
+        collapse_vars: true,
+        inline: true,
+        keep_fargs: false,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var f = function(a) {
+            return /*@__PURE__*/ function(b) {
+                console.log(b);
+            }(a);
+        };
+        f("PASS");
+    }
+    expect: {
+        var f = function(a) {
+            return function() {
+                console.log(a);
+            }();
+        };
+        f("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+inline_pure_call_1: {
+    options = {
+        annotations: true,
+        collapse_vars: true,
+        inline: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var f = function(a) {
+            return /*@__PURE__*/ function(b) {
+                console.log(b);
+            }(a);
+        };
+        f("PASS");
+    }
+    expect: {}
+}
+
+inline_pure_call_2: {
+    options = {
+        annotations: true,
+        collapse_vars: true,
+        inline: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var f = function(a) {
+            return /*@__PURE__*/ function(b) {
+                console.log(b);
+            }(a);
+        };
+        var a = f("PASS");
+    }
+    expect: {}
+}
+
+inline_pure_call_3: {
+    options = {
+        annotations: true,
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        keep_fargs: false,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var f = function(a) {
+            return /*@__PURE__*/ function(b) {
+                console.log(b);
+            }(a);
+        };
+        var a = f("PASS");
+        console.log(a);
+    }
+    expect: {
+        var a = function() {
+            console.log("PASS");
+        }();
+        console.log(a);
+    }
+    expect_stdout: [
+        "PASS",
+        "undefined",
+    ]
+}
+
+inline_pure_call_4: {
+    options = {
+        annotations: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = /*@__PURE__*/ function() {
+            return console.log("PASS"), 42;
+        }();
+        console.log(a);
+    }
+    expect: {
+        var a = function() {
+            return console.log("PASS"), 42;
+        }();
+        console.log(a);
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+}
+
+compress_and_output_annotations_enabled: {
+    options = {
+        annotations: true,
+        side_effects: true,
+    }
+    beautify = {
+        annotations: true,
+        beautify: true,
+        comments: false,
+    }
+    input: {
+        var top = /*@__PURE__*/ foo();
+        /*@__PURE__*/ a(1)(2)(3);
+        /*@__PURE__*/ (b(1))(2)(3);
+        /*@__PURE__*/ (c(1)(2))(3);
+        /*@__PURE__*/ (d(1)(2)(3));
+        (/*@__PURE__*/ e)(1)(2)(3);
+        (/*@__PURE__*/ f(1))(2)(3);
+        (/*@__PURE__*/ g(1)(2))(3);
+        (/*@__PURE__*/ h(1)(2)(3));
+        /*@__PURE__*/ l(1).p(2);
+        (/*@__PURE__*/ m(1)).p(2);
+        (/*@__PURE__*/ n(1).p)(2);
+        (/*@__PURE__*/ o(1).p(2));
+    }
+    expect_exact: [
+        "var top = /*@__PURE__*/foo();",
+        "",
+        "e(1)(2)(3);",
+        "",
+        "f(1)(2)(3);",
+        "",
+        "g(1)(2)(3);",
+        "",
+        "m(1).p(2);",
+        "",
+        "n(1).p(2);",
+    ]
+}
+
+compress_annotations_disabled_output_annotations_enabled: {
+    options = {
+        annotations: false,
+        evaluate: true,
+        sequences: true,
+        side_effects: true,
+    }
+    beautify = {
+        annotations: true,
+        comments: true,
+    }
+    input: {
+        /*@__PURE__*/ a(1+2);
+        /*#__PURE__*/ (b(2+3));
+        (/*@__PURE__*/ c)(side_effect);
+        (/*#__PURE__*/ d(effect()));
+    }
+    expect_exact: [
+        "/*@__PURE__*/a(3),",
+        "/*#__PURE__*/b(5),",
+        "c(side_effect),",
+        "/*#__PURE__*/d(effect());",
+    ]
+}
+
+compress_and_output_annotations_disabled: {
+    options = {
+        annotations: false,
+        evaluate: true,
+        sequences: true,
+        side_effects: true,
+    }
+    beautify = {
+        annotations: false,
+        comments: true,
+    }
+    input: {
+        /*@__PURE__*/ a(1+2);
+        /*@__PURE__*/ (b(2+3));
+        (/*@__PURE__*/ c)(side_effect);
+        (/*@__PURE__*/ d(effect()));
+    }
+    expect_exact: [
+        "a(3),",
+        "b(5),",
+        "c(side_effect),",
+        "d(effect());",
+    ]
+}

test/compress/arguments.js

@@ -84,6 +84,7 @@ replace_index_drop_fargs_1: {
         evaluate: true,
         keep_fargs: false,
         properties: true,
+        reduce_vars: true,
     }
     input: {
         var arguments = [];
@@ -119,7 +120,7 @@ replace_index_drop_fargs_1: {
             console.log(b, b, arguments.foo);
         })("bar", 42);
         (function(arguments) {
-            console.log(arguments[1], arguments[1], arguments.foo);
+            console.log("bar"[1], "bar"[1], "bar".foo);
         })("bar", 42);
         (function(argument_0, argument_1) {
             var arguments;
@@ -253,6 +254,25 @@ duplicate_argname: {
     expect_stdout: "bar 42 foo 42 bar"
 }
 
+fraction: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            return arguments[0.3];
+        }("FAIL") || "PASS");
+    }
+    expect: {
+        console.log(function() {
+            return arguments[0.3];
+        }("FAIL") || "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
 issue_3273: {
     options = {
         arguments: true,
@@ -649,6 +669,7 @@ issue_3420_1: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         console.log(function() {
@@ -671,6 +692,7 @@ issue_3420_2: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         var foo = function() {
@@ -691,6 +713,7 @@ issue_3420_3: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         "use strict";
@@ -713,6 +736,7 @@ issue_3420_4: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         !function() {
@@ -738,6 +762,7 @@ issue_3420_5: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         "use strict";
@@ -765,6 +790,7 @@ issue_3420_6: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         console.log(function() {
@@ -783,6 +809,7 @@ issue_3420_7: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         "use strict";
@@ -827,6 +854,7 @@ issue_4291_1: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         console.log(function() {
@@ -847,6 +875,7 @@ issue_4291_2: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         var a = function() {
@@ -857,8 +886,8 @@ issue_4291_2: {
         console.log(a[1], a[0], a.length);
     }
     expect: {
-        var a = function(argument_0) {
-            if (argument_0)
+        var a = function() {
+            if (arguments[0])
                 arguments[1] = "PASS";
             return arguments;
         }(42);
@@ -871,6 +900,7 @@ issue_4397: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         console.log(typeof function() {
@@ -977,3 +1007,48 @@ issue_4432: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4696: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        console.log(function() {
+            for (arguments in [ 42 ]);
+            for (var a in arguments[0])
+                return "PASS";
+        }());
+    }
+    expect: {
+        console.log(function() {
+            for (arguments in [ 42 ]);
+            for (var a in arguments[0])
+                return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4809: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        A = 0;
+        (function() {
+            arguments[A] = "PASS";
+            console.log(arguments[0]);
+        })();
+    }
+    expect: {
+        A = 0;
+        (function() {
+            arguments[A] = "PASS";
+            console.log(arguments[0]);
+        })();
+    }
+    expect_stdout: "PASS"
+}

test/compress/arrays.js

@@ -13,9 +13,10 @@ holes_and_undefined: {
     }
 }
 
-constant_join: {
+constant_join_1: {
     options = {
         evaluate: true,
+        side_effects: true,
         strings: true,
         unsafe: true,
     }
@@ -57,7 +58,7 @@ constant_join: {
         var c5 = [ boo() + bar() + "foo", 1, 2, 3, "bar", bar() + "foo" ].join();
         var c6 = [ "1,2,,,foo,bar", baz() ].join();
         var d = "foo-3bar-baz";
-        var e = [].join(foo + bar);
+        var e = (foo, bar, "");
         var f = "";
         var g = "";
     }
@@ -354,3 +355,72 @@ constructor_good: {
     expect_stdout: true
     expect_warnings: []
 }
+
+unsafe_evaluate_modified_binary: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        (function(a) {
+            (console && a).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect: {
+        (function(a) {
+            (console && a).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect_stdout: "PASS"
+}
+
+unsafe_evaluate_modified_conditional: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        (function(a) {
+            (console ? a : []).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect: {
+        (function(a) {
+            (console ? a : []).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect_stdout: "PASS"
+}
+
+unsafe_evaluate_modified_sequence: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        (function(a) {
+            (0, a).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect: {
+        (function(a) {
+            (0, a).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect_stdout: "PASS"
+}

test/compress/arrows.js

@@ -34,7 +34,7 @@ destructured_funarg: {
     node_version: ">=6"
 }
 
-await_parenthesis: {
+await_parentheses: {
     input: {
         async function f() {
             await (a => a);
@@ -43,7 +43,7 @@ await_parenthesis: {
     expect_exact: "async function f(){await(a=>a)}"
 }
 
-for_parenthesis_init: {
+for_parentheses_init: {
     input: {
         for (a => (a in a); console.log(42););
     }
@@ -52,7 +52,7 @@ for_parenthesis_init: {
     node_version: ">=4"
 }
 
-for_parenthesis_condition: {
+for_parentheses_condition: {
     input: {
         for (console.log(42); a => (a in a);)
             break;
@@ -62,7 +62,7 @@ for_parenthesis_condition: {
     node_version: ">=4"
 }
 
-for_parenthesis_step: {
+for_parentheses_step: {
     input: {
         for (; console.log(42); a => (a in a));
     }
@@ -71,7 +71,7 @@ for_parenthesis_step: {
     node_version: ">=4"
 }
 
-for_assign_parenthesis_init: {
+for_assign_parentheses_init: {
     input: {
         for (f = a => (a in a); console.log(42););
     }
@@ -80,7 +80,7 @@ for_assign_parenthesis_init: {
     node_version: ">=4"
 }
 
-for_assign_parenthesis_condition: {
+for_assign_parentheses_condition: {
     input: {
         for (console.log(42); f = a => (a in a);)
             break;
@@ -90,7 +90,7 @@ for_assign_parenthesis_condition: {
     node_version: ">=4"
 }
 
-for_assign_parenthesis_step: {
+for_assign_parentheses_step: {
     input: {
         for (; console.log(42); f = a => (a in a));
     }
@@ -99,7 +99,7 @@ for_assign_parenthesis_step: {
     node_version: ">=4"
 }
 
-for_declaration_parenthesis_init: {
+for_declaration_parentheses_init: {
     input: {
         for (var f = a => (a in a); console.log(42););
     }
@@ -108,7 +108,7 @@ for_declaration_parenthesis_init: {
     node_version: ">=4"
 }
 
-for_statement_parenthesis_init: {
+for_statement_parentheses_init: {
     input: {
         for (a => {
             a in a;
@@ -276,6 +276,7 @@ drop_arguments: {
     options = {
         arguments: true,
         keep_fargs: false,
+        reduce_vars: true,
     }
     input: {
         console.log(function() {
@@ -420,6 +421,7 @@ collapse_value: {
         arrows: true,
         collapse_vars: true,
         keep_fargs: false,
+        unsafe: true,
         unused: true,
     }
     input: {
@@ -434,6 +436,62 @@ collapse_value: {
     node_version: ">=4"
 }
 
+collapse_property_lambda: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        console.log(function f() {
+            f.g = () => 42;
+            return f.g();
+        }());
+    }
+    expect: {
+        console.log(function f() {
+            return (f.g = () => 42)();
+        }());
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+drop_return: {
+    options = {
+        arrows: true,
+        side_effects: true,
+    }
+    input: {
+        (a => {
+            while (!console);
+            return console.log(a);
+        })(42);
+    }
+    expect: {
+        (a => {
+            while (!console);
+            console.log(a);
+        })(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+drop_value: {
+    options = {
+        arrows: true,
+        side_effects: true,
+    }
+    input: {
+        ((a, b) => a + b)(console.log(42));
+    }
+    expect: {
+        ((a, b) => {})(console.log(42));
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
 reduce_iife_1: {
     options = {
         evaluate: true,
@@ -638,3 +696,122 @@ issue_4476: {
     expect_stdout: "foo bar"
     node_version: ">=4"
 }
+
+issue_4666: {
+    input: {
+        console.log((a => /[0-9]/.test(a))(42));
+    }
+    expect_exact: "console.log((a=>/[0-9]/.test(a))(42));"
+    expect_stdout: "true"
+    node_version: ">=4"
+}
+
+issue_4685_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        new function(f) {
+            if (f() !== this)
+                console.log("PASS");
+        }(() => this);
+    }
+    expect: {
+        new function(f) {
+            if (f() !== this)
+                console.log("PASS");
+        }(() => this);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4685_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        new function(f) {
+            if (f() !== this)
+                console.log("PASS");
+        }(() => {
+            if (console)
+                return this;
+        });
+    }
+    expect: {
+        new function(f) {
+            if (f() !== this)
+                console.log("PASS");
+        }(() => {
+            if (console)
+                return this;
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4687_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        new function() {
+            console.log(function(f) {
+                return f() === this;
+            }(() => this) || "PASS");
+        }
+    }
+    expect: {
+        new function() {
+            console.log(function(f) {
+                return f() === this;
+            }(() => this) || "PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4687_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        new function() {
+            console.log(function(f) {
+                return f() === this;
+            }(() => {
+                if (console)
+                    return this;
+            }) || "PASS");
+        }
+    }
+    expect: {
+        new function() {
+            console.log(function(f) {
+                return f() === this;
+            }(() => {
+                if (console)
+                    return this;
+            }) || "PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4772: {
+    input: {
+        var f = a => (a)
+        /**/ console.log(f("PASS"));
+    }
+    expect_exact: 'var f=a=>a;console.log(f("PASS"));'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/assignments.js

@@ -475,3 +475,274 @@ issue_4521: {
     }
     expect_stdout: "42"
 }
+
+logical_assignments: {
+    input: {
+        var a = 42, b = null, c;
+        a &&= "foo";
+        b ||= "bar";
+        c ??= "baz";
+        console.log(a, b, c);
+    }
+    expect_exact: 'var a=42,b=null,c;a&&="foo";b||="bar";c??="baz";console.log(a,b,c);'
+    expect_stdout: "foo bar baz"
+    node_version: ">=15"
+}
+
+logical_collapse_vars: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL", b = false;
+        a = "PASS";
+        b ??= a;
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL", b = false;
+        a = "PASS";
+        b ??= a;
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+logical_reduce_vars: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS", b = 42;
+        b ??= a = "FAIL";
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS", b = 42;
+        b ??= a = "FAIL";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+logical_side_effects: {
+    options = {
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS", b = 42;
+        b ??= a = "FAIL";
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS", b = 42;
+        b ??= a = "FAIL";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+issue_4815_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        42..p &&= a = "FAIL";
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        42..p &&= a = "FAIL";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+issue_4815_2: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var a = "PASS";
+        42..p &&= a = "FAIL";
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        42..p &&= a = "FAIL";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+issue_4819: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        console.log(void 0 === ([].p &&= 42));
+    }
+    expect: {
+        console.log(void 0 === ([].p &&= 42));
+    }
+    expect_stdout: "true"
+    node_version: ">=15"
+}
+
+issue_4827_1: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        A = "FAIL";
+        var a = A, b = "PASS", c;
+        c &&= b = a, console.log(b);
+    }
+    expect: {
+        A = "FAIL";
+        var a = A, b = "PASS", c;
+        c &&= b = a, console.log(b);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+issue_4827_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0, b = "PASS";
+        function f(c) {
+            a++,
+            c &&= b = a;
+        }
+        f();
+        console.log(b);
+    }
+    expect: {
+        var a = 0, b = "PASS";
+        a++,
+        c &&= b = a;
+        var c;
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+issue_4827_3: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 0, b, c;
+        a++;
+        c &&= b = a;
+        console.log(b);
+    }
+    expect: {
+        var a = 0, b, c;
+        a++;
+        c &&= b = a;
+        console.log(b);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=15"
+}
+
+issue_4876: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        try {
+            var a = null;
+            var b = a &&= 42;
+            b.p;
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            var a = null;
+            var b = a &&= 42;
+            b.p;
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+issue_4924_1: {
+    options = {
+        collapse_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, b;
+        console.log("PASS");
+        a = function() {};
+        b = function() {}(b ||= a);
+    }
+    expect: {
+        var b;
+        console.log("PASS");
+        b = void (b ||= function() {});
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+issue_4924_2: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        passes: 2,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, b;
+        console.log("PASS");
+        a = function() {};
+        b = function() {}(b ||= a);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}

test/compress/awaits.js

@@ -23,16 +23,34 @@ async_label: {
 }
 
 await_await: {
+    options = {
+        awaits: true,
+        side_effects: true,
+    }
     input: {
         (async function() {
-            console.log("PASS");
-            await await 42;
+            await await {
+                then(resolve) {
+                    resolve({
+                        then() {
+                            console.log("PASS");
+                        },
+                    });
+                },
+            };
         })();
     }
     expect: {
         (async function() {
-            console.log("PASS");
-            await await 42;
+            await {
+                then(resolve) {
+                    resolve({
+                        then() {
+                            console.log("PASS");
+                        },
+                    });
+                },
+            };
         })();
     }
     expect_stdout: "PASS"
@@ -209,9 +227,7 @@ inline_await_1_trim: {
         console.log("PASS");
     }
     expect: {
-        (async function() {
-            await 0;
-        })();
+        void 0;
         console.log("PASS");
     }
     expect_stdout: "PASS"
@@ -316,7 +332,7 @@ inline_await_3_trim: {
     }
     expect: {
         (async function() {
-            return a = "PASS", b = console.log, await b(a);
+            return a = "PASS", b = console.log, b(a);
             var a, b;
         })();
     }
@@ -519,6 +535,253 @@ collapse_vars_3: {
     node_version: ">=8"
 }
 
+collapse_property_lambda: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        (async function f() {
+            f.g = () => 42;
+            return f.g();
+        })().then(console.log);
+    }
+    expect: {
+        (async function f() {
+            return (f.g = () => 42)();
+        })().then(console.log);
+    }
+    expect_stdout: "42"
+    node_version: ">=8"
+}
+
+drop_async_1: {
+    options = {
+        awaits: true,
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(a) {
+            (async function() {
+                a *= 7;
+            })();
+            return a;
+        }(6));
+    }
+    expect: {
+        console.log(function(a) {
+            void (a *= 7);
+            return a;
+        }(6));
+    }
+    expect_stdout: "42"
+    node_version: ">=8"
+}
+
+drop_async_2: {
+    options = {
+        awaits: true,
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(a) {
+            (async b => await (a *= b))(7);
+            return a;
+        }(6));
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=8"
+}
+
+drop_return: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (async function(a) {
+            while (!console);
+            return !console.log(a);
+        })(42);
+    }
+    expect: {
+        (async function(a) {
+            while (!console);
+            console.log(a);
+        })(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=8"
+}
+
+functions: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        !async function() {
+            var a = async function a() {
+                return a && "a";
+            };
+            var b = async function x() {
+                return !!x;
+            };
+            var c = async function(c) {
+                return c;
+            };
+            if (await c(await b(await a()))) {
+                var d = async function() {};
+                var e = async function y() {
+                    return typeof y;
+                };
+                var f = async function(f) {
+                    return f;
+                };
+                console.log(await a(await d()), await b(await e()), await c(await f(42)), typeof d, await e(), typeof f);
+            }
+        }();
+    }
+    expect: {
+        !async function() {
+            async function a() {
+                return a && "a";
+            }
+            async function b() {
+                return !!b;
+            }
+            async function c(c) {
+                return c;
+            }
+            if (await c(await b(await a()))) {
+                var d = async function() {};
+                var e = async function y() {
+                    return typeof y;
+                };
+                var f = async function(f) {
+                    return f;
+                };
+                console.log(await a(await d()), await b(await e()), await c(await f(42)), typeof d, await e(), typeof f);
+            }
+        }();
+    }
+    expect_stdout: "a true 42 function function function"
+    node_version: ">=8"
+}
+
+functions_use_strict: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        !async function() {
+            var a = async function a() {
+                return a && "a";
+            };
+            var b = async function x() {
+                return !!x;
+            };
+            var c = async function(c) {
+                return c;
+            };
+            if (await c(await b(await a()))) {
+                var d = async function() {};
+                var e = async function y() {
+                    return typeof y;
+                };
+                var f = async function(f) {
+                    return f;
+                };
+                console.log(await a(await d()), await b(await e()), await c(await f(42)), typeof d, await e(), typeof f);
+            }
+        }();
+    }
+    expect: {
+        "use strict";
+        !async function() {
+            async function a() {
+                return a && "a";
+            }
+            async function b() {
+                return !!b;
+            }
+            async function c(c) {
+                return c;
+            }
+            if (await c(await b(await a()))) {
+                var d = async function() {};
+                var e = async function y() {
+                    return typeof y;
+                };
+                var f = async function(f) {
+                    return f;
+                };
+                console.log(await a(await d()), await b(await e()), await c(await f(42)), typeof d, await e(), typeof f);
+            }
+        }();
+    }
+    expect_stdout: "a true 42 function function function"
+    node_version: ">=8"
+}
+
+functions_anonymous: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var await = async function() {
+            console.log("PASS");
+        };
+        await(await);
+    }
+    expect: {
+        async function await() {
+            console.log("PASS");
+        }
+        await();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+functions_inner_var: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var await = function a() {
+            var a;
+            console.log(a, a);
+        };
+        await(await);
+    }
+    expect: {
+        function await() {
+            var a;
+            console.log(a, a);
+        }
+        await();
+    }
+    expect_stdout: "undefined undefined"
+    node_version: ">=8"
+}
+
 issue_4335_1: {
     options = {
         inline: true,
@@ -612,22 +875,32 @@ issue_4340: {
 call_expression: {
     input: {
         console.log(typeof async function(log) {
-            (await log)("FAIL");
+            (await log)("foo");
         }(console.log).then);
+        console.log("bar");
     }
-    expect_exact: 'console.log(typeof async function(log){(await log)("FAIL")}(console.log).then);'
-    expect_stdout: "function"
+    expect_exact: 'console.log(typeof async function(log){(await log)("foo")}(console.log).then);console.log("bar");'
+    expect_stdout: [
+        "function",
+        "bar",
+        "foo",
+    ]
     node_version: ">=8"
 }
 
 property_access_expression: {
     input: {
         console.log(typeof async function(con) {
-            (await con).log("FAIL");
+            (await con).log("foo");
         }(console).then);
+        console.log("bar");
     }
-    expect_exact: 'console.log(typeof async function(con){(await con).log("FAIL")}(console).then);'
-    expect_stdout: "function"
+    expect_exact: 'console.log(typeof async function(con){(await con).log("foo")}(console).then);console.log("bar");'
+    expect_stdout: [
+        "function",
+        "bar",
+        "foo",
+    ]
     node_version: ">=8"
 }
 
@@ -685,20 +958,18 @@ reduce_iife_3: {
     input: {
         var a = "foo";
         (async function() {
-            console.log(a);
-            console.log(await a);
+            console.log(a, await a, a, await a);
         })();
         a = "bar";
     }
     expect: {
         var a = "foo";
         (async function() {
-            console.log(a);
-            console.log(await a);
+            console.log(a, await a, a, await a);
         })();
         a = "bar";
     }
-    expect_stdout: "foo"
+    expect_stdout: "foo foo bar bar"
     node_version: ">=8"
 }
 
@@ -995,3 +1266,495 @@ issue_4534: {
     expect_stdout: "PASS"
     node_version: ">=8"
 }
+
+issue_4581: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        (async () => (A, a = "FAIL"))();
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (async () => (A, a = "FAIL"))();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4595: {
+    options = {
+        awaits: true,
+        inline: true,
+    }
+    input: {
+        (async function() {
+            await async function f() {
+                console.log(f.length);
+            }();
+        })();
+    }
+    expect: {
+        (async function() {
+            await async function f() {
+                console.log(f.length);
+            }();
+        })();
+    }
+    expect_stdout: "0"
+    node_version: ">=8"
+}
+
+issue_4598: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        if (console.log("PASS")) {
+            async function f() {}
+        }
+    }
+    expect: {
+        async function f() {}
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4618: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function() {
+            var await = async function f() {
+                console || f();
+            };
+            console.log;
+            return await;
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            var await = async function f() {
+                console || f();
+            };
+            console.log;
+            return await;
+        }());
+    }
+    expect_stdout: "function"
+    node_version: ">=8"
+}
+
+issue_4717: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            async function f() {
+                var a = function() {
+                    await;
+                }();
+                return "FAIL";
+            }
+            return f();
+        })().then(console.log).catch(function() {
+            console.log("PASS");
+        });
+    }
+    expect: {
+        (async function() {
+            return function() {
+                await;
+            }(), "FAIL";
+        })().then(console.log).catch(function() {
+            console.log("PASS");
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4738_1: {
+    options = {
+        awaits: true,
+        side_effects: true,
+    }
+    input: {
+        (async function() {
+            await {
+                then() {
+                    console.log("PASS");
+                },
+            };
+        })();
+    }
+    expect: {
+        (async function() {
+            await {
+                then() {
+                    console.log("PASS");
+                },
+            };
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4738_2: {
+    options = {
+        awaits: true,
+        side_effects: true,
+    }
+    input: {
+        (async function() {
+            await {
+                get then() {
+                    console.log("PASS");
+                },
+            };
+        })();
+    }
+    expect: {
+        (async function() {
+            await {
+                get then() {
+                    console.log("PASS");
+                },
+            };
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4738_3: {
+    options = {
+        awaits: true,
+        side_effects: true,
+    }
+    input: {
+        (async function() {
+            await {
+                then: function() {
+                    console.log("PASS");
+                },
+            };
+        })();
+    }
+    expect: {
+        (async function() {
+            await {
+                then: function() {
+                    console.log("PASS");
+                },
+            };
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4747: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            async function f() {
+                a = "PASS";
+                null.p += "PASS";
+            }
+            f();
+            return a;
+        }("FAIL"));
+    }
+    expect: {
+        console.log(function(a) {
+            (async function() {
+                a = "PASS";
+                null.p += "PASS";
+            })();
+            return a;
+        }("FAIL"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4764_1: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (async function() {
+            return {
+                then() {
+                    console.log("PASS");
+                },
+            };
+        })();
+    }
+    expect: {
+        (async function() {
+            return {
+                then() {
+                    console.log("PASS");
+                },
+            };
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4764_2: {
+    options = {
+        arrows: true,
+        side_effects: true,
+    }
+    input: {
+        (async () => ({
+            get then() {
+                console.log("PASS");
+            },
+        }))();
+    }
+    expect: {
+        (async () => ({
+            get then() {
+                console.log("PASS");
+            },
+        }))();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4764_3: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (async function(o) {
+            return o;
+        })({
+            then() {
+                console.log("PASS");
+            },
+        });
+    }
+    expect: {
+        (async function(o) {
+            return o;
+        })({
+            then() {
+                console.log("PASS");
+            },
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4972_1: {
+    options = {
+        awaits: true,
+        side_effects: true,
+    }
+    input: {
+        console.log("foo");
+        (async function() {
+            try {
+                return await "bar";
+            } finally {
+                console.log("baz");
+            }
+        })().then(console.log);
+        console.log("moo");
+    }
+    expect: {
+        console.log("foo");
+        (async function() {
+            try {
+                return await "bar";
+            } finally {
+                console.log("baz");
+            }
+        })().then(console.log);
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "moo",
+        "baz",
+        "bar",
+    ]
+    node_version: ">=8"
+}
+
+issue_4972_2: {
+    options = {
+        awaits: true,
+        side_effects: true,
+    }
+    input: {
+        console.log("foo");
+        (async function() {
+            try {
+                console.log("bar");
+            } finally {
+                return await "baz";
+            }
+        })().then(console.log);
+        console.log("moo");
+    }
+    expect: {
+        console.log("foo");
+        (async function() {
+            try {
+                console.log("bar");
+            } finally {
+                return "baz";
+            }
+        })().then(console.log);
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "moo",
+        "baz",
+    ]
+    node_version: ">=8"
+}
+
+issue_4972_3: {
+    options = {
+        awaits: true,
+        side_effects: true,
+    }
+    input: {
+        console.log("foo");
+        try {
+            (async function() {
+                return await "bar";
+            })().then(console.log);
+        } finally {
+            console.log("baz");
+        }
+        console.log("moo");
+    }
+    expect: {
+        console.log("foo");
+        try {
+            (async function() {
+                return "bar";
+            })().then(console.log);
+        } finally {
+            console.log("baz");
+        }
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "moo",
+        "bar",
+    ]
+    node_version: ">=8"
+}
+
+issue_4974: {
+    options = {
+        awaits: true,
+        side_effects: true,
+    }
+    input: {
+        (async function f() {
+            return 42 in f();
+        })();
+        console.log("PASS");
+    }
+    expect: {
+        (async function f() {
+            return 42 in f();
+        })();
+        console.log("PASS");
+    }
+    expect_stdout: true
+    node_version: ">=8"
+}
+
+issue_4975: {
+    options = {
+        awaits: true,
+        side_effects: true,
+    }
+    input: {
+        (async function f(a) {
+            try {
+                if (a) console.log(typeof f());
+            } catch (e) {}
+        })(42);
+    }
+    expect: {
+        (async function f(a) {
+            try {
+                if (a) console.log(typeof f());
+            } catch (e) {}
+        })(42);
+    }
+    expect_stdout: "object"
+    node_version: ">=8"
+}
+
+issue_4987: {
+    options = {
+        awaits: true,
+        side_effects: true,
+    }
+    input: {
+        (async function() {
+            try {
+                await 42;
+            } finally {
+                console.log("foo");
+            }
+        })();
+        console.log("bar");
+    }
+    expect: {
+        (async function() {
+            try {
+                await 0;
+            } finally {
+                console.log("foo");
+            }
+        })();
+        console.log("bar");
+    }
+    expect_stdout: [
+        "bar",
+        "foo",
+    ]
+    node_version: ">=8"
+}

test/compress/bigint.js

@@ -0,0 +1,92 @@
+arithmetic: {
+    input: {
+        console.log(((1n + 0x2n) * (0o3n - -4n)) >> (5n - 6n));
+    }
+    expect_exact: "console.log((1n+0x2n)*(0o3n- -4n)>>5n-6n);"
+    expect_stdout: "42n"
+    node_version: ">=10"
+}
+
+minus_dot: {
+    input: {
+        console.log(typeof -42n.toString(), typeof (-42n).toString());
+    }
+    expect_exact: "console.log(typeof-42n.toString(),typeof(-42n).toString());"
+    expect_stdout: "number string"
+    node_version: ">=10"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log((0xDEAD_BEEFn).toString(16));
+    }
+    expect: {
+        console.log(0xdeadbeefn.toString(16));
+    }
+    expect_stdout: "deadbeef"
+    node_version: ">=10"
+}
+
+Number: {
+    options = {
+        unsafe: true,
+    }
+    input: {
+        console.log(Number(-0xfeed_dead_beef_badn));
+    }
+    expect: {
+        console.log(+("" + -0xfeed_dead_beef_badn));
+    }
+    expect_stdout: "-1148098955808013200"
+    node_version: ">=10"
+}
+
+issue_4590: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        A = 1;
+        0n || console.log("PASS");
+    }
+    expect: {
+        A = 1;
+        0n || console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=10"
+}
+
+issue_4801: {
+    options = {
+        booleans: true,
+        collapse_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        try {
+            (function(a) {
+                A = 42;
+                a || A;
+            })(!(0 == 42 >> 0o644n));
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function(a) {
+                0 != (A = 42) >> 0o644n || A;
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=10"
+}

test/compress/collapse_vars.js

@@ -958,8 +958,7 @@ collapse_vars_misc: {
     }
     expect: {
         function f0(o, a, h) {
-            var b = 3 - a;
-            return o.run(b)[7] = h;
+            return o.run(3 - a)[7] = h;
         }
         function f1(x) { return 5 - x }
         function f2(x) { return foo() / (5 - x) }
@@ -2265,6 +2264,7 @@ var_defs: {
         properties: true,
         sequences: true,
         side_effects: true,
+        unsafe: true,
         unused: true,
     }
     input: {
@@ -2276,8 +2276,8 @@ var_defs: {
     }
     expect: {
         var f1 = function(x, y) {
-            var r = x + y, z = r * r - r, b = 7;
-            console.log(z + b);
+            var r = x + y;
+            console.log(r * r - r + 7);
         };
         f1("1", 0);
     }
@@ -2487,6 +2487,7 @@ issue_1858: {
     options = {
         collapse_vars: true,
         pure_getters: true,
+        reduce_vars: true,
         unused: true,
     }
     input: {
@@ -2869,7 +2870,7 @@ lvalues_def: {
     expect_stdout: true
 }
 
-compound_assignment: {
+compound_assignment_1: {
     options = {
         collapse_vars: true,
     }
@@ -2888,9 +2889,27 @@ compound_assignment: {
     expect_stdout: "4"
 }
 
+compound_assignment_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a;
+        a = 1;
+        for (a += a + 2; console.log(a););
+    }
+    expect: {
+        var a;
+        a = 1;
+        for (a += a + 2; console.log(a););
+    }
+    expect_stdout: "4"
+}
+
 issue_2187_1: {
     options = {
         collapse_vars: true,
+        reduce_vars: true,
         unused: true,
     }
     input: {
@@ -2907,8 +2926,7 @@ issue_2187_1: {
         var a = 1;
         !function(foo) {
             foo();
-            var a = 2;
-            console.log(a);
+            console.log(2);
         }(function() {
             console.log(a);
         });
@@ -4256,6 +4274,7 @@ issue_2436_14: {
     options = {
         collapse_vars: true,
         reduce_vars: true,
+        unsafe: true,
         unused: true,
     }
     input: {
@@ -4709,7 +4728,7 @@ cascade_statement: {
         }
         function f3(a, b) {
             for (; a < b; a++)
-                if ((c = a) && b)
+                if (c = a, a && b)
                     var c = c = b(a);
         }
     }
@@ -4746,6 +4765,7 @@ unsafe_builtin: {
     options = {
         collapse_vars: true,
         pure_getters: "strict",
+        reduce_vars: true,
         unsafe: true,
         unused: true,
     }
@@ -5608,6 +5628,7 @@ collapse_rhs_array: {
 collapse_rhs_boolean_1: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5633,6 +5654,7 @@ collapse_rhs_boolean_1: {
 collapse_rhs_boolean_2: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a;
@@ -5667,6 +5689,7 @@ collapse_rhs_boolean_3: {
         booleans: true,
         collapse_vars: true,
         conditionals: true,
+        evaluate: true,
     }
     input: {
         var a, f, g, h, i, n, s, t, x, y;
@@ -5720,6 +5743,7 @@ collapse_rhs_function: {
 collapse_rhs_number: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5799,6 +5823,7 @@ collapse_rhs_regexp: {
 collapse_rhs_string: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5874,6 +5899,7 @@ collapse_rhs_this: {
 collapse_rhs_undefined: {
     options = {
         collapse_vars: true,
+        side_effects: true,
     }
     input: {
         var a, b;
@@ -6944,6 +6970,7 @@ sequence_in_iife_2: {
         inline: true,
         passes: 2,
         side_effects: true,
+        unsafe: true,
         unused: true,
     }
     input: {
@@ -6955,8 +6982,7 @@ sequence_in_iife_2: {
     }
     expect: {
         var a = "foo", b = 42;
-        b = a;
-        console.log(a, b);
+        console.log(b = a, b);
     }
     expect_stdout: "foo foo"
 }
@@ -6968,6 +6994,7 @@ sequence_in_iife_3: {
         passes: 2,
         side_effects: true,
         toplevel: true,
+        unsafe: true,
         unused: true,
     }
     input: {
@@ -7072,6 +7099,7 @@ setter_side_effect: {
 substitution_assign: {
     options = {
         collapse_vars: true,
+        unsafe: true,
     }
     input: {
         function f1(a, b) {
@@ -7092,8 +7120,7 @@ substitution_assign: {
     }
     expect: {
         function f1(a, b) {
-            f1 = a;
-            console.log(a, a);
+            console.log(f1 = a, a);
         }
         function f2(a, b) {
             a = 1 + (b = a);
@@ -7897,6 +7924,7 @@ issue_3744: {
 assign_value_def: {
     options = {
         collapse_vars: true,
+        reduce_vars: true,
         unused: true,
     }
     input: {
@@ -7937,6 +7965,7 @@ join_vars_value_def: {
     options = {
         collapse_vars: true,
         join_vars: true,
+        reduce_vars: true,
         unused: true,
     }
     input: {
@@ -7976,6 +8005,7 @@ join_vars_value_def: {
 var_value_def: {
     options = {
         collapse_vars: true,
+        reduce_vars: true,
         unused: true,
     }
     input: {
@@ -8013,6 +8043,7 @@ var_value_def: {
 mangleable_var: {
     options = {
         collapse_vars: true,
+        reduce_vars: true,
         unused: true,
     }
     input: {
@@ -8044,6 +8075,69 @@ mangleable_var: {
     expect_stdout: "PASS"
 }
 
+mangleable_assignment_1: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            p: function() {
+                return 6;
+            },
+        };
+        (function() {
+            var a, b = a = o.p();
+            console.log(a * (b / a + b));
+        })();
+    }
+    expect: {
+        var o = {
+            p: function() {
+                return 6;
+            },
+        };
+        (function() {
+            var a;
+            a = o.p();
+            console.log(a * (a / a + a));
+        })();
+    }
+    expect_stdout: "42"
+}
+
+mangleable_assignment_2: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            p: function() {
+                return 6;
+            },
+        };
+        (function(a, b) {
+            b = a = o.p();
+            console.log(a * (b / a + b));
+        })();
+    }
+    expect: {
+        var o = {
+            p: function() {
+                return 6;
+            },
+        };
+        (function(a, b) {
+            a = o.p();
+            console.log(a * (a / a + a));
+        })();
+    }
+    expect_stdout: "42"
+}
+
 issue_3884_1: {
     options = {
         collapse_vars: true,
@@ -8479,7 +8573,7 @@ issue_4047_1: {
     expect: {
         var b = 1;
         var a;
-        console.log((a = --b + ((a = 0) !== typeof A), +void ((a >>= 0) && console.log("PASS"))));
+        console.log((a = --b + (0 !== typeof A), +void ((a >>= 0) && console.log("PASS"))));
     }
     expect_stdout: [
         "PASS",
@@ -8705,3 +8799,616 @@ collapse_or_assign: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4586_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 42;
+        (function f(b) {
+            var b = a;
+            if (b === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect: {
+        var a = 42;
+        (function f(b) {
+            var b = a;
+            if (b === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4586_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 42;
+        (function f(b) {
+            b = a;
+            if (b === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect: {
+        var a = 42;
+        (function f(b) {
+            if ((b = a) === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4732_1: {
+    options = {
+        booleans: true,
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        (function(b) {
+            var b = a++;
+            var c = b ? b && console.log("PASS") : 0;
+        })(a++);
+    }
+    expect: {
+        var a = 0;
+        (function(b) {
+            (b = a++) && (b && console.log("PASS"));
+        })(a++);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4732_2: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        (function(b) {
+            var b = a++;
+            var c = b ? b && console.log("PASS") : 0;
+        })(a++);
+    }
+    expect: {
+        var a = 0;
+        (function(b) {
+            (b = a++) && b && console.log("PASS");
+        })(a++);
+    }
+    expect_stdout: "PASS"
+}
+
+dot_in_try: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var o, a = 6, b = 7, c;
+        try {
+            c = a * b;
+            o.p(c);
+        } catch (e) {
+            console.log(c);
+        }
+    }
+    expect: {
+        var o, a = 6, b = 7, c;
+        try {
+            c = a * b;
+            o.p(c);
+        } catch (e) {
+            console.log(c);
+        }
+    }
+    expect_stdout: "42"
+}
+
+dot_non_local: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var o, a = 6, b = 7, c;
+        function f() {
+            c = a * b;
+            o.p(c);
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log(c);
+        }
+    }
+    expect: {
+        var o, a = 6, b = 7, c;
+        function f() {
+            c = a * b;
+            o.p(c);
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log(c);
+        }
+    }
+    expect_stdout: "42"
+}
+
+issue_4806: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a, o = {
+            f: function() {
+                console.log(this === o ? "FAIL" : "PASS");
+            },
+        };
+        (a = 42, o.f)(42);
+    }
+    expect: {
+        var a, o = {
+            f: function() {
+                console.log(this === o ? "FAIL" : "PASS");
+            },
+        };
+        (0, o.f)(a = 42);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4852: {
+    options = {
+        collapse_vars: true,
+        unsafe: true,
+    }
+    input: {
+        var a = "PASS";
+        (function(b) {
+            switch (b = a) {
+              case 42:
+                try {
+                    console;
+                } catch (b) {
+                    b.p;
+                }
+              case console.log(b):
+            }
+        })("FAIL");
+    }
+    expect: {
+        var a = "PASS";
+        (function(b) {
+            switch (a) {
+              case 42:
+                try {
+                    console;
+                } catch (b) {
+                    b.p;
+                }
+              case console.log(a):
+            }
+        })("FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4865: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var NaN;
+        var a = NaN = "PASS";
+        console.log(a, NaN);
+    }
+    expect: {
+        var NaN;
+        var a = NaN = "PASS";
+        console.log(a, NaN);
+    }
+    expect_stdout: true
+}
+
+issue_4868: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        (function(b) {
+            console.log(b[0]);
+        })(a = [ "PASS" ], a = [ "FAIL" ]);
+    }
+    expect: {
+        var a;
+        (function(b) {
+            console.log(b[0]);
+        })(a = [ "PASS" ], a = [ "FAIL" ]);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4874: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        a = null;
+        (function(b) {
+            for (var c in b = b && b[console.log("PASS")])
+                console;
+        })(a = 42);
+    }
+    expect: {
+        var a;
+        null;
+        (function(b) {
+            for (var c in a && a[console.log("PASS")])
+                console;
+        })(a = 42);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4891: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 0, b;
+        a++;
+        console.log(b = a, b);
+        b--;
+        a.a += 0;
+        console.log(b);
+    }
+    expect: {
+        var a = 0, b;
+        a++;
+        console.log(a, b = a);
+        b--;
+        a.a += 0;
+        console.log(b);
+    }
+    expect_stdout: [
+        "1 1",
+        "0",
+    ]
+}
+
+issue_4895: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b;
+        (function f() {
+            a = 42;
+        })();
+        console.log((b = a) || b, b += 0);
+    }
+    expect: {
+        var a, b;
+        (function f() {
+            a = 42;
+        })();
+        console.log((b = a) || b, b += 0);
+    }
+    expect_stdout: "42 42"
+}
+
+issue_4908: {
+    options = {
+        collapse_vars: true,
+        join_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 0;
+        var b;
+        console || a++;
+        var c = d = a, d = [ c && c, d += 42 ];
+        console.log(d[1]);
+    }
+    expect: {
+        var a = 0, b;
+        console || a++;
+        var c = a, d = [ (d = a) && d, d += 42 ];
+        console.log(d[1]);
+    }
+    expect_stdout: "42"
+}
+
+issue_4910: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "foo", b;
+        var c = b = a;
+        1 && c[a = "bar"];
+        console.log(a, b);
+    }
+    expect: {
+        var a = "foo", b;
+        var c = b = a;
+        1 && b[a = "bar"];
+        console.log(a, b);
+    }
+    expect_stdout: "bar foo"
+}
+
+issue_4914: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        console.log(typeof function f() {
+            f.__proto__ = 42;
+            return f.__proto__;
+        }());
+    }
+    expect: {
+        console.log(typeof function f() {
+            f.__proto__ = 42;
+            return f.__proto__;
+        }());
+    }
+    expect_stdout: "function"
+}
+
+issue_4918: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        ({
+            get 42() {
+                console.log(a);
+            }
+        }[a = "PASS", 42] += "PASS");
+    }
+    expect: {
+        var a = "FAIL";
+        ({
+            get 42() {
+                console.log(a);
+            }
+        }[a = "PASS", 42] += "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4920_1: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS", b;
+        ({
+            get PASS() {
+                a = "FAIL";
+            },
+        })[b = a];
+        console.log(b);
+    }
+    expect: {
+        var a = "PASS", b;
+        ({
+            get PASS() {
+                a = "FAIL";
+            },
+        })[b = a];
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4920_2: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            get PASS() {
+                a = "FAIL";
+            },
+        };
+        var a = "PASS", b;
+        o[b = a];
+        console.log(b);
+    }
+    expect: {
+        var o = {
+            get PASS() {
+                a = "FAIL";
+            },
+        };
+        var a = "PASS", b;
+        o[b = a];
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4920_3: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var log = console.log;
+        var o = {
+            get PASS() {
+                a = "FAIL";
+            },
+        };
+        var a = "PASS", b;
+        o[b = a];
+        log(b);
+    }
+    expect: {
+        var log = console.log;
+        var o = {
+            get PASS() {
+                a = "FAIL";
+            },
+        };
+        var a = "PASS", b;
+        o[b = a];
+        log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4935: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        var b;
+        var c = b = a;
+        console || c(a++);
+        --b;
+        console.log(a, b);
+    }
+    expect: {
+        var a = 1;
+        var b;
+        var c = b = a;
+        console || a(a++);
+        --b;
+        console.log(a, b);
+    }
+    expect_stdout: "1 0"
+}
+
+inline_throw: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        try {
+            (function() {
+                return function(a) {
+                    return function(b) {
+                        throw b;
+                    }(a);
+                };
+            })()("PASS");
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        try {
+            (function(a) {
+                return function() {
+                    throw a;
+                }();
+            })("PASS");
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4977_1: {
+    options = {
+        collapse_vars: true,
+        unsafe: true,
+    }
+    input: {
+        var a = "FAIL";
+        var o = {
+            get p() {
+                return a;
+            }
+        };
+        a = "PASS";
+        console.log(o.p, a);
+    }
+    expect: {
+        var a = "FAIL";
+        var o = {
+            get p() {
+                return a;
+            }
+        };
+        a = "PASS";
+        console.log(o.p, a);
+    }
+    expect_stdout: "PASS PASS"
+}
+
+issue_4977_2: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        var a, o = {
+            get p() {
+                return a = "PASS";
+            },
+        };
+        if (console) {
+            var a = "FAIL";
+            console.log(o.p, a);
+        }
+    }
+    expect: {
+        var a, o = {
+            get p() {
+                return a = "PASS";
+            },
+        };
+        if (console) {
+            var a = "FAIL";
+            console.log(o.p, a);
+        }
+    }
+    expect_stdout: "PASS PASS"
+}

test/compress/conditionals.js

@@ -1861,3 +1861,39 @@ issue_3808_2: {
     }
     expect_stdout: " PASS"
 }
+
+object_super: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        Object.setPrototypeOf({
+            f(a) {
+                a ? this.g("FAIL") : super.g("FAIL");
+            },
+            g(b) {
+                console.log(b);
+            },
+        }, {
+            g() {
+                console.log("PASS");
+            },
+        }).f();
+    }
+    expect: {
+        Object.setPrototypeOf({
+            f(a) {
+                a ? this.g("FAIL") : super.g("FAIL");
+            },
+            g(b) {
+                console.log(b);
+            },
+        }, {
+            g() {
+                console.log("PASS");
+            },
+        }).f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/const.js

@@ -1434,3 +1434,261 @@ issue_4527: {
     }
     expect_stdout: "aaaa"
 }
+
+issue_4689: {
+    options = {
+        sequences: true,
+    }
+    input: {
+        "use strict";
+        var a = "PASS";
+        console.log(a);
+        for (const a in 42);
+    }
+    expect: {
+        "use strict";
+        var a = "PASS";
+        console.log(a);
+        for (const a in 42);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4691: {
+    options = {
+        if_return: true,
+        toplevel: true,
+    }
+    input: {
+        function A() {}
+        A.prototype.f = function() {
+            if (!this)
+                return;
+            const a = "PA";
+            function g(b) {
+                h(a + b);
+            }
+            [ "SS" ].forEach(function(c) {
+                g(c);
+            });
+        };
+        function h(d) {
+            console.log(d);
+        }
+        new A().f();
+    }
+    expect: {
+        function A() {}
+        A.prototype.f = function() {
+            if (this) {
+                const a = "PA";
+                [ "SS" ].forEach(function(c) {
+                    g(c);
+                });
+                function g(b) {
+                    h(a + b);
+                }
+            }
+        };
+        function h(d) {
+            console.log(d);
+        }
+        new A().f();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4848: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f(a) {
+            a(function() {
+                console.log(b);
+            });
+            if (!console)
+                return;
+            const b = "PASS";
+        }
+        var g;
+        f(function(h) {
+            g = h;
+        });
+        g();
+    }
+    expect: {
+        function f(a) {
+            a(function() {
+                console.log(b);
+            });
+            if (!console)
+                return;
+            const b = "PASS";
+        }
+        var g;
+        f(function(h) {
+            g = h;
+        });
+        g();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4954_1: {
+    rename = true
+    input: {
+        "use strict";
+        (function() {
+            {
+                const a = "foo";
+                console.log(a);
+            }
+            {
+                const a = "bar";
+                console.log(a);
+            }
+        })();
+    }
+    expect: {
+        "use strict";
+        (function() {
+            {
+                const a = "foo";
+                console.log(a);
+            }
+            {
+                const b = "bar";
+                console.log(b);
+            }
+        })();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+issue_4954_2: {
+    mangle = {}
+    input: {
+        "use strict";
+        const a = null;
+        (function(b) {
+            for (const a in null);
+            for (const a in b)
+                console.log("PASS");
+        })([ null ]);
+    }
+    expect: {
+        "use strict";
+        const a = null;
+        (function(o) {
+            for (const n in null);
+            for (const n in o)
+                console.log("PASS");
+        })([ null ]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4960: {
+    mangle = {}
+    input: {
+        "use strict";
+        var a;
+        (function() {
+            {
+                const a = console.log("PASS");
+            }
+            try {} catch (e) {
+                const a = console.log("FAIL");
+            }
+        })();
+    }
+    expect: {
+        "use strict";
+        var a;
+        (function() {
+            {
+                const o = console.log("PASS");
+            }
+            try {} catch (o) {
+                const c = console.log("FAIL");
+            }
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4965_1: {
+    mangle = {}
+    input: {
+        "use strict";
+        try {
+            c;
+        } catch (a) {
+            {
+                const a = 1;
+            }
+            {
+                const a = console.log(typeof c);
+            }
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            c;
+        } catch (t) {
+            {
+                const c = 1;
+            }
+            {
+                const t = console.log(typeof c);
+            }
+        }
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4965_2: {
+    mangle = {}
+    input: {
+        "use strict";
+        try {
+            throw 1;
+        } catch (e) {
+            try {
+                {
+                    const e = 2;
+                }
+            } finally {
+                const e = 3;
+                console.log(typeof t);
+            }
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            throw 1;
+        } catch (o) {
+            try {
+                {
+                    const t = 2;
+                }
+            } finally {
+                const o = 3;
+                console.log(typeof t);
+            }
+        }
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}

test/compress/dead-code.js

@@ -53,8 +53,10 @@ dead_code_2_should_warn: {
             g();
             x = 10;
             throw new Error("foo");
-            var x;
-            function g(){};
+            {
+                var x;
+                function g(){};
+            }
         }
         f();
     }
@@ -62,7 +64,6 @@ dead_code_2_should_warn: {
     expect_warnings: [
         "WARN: Dropping unreachable code [test/compress/dead-code.js:8,12]",
     ]
-    node_version: "<=4"
 }
 
 dead_code_constant_boolean_should_warn_more: {
@@ -88,8 +89,10 @@ dead_code_constant_boolean_should_warn_more: {
         bar();
     }
     expect: {
-        var foo;
-        function bar() {}
+        {
+            var foo;
+            function bar() {}
+        }
         // nothing for the while
         // as for the for, it should keep:
         var x = 10, y;

test/compress/default-values.js

@@ -161,6 +161,7 @@ process_boolean_returns: {
 collapse_value_1: {
     options = {
         collapse_vars: true,
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -169,7 +170,7 @@ collapse_value_1: {
         }());
     }
     expect: {
-        console.log(function(a) {
+        console.log(function() {
             return "PASS";
         }());
     }
@@ -180,6 +181,7 @@ collapse_value_1: {
 collapse_value_2: {
     options = {
         collapse_vars: true,
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -188,7 +190,7 @@ collapse_value_2: {
         })().log("PASS");
     }
     expect: {
-        (function(a) {
+        (function() {
             return console;
         })().log("PASS");
     }
@@ -471,7 +473,7 @@ inline_side_effects_2: {
     }
     expect: {
         var a = 42;
-        [ 0[0] = --a ] = [ console ];
+        [ [].e = --a ] = [ console ];
         console.log(a);
     }
     expect_stdout: "42"
@@ -554,8 +556,9 @@ drop_fargs: {
         "bar",
     ]
     expect_warnings: [
-        "WARN: Dropping unused function argument c [test/compress/default-values.js:1,61]",
+        "WARN: Dropping unused default argument c [test/compress/default-values.js:1,61]",
         "WARN: Side effects in default value of unused variable b [test/compress/default-values.js:1,37]",
+        "WARN: Dropping unused default argument assignment a [test/compress/default-values.js:1,29]",
     ]
     node_version: ">=6"
 }
@@ -595,6 +598,7 @@ unused_var_1: {
 
 unused_var_2: {
     options = {
+        pure_getters: "strict",
         toplevel: true,
         unused: true,
     }
@@ -606,11 +610,7 @@ unused_var_2: {
         };
     }
     expect: {
-        var {
-            p: [] = [ console.log("FAIL") ],
-        } = {
-            p: [ console.log("PASS") ],
-        };
+        console.log("PASS");
     }
     expect_stdout: "PASS"
     node_version: ">=6"
@@ -1474,7 +1474,7 @@ issue_4502_4: {
         (function(a, b = console.log("FAIL")) {})(..."" + console.log(42));
     }
     expect: {
-        [ , 0[0] = console.log("FAIL") ] = [ ..."" + console.log(42) ];
+        [ , [].e = console.log("FAIL") ] = [ ..."" + console.log(42) ];
     }
     expect_stdout: "42"
     node_version: ">=6"
@@ -1596,3 +1596,133 @@ issue_4548: {
     ]
     node_version: ">=6"
 }
+
+issue_4588_1_unused: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function(a = 42) {}.length);
+    }
+    expect: {
+        console.log(function(a = 0) {}.length);
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+issue_4588_2_unused: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function(a, b = void 0, c, d = "foo") {}.length);
+    }
+    expect: {
+        console.log(function(a, b = 0, c, d) {}.length);
+    }
+    expect_stdout: "1"
+    expect_warnings: [
+        "WARN: Dropping unused default argument assignment d [test/compress/default-values.js:1,47]",
+        "WARN: Dropping unused default argument value b [test/compress/default-values.js:1,32]",
+    ]
+    node_version: ">=6"
+}
+
+issue_4588_1_evaluate: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(function(a = 42) {}.length);
+    }
+    expect: {
+        console.log(0);
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+issue_4588_2_evaluate: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(function(a, b = void 0, c, d = "foo") {}.length);
+    }
+    expect: {
+        console.log(1);
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+}
+
+issue_4817: {
+    options = {
+        ie8: true,
+        inline: true,
+        unused: true,
+    }
+    input: {
+        (function f(a = console.log(typeof f)) {
+            return 42;
+        })();
+    }
+    expect: {
+        (function f(a = console.log(typeof f)) {
+            return 42;
+        })();
+    }
+    expect_stdout: "function"
+    node_version: ">=6"
+}
+
+issue_4854: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            (function(b = a = "foo") {
+                [] = "foo";
+            })();
+            a;
+        }());
+    }
+    expect: {
+        console.log(void ([] = "foo"));
+    }
+    expect_stdout: "undefined"
+    node_version: ">=6"
+}
+
+issue_4916: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+    }
+    input: {
+        var log = console.log;
+        (function(b = "foo") {
+            b.value = "FAIL";
+            b;
+            log(b.value);
+        })();
+    }
+    expect: {
+        var log = console.log;
+        (function(b = "foo") {
+            b.value = "FAIL";
+            b;
+            log(b.value);
+        })();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=6"
+}

test/compress/destructured.js

@@ -1010,6 +1010,42 @@ collapse_vars_8: {
     node_version: ">=6"
 }
 
+collapse_vars_9: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            try {
+                var b = function([ c ]) {
+                    if (c)
+                        return "FAIL 1";
+                }();
+                a = "FAIL 2";
+                return b;
+            } catch (e) {
+                return a;
+            }
+        }("PASS"));
+    }
+    expect: {
+        console.log(function(a) {
+            try {
+                var b = function([ c ]) {
+                    if (c)
+                        return "FAIL 1";
+                }();
+                a = "FAIL 2";
+                return b;
+            } catch (e) {
+                return a;
+            }
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 conditionals: {
     options = {
         conditionals: true,
@@ -2487,3 +2523,72 @@ issue_4554: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_4584: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        try {
+            (function f({
+                [console.log(a = "FAIL")]: a,
+            }) {})(0);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function f({
+                [console.log(a = "FAIL")]: a,
+            }) {})(0);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4608_1: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        (function() {
+            [ arguments ] = [ "foo" ];
+            console.log(arguments[0]);
+        })();
+    }
+    expect: {
+        (function() {
+            [ arguments ] = [ "foo" ];
+            console.log(arguments[0]);
+        })();
+    }
+    expect_stdout: "f"
+    node_version: ">=6"
+}
+
+issue_4608_2: {
+    options = {
+        arguments: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function(a) {
+            [ arguments ] = [ "foo" ];
+            console.log(arguments[0]);
+        })();
+    }
+    expect: {
+        (function(a) {
+            [ arguments ] = [ "foo" ];
+            console.log(arguments[0]);
+        })();
+    }
+    expect_stdout: "f"
+    node_version: ">=6"
+}

test/compress/drop-unused.js

@@ -2138,6 +2138,7 @@ issue_3497: {
 issue_3515_1: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         reduce_vars: true,
         unused: true,
     }
@@ -2189,6 +2190,7 @@ issue_3515_2: {
 issue_3515_3: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         unused: true,
     }
     input: {
@@ -2256,6 +2258,7 @@ function_assign: {
 issue_3598: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         reduce_vars: true,
         unused: true,
     }
@@ -2368,6 +2371,7 @@ function_parameter_ie8: {
 issue_3664: {
     options = {
         pure_getters: "strict",
+        side_effects: true,
         unused: true,
     }
     input: {
@@ -2378,7 +2382,7 @@ issue_3664: {
     }
     expect: {
         console.log(function() {
-            var b = ([ b && console.log("FAIL") ].p = 0, 0);
+            var a, b = (a = (a = [ b && console.log("FAIL") ]).p = 0, 0);
             return "PASS";
         }());
     }
@@ -2388,6 +2392,7 @@ issue_3664: {
 issue_3673: {
     options = {
         pure_getters: "strict",
+        sequences: true,
         side_effects: true,
         toplevel: true,
         unused: true,
@@ -2398,8 +2403,6 @@ issue_3673: {
         console.log("PASS");
     }
     expect: {
-        var a;
-        (a = [ a ]).p = 42;
         console.log("PASS");
     }
     expect_stdout: "PASS"
@@ -3077,11 +3080,9 @@ issue_4235: {
         })();
     }
     expect: {
-        (function() {
-            f = console.log(f),
-            void 0;
-            var f;
-        })();
+        void function() {
+            var f = console.log(f);
+        }();
     }
     expect_stdout: "undefined"
 }
@@ -3248,3 +3249,222 @@ issue_4558_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4662: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        function f(b, c) {
+            console.log(b, c);
+        }
+        f(++a, a = a, a);
+    }
+    expect: {
+        var a = 0;
+        (function(b, c) {
+            console.log(b, c);
+        })(++a, a = 1);
+    }
+    expect_stdout: "1 1"
+}
+
+issue_4806_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        O = {
+            f: function() {
+                console.log(this === O ? "FAIL" : "PASS");
+            },
+        };
+        var a;
+        (a = 42, O.f)();
+        a;
+    }
+    expect: {
+        O = {
+            f: function() {
+                console.log(this === O ? "FAIL" : "PASS");
+            },
+        };
+        (0, O.f)();
+        42;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4806_2: {
+    options = {
+        sequences: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        O = {
+            f: function() {
+                console.log(this === O ? "FAIL" : "PASS");
+            },
+        };
+        var a;
+        (a = 42, O.f)();
+        a;
+    }
+    expect: {
+        O = {
+            f: function() {
+                console.log(this === O ? "FAIL" : "PASS");
+            },
+        },
+        (0, O.f)();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4806_3: {
+    options = {
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        O = {
+            f: function() {
+                console.log(this === O ? "FAIL" : "PASS");
+            },
+        };
+        var a;
+        (a = 42, O.f)();
+        a;
+    }
+    expect: {
+        O = {
+            f: function() {
+                console.log(this === O ? "FAIL" : "PASS");
+            },
+        };
+        (0, O.f)();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4834: {
+    options = {
+        inline: true,
+        keep_fargs: false,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        try {
+            new function(a, b) {
+                b;
+                b.p;
+            }(42);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            void b.p;
+        } catch (e) {
+            console.log("PASS");
+        }
+        var b;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4912_1: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = A = function() {};
+        A;
+        a.prototype = {
+            f: function() {
+                console.log("PASS");
+            },
+        };
+        new A().f();
+    }
+    expect: {
+        var a = A = function() {};
+        A;
+        a.prototype = {
+            f: function() {
+                console.log("PASS");
+            },
+        };
+        new A().f();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4912_2: {
+    options = {
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var g, f = function() {};
+            f.p = {};
+            (g = f.p.q = function() {}).r = "PASS";
+            return f;
+        }().p.q.r);
+    }
+    expect: {
+        console.log(function() {
+            var g, f = function() {};
+            f.p = {};
+            (f.p.q = function() {}).r = "PASS";
+            return f;
+        }().p.q.r);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4912_3: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(f, g) {
+            f = function() {};
+            f.p = {};
+            g = f.p.q = function() {};
+            g.r = "PASS";
+            return f;
+        }().p.q.r);
+    }
+    expect: {
+        console.log(function(f, g) {
+            f = function() {};
+            f.p = {};
+            g = f.p.q = function() {};
+            g.r = "PASS";
+            return f;
+        }().p.q.r);
+    }
+    expect_stdout: "PASS"
+}

test/compress/evaluate.js

@@ -399,18 +399,18 @@ unsafe_object_accessor: {
         function f() {
             var a = {
                 get b() {},
-                set b() {}
+                set b(v) {},
             };
-            return {a:a};
+            return { a: a };
         }
     }
     expect: {
         function f() {
             var a = {
                 get b() {},
-                set b() {}
+                set b(v) {},
             };
-            return {a:a};
+            return { a: a };
         }
     }
 }
@@ -703,6 +703,7 @@ prototype_function: {
         var g = 0();
         var h = 0();
     }
+    expect_stdout: true
 }
 
 call_args: {
@@ -846,6 +847,8 @@ unsafe_charAt_noop: {
         unsafe: true,
     }
     input: {
+        s = "foo";
+        x = 42;
         console.log(
             s.charAt(0),
             "string".charAt(x),
@@ -853,12 +856,15 @@ unsafe_charAt_noop: {
         );
     }
     expect: {
+        s = "foo";
+        x = 42;
         console.log(
-            s[0],
-            "string"[0 | x],
-            (typeof x)[0]
+            s[0] || "",
+            "string"[0 | x] || "",
+            (typeof x)[0] || ""
         );
     }
+    expect_stdout: "f  n"
 }
 
 issue_1649: {
@@ -2800,7 +2806,7 @@ operator_in: {
         console.log("PASS" in { });
         console.log("FAIL" in { });
         console.log("toString" in { });
-        console.log(true);
+        console.log("toString" in { toString: 3 });
     }
     expect_stdout: [
         "true",
@@ -3175,3 +3181,23 @@ issue_4552: {
     }
     expect_stdout: "NaN"
 }
+
+issue_4886: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log("length" in {
+            __proto__: function() {},
+            length: void 0,
+        });
+    }
+    expect: {
+        console.log("length" in {
+            __proto__: function() {},
+            length: void 0,
+        });
+    }
+    expect_stdout: "true"
+}

test/compress/exponentiation.js

@@ -0,0 +1,147 @@
+precedence_1: {
+    input: {
+        console.log(-4 ** 3 ** 2);
+    }
+    expect_exact: "console.log((-4)**3**2);"
+    expect_stdout: "-262144"
+    node_version: ">=8"
+}
+
+precedence_2: {
+    input: {
+        console.log(-4 ** (3 ** 2));
+    }
+    expect_exact: "console.log((-4)**3**2);"
+    expect_stdout: "-262144"
+    node_version: ">=8"
+}
+
+precedence_3: {
+    input: {
+        console.log(-(4 ** 3) ** 2);
+    }
+    expect_exact: "console.log((-(4**3))**2);"
+    expect_stdout: "4096"
+    node_version: ">=8"
+}
+
+precedence_4: {
+    input: {
+        console.log((-4 ** 3) ** 2);
+    }
+    expect_exact: "console.log(((-4)**3)**2);"
+    expect_stdout: "4096"
+    node_version: ">=8"
+}
+
+await: {
+    input: {
+        (async a => a * await a ** ++a % a)(2).then(console.log);
+    }
+    expect_exact: "(async a=>a*(await a)**++a%a)(2).then(console.log);"
+    expect_stdout: "1"
+    node_version: ">=8"
+}
+
+assignment_1: {
+    input: {
+        var a = 2;
+        a **= 5;
+        console.log(a);
+    }
+    expect_exact: "var a=2;a**=5;console.log(a);"
+    expect_stdout: "32"
+    node_version: ">=8"
+}
+
+assignment_2: {
+    input: {
+        var a = 8n;
+        a **= a;
+        console.log(a);
+    }
+    expect_exact: "var a=8n;a**=a;console.log(a);"
+    expect_stdout: "16777216n"
+    node_version: ">=10"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log(1 + 2 ** 3 - 4);
+    }
+    expect: {
+        console.log(5);
+    }
+    expect_stdout: "5"
+    node_version: ">=8"
+}
+
+issue_4664: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            new function(a) {
+                console.log(typeof f, a, typeof this);
+            }((A = 0, (NaN ^ 1) * 2 ** 30), 0);
+        }
+        f();
+    }
+    expect: {
+        (function f() {
+            new function(a) {
+                console.log(typeof f, 1073741824, typeof this);
+            }(A = 0);
+        })();
+    }
+    expect_stdout: "function 1073741824 object"
+    node_version: ">=8"
+}
+
+issue_4715: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        A = 1;
+        console.log((-0) ** A + 0);
+        console.log((-0) ** A - 0);
+        console.log((-0) ** A * 1);
+        console.log((-0) ** A / 1);
+        console.log(Math.pow(-0, A) + 0);
+        console.log(Math.pow(-0, A) - 0);
+        console.log(Math.pow(-0, A) * 1);
+        console.log(Math.pow(-0, A) / 1);
+    }
+    expect: {
+        A = 1;
+        console.log((-0) ** A + 0);
+        console.log((-0) ** A);
+        console.log((-0) ** A * 1);
+        console.log((-0) ** A);
+        console.log(Math.pow(-0, A) + 0);
+        console.log(+Math.pow(-0, A));
+        console.log(+Math.pow(-0, A));
+        console.log(+Math.pow(-0, A));
+    }
+    expect_stdout: [
+        "0",
+        "-0",
+        "-0",
+        "-0",
+        "0",
+        "-0",
+        "-0",
+        "-0",
+    ]
+    node_version: ">=8"
+}

test/compress/exports.js

@@ -0,0 +1,498 @@
+refs: {
+    input: {
+        export {};
+        export { a, b as B, c as case, d as default };
+    }
+    expect_exact: "export{};export{a,b as B,c as case,d as default};"
+}
+
+var_defs: {
+    input: {
+        export const a = 1;
+        export let b = 2, c = 3;
+        export var { d, e: [] } = f;
+    }
+    expect_exact: "export const a=1;export let b=2,c=3;export var{d,e:[]}=f;"
+}
+
+defuns: {
+    input: {
+        export class A {}
+        export function e() {}
+        export function* f(a) {}
+        export async function g(b, c) {}
+        export async function* h({}, ...[]) {}
+    }
+    expect_exact: "export class A{}export function e(){}export function*f(a){}export async function g(b,c){}export async function*h({},...[]){}"
+}
+
+defaults: {
+    input: {
+        export default 42;
+        export default async;
+        export default (x, y) => x * x;
+        export default class {};
+        export default function*(a, b) {};
+        export default async function f({ c }, ...[ d ]) {};
+    }
+    expect_exact: "export default 42;export default async;export default(x,y)=>x*x;export default class{}export default function*(a,b){}export default async function f({c},...[d]){}"
+}
+
+defaults_parentheses_1: {
+    input: {
+        export default function() {
+            console.log("FAIL");
+        }(console.log("PASS"));
+    }
+    expect_exact: 'export default function(){console.log("FAIL")}console.log("PASS");'
+}
+
+defaults_parentheses_2: {
+    input: {
+        export default (async function() {
+            console.log("PASS");
+        })();
+    }
+    expect_exact: 'export default(async function(){console.log("PASS")})();'
+}
+
+defaults_parentheses_3: {
+    input: {
+        export default (42, "PASS");
+    }
+    expect_exact: 'export default(42,"PASS");'
+}
+
+defaults_parentheses_4: {
+    input: {
+        export default (function f() {});
+    }
+    expect_exact: "export default(function f(){});"
+}
+
+defaults_parentheses_5: {
+    input: {
+        export default (function(a) {
+            console.log(a[0]);
+        }`PASS`);
+    }
+    expect_exact: "export default(function(a){console.log(a[0])})`PASS`;"
+}
+
+defaults_parentheses_6: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        export default !function() {
+            while (!console);
+        }() ? "PASS" : "FAIL";
+    }
+    expect_exact: 'export default(function(){while(!console);})()?"FAIL":"PASS";'
+}
+
+defaults_regexp: {
+    input: {
+        export default /foo/;
+    }
+    expect_exact: "export default/foo/;"
+}
+
+foreign: {
+    input: {
+        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";
+    }
+    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";'
+}
+
+same_quotes: {
+    beautify = {
+        beautify: true,
+        quote_style: 3,
+    }
+    input: {
+        export * from 'foo';
+        export {} from "bar";
+    }
+    expect_exact: [
+        "export * from 'foo';",
+        "",
+        'export {} from "bar";',
+    ]
+}
+
+drop_unused: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default 42;
+        export default (x, y) => x * x;
+        export default class A extends B { get p() { h() } }
+        export default function*(a, b) {}
+        export default async function f({ c }, ...[ d ]) {}
+        export var e;
+        export function g(x, [ y ], ...z) {}
+        function h() {}
+    }
+    expect: {
+        export default 42;
+        export default (x, y) => x * x;
+        export default class extends B { get p() { h() } }
+        export default function*(a, b) {}
+        export default async function({}) {}
+        export var e;
+        export function g(x, []) {}
+        function h() {}
+    }
+}
+
+mangle: {
+    rename = false
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        const a = 42;
+        export let b, { foo: c } = a;
+        export function f(d, { [b]: e }) {
+            d(e, f);
+        }
+        export default a;
+        export default async function g(x, ...{ [c]: y }) {
+            (await x)(g, y);
+        }
+    }
+    expect: {
+        const t = 42;
+        export let b, { foo: c } = t;
+        export function f(t, { [b]: o }) {
+            t(o, f);
+        }
+        export default t;
+        export default async function e(t, ...{ [c]: o}) {
+            (await t)(e, o);
+        }
+    }
+}
+
+mangle_rename: {
+    rename = true
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        const a = 42;
+        export let b, { foo: c } = a;
+        export function f(d, { [b]: e }) {
+            d(e, f);
+        }
+        export default a;
+        export default async function g(x, ...{ [c]: y }) {
+            (await x)(g, y);
+        }
+    }
+    expect: {
+        const t = 42;
+        export let b, { foo: c } = t;
+        export function f(t, { [b]: o }) {
+            t(o, f);
+        }
+        export default t;
+        export default async function e(t, ...{ [c]: o}) {
+            (await t)(e, o);
+        }
+    }
+}
+
+hoist_exports_1: {
+    options = {
+        hoist_exports: true,
+    }
+    input: {
+        export { a };
+        export var b;
+        export function f() {}
+    }
+    expect: {
+        var b;
+        function f() {}
+        export { a, b, f };
+    }
+}
+
+hoist_exports_2: {
+    options = {
+        evaluate: true,
+        hoist_exports: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        const a = 42;
+        export let bbb, { foo: ccc } = a;
+        export function fff(d, { [bbb]: e }) {
+            d(e, fff);
+        }
+        export default a;
+        export default async function g(x, ...{ [ccc]: y }) {
+            (await x)(g, y);
+        }
+    }
+    expect: {
+        let e, { foo: a } = 42;
+        function f(t, { [e]: o }) {
+            t(o, f);
+        }
+        export default 42;
+        export default async function n(t, ...{ [a]: o }) {
+            (await t)(n, o);
+        };
+        export { e as bbb, a as ccc, f as fff };
+    }
+}
+
+hoist_vars: {
+    options = {
+        hoist_vars: true,
+    }
+    input: {
+        var a;
+        export var b = 42;
+    }
+    expect: {
+        var a;
+        export var b = 42;
+    }
+}
+
+keep_return_values: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        export default function() {
+            return [];
+        }
+        export default function f() {
+            return null;
+        }
+    }
+    expect: {
+        export default function() {
+            return [];
+        }
+        export default function f() {
+            return null;
+        }
+    }
+}
+
+in_use: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f() {}
+        f.prototype.p = 42;
+    }
+    expect: {
+        export function f() {}
+        f.prototype.p = 42;
+    }
+}
+
+in_use_default: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f() {}
+        f.prototype.p = 42;
+    }
+    expect: {
+        export default function f() {}
+        f.prototype.p = 42;
+    }
+}
+
+single_use: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f() {
+            console.log("PASS");
+        }
+        f();
+    }
+    expect: {
+        export function f() {
+            console.log("PASS");
+        }
+        f();
+    }
+}
+
+single_use_default: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f() {
+            console.log("PASS");
+        }
+        f();
+    }
+    expect: {
+        export default function f() {
+            console.log("PASS");
+        }
+        f();
+    }
+}
+
+single_use_class: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class A {}
+        A.prototype.p = "PASS";
+    }
+    expect: {
+        export class A {}
+        A.prototype.p = "PASS";
+    }
+}
+
+single_use_class_default: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class A {}
+        A.prototype.p = "PASS";
+    }
+    expect: {
+        export default class A {}
+        A.prototype.p = "PASS";
+    }
+}
+
+hoist_funs: {
+    options = {
+        hoist_funs: true,
+    }
+    input: {
+        export function f() {}
+        export default async function* g() {}
+    }
+    expect_exact: "export function f(){}export default async function*g(){}"
+}
+
+issue_4742_join_vars_1: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var a = 42;
+        export var a;
+    }
+    expect: {
+        var a = 42;
+        export var a;
+    }
+}
+
+issue_4742_join_vars_2: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        export var a = "foo";
+        var b;
+        b = "bar";
+    }
+    expect: {
+        export var a = "foo";
+        var b, b = "bar";
+    }
+}
+
+issue_4742_unused_1: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var a = 42;
+        export var a;
+    }
+    expect: {
+        var a = 42;
+        export var a;
+    }
+}
+
+issue_4742_unused_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export var a = "foo";
+        var a = "bar";
+    }
+    expect: {
+        export var a = "foo";
+        a = "bar";
+    }
+}
+
+issue_4761: {
+    input: {
+        export default "function" == 42;
+    }
+    expect_exact: 'export default"function"==42;'
+}
+
+issue_4766: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var a = "foo";
+        export var a = "bar";
+    }
+    expect: {
+        var a = "foo";
+        export var a = "bar";
+    }
+}

test/compress/hoist_props.js

@@ -1068,3 +1068,29 @@ issue_4023: {
     }
     expect_stdout: "true"
 }
+
+object_super: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            f(a) {
+                return a ? console.log("PASS") : super.log("PASS");
+            },
+        };
+        o.f(42);
+    }
+    expect: {
+        var o = {
+            f(a) {
+                return a ? console.log("PASS") : super.log("PASS");
+            },
+        };
+        o.f(42);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/hoist_vars.js

@@ -152,7 +152,7 @@ issue_4487: {
     }
     expect: {
         function a() {
-            var a = console.log(typeof a);
+            var f = console.log(typeof f);
         }
         a();
     }
@@ -207,3 +207,192 @@ issue_4517: {
     }
     expect_stdout: "2boolean"
 }
+
+issue_4736: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        hoist_vars: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        function f() {
+            (function g() {
+                var b = (a = 0, 1 << 30);
+                var c = (a = 0, console.log(b));
+                var d = c;
+            })(f);
+        }
+        f();
+    }
+    expect: {
+        (function() {
+            (function() {
+                0,
+                console.log(1073741824);
+            })();
+        })();
+    }
+    expect_stdout: "1073741824"
+}
+
+issue_4839: {
+    options = {
+        evaluate: true,
+        hoist_vars: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = function(a, b) {
+            return b && b;
+        }("foo");
+        for (var k in o)
+            throw "FAIL";
+        console.log("PASS");
+    }
+    expect: {
+        var k, o = void 0;
+        for (k in o)
+            throw "FAIL";
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4859: {
+    options = {
+        evaluate: true,
+        hoist_vars: true,
+        keep_infinity: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b = (a = 2, 1 / 0), c = 3;
+            var d = a + b;
+            console.log(d);
+            return f;
+        }
+        f();
+    }
+    expect: {
+        (function f(a) {
+            var d = 1 / 0, d = Infinity;
+            console.log(d);
+            return f;
+        })();
+    }
+    expect_stdout: "Infinity"
+}
+
+issue_4893_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {}
+            var a = null;
+            var b = null;
+            var c = null;
+            b.p += a = 42;
+            f;
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try{
+            (function f() {
+                var b;
+                b = null;
+                b.p += 42;
+                f;
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4893_2: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {}
+            var a = null;
+            var b = null;
+            var c = null;
+            b.p += a = 42;
+            f;
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try{
+            (function() {
+                var b;
+                b = null;
+                b.p += 42;
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4898: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        hoist_vars: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        do {
+            var b = [ console.log("PASS") ];
+            var c = b;
+        } while (c.p = 0);
+    }
+    expect: {
+        var b;
+        b = [ console.log("PASS") ];
+        b.p = 0;
+    }
+    expect_stdout: "PASS"
+}

test/compress/ie8.js

@@ -2653,7 +2653,9 @@ issue_4019: {
             try {
                 console.log("FAIL");
             } catch (o) {}
-        }, o = (console.log(o.length), ++o);
+        };
+        console.log(o.length),
+        ++o;
     }
     expect_stdout: "0"
 }
@@ -2919,3 +2921,99 @@ issue_4568: {
     }
     expect_stdout: "undefined 1"
 }
+
+issue_4729: {
+    options = {
+        ie8: true,
+        pure_getters: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        try {
+            f;
+        } catch (e) {
+            var a = a && a[function f() {}];
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            f;
+        } catch (e) {
+            (function f() {});
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4928_1: {
+    options = {
+        ie8: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f() {
+            f(a);
+        };
+        console.log(typeof f);
+    }
+    expect: {
+        var a = function f() {
+            f(a);
+        };
+        console.log(typeof f);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4928_2: {
+    options = {
+        ie8: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        switch (42) {
+          case console:
+            var a = function f() {
+                f(a);
+            };
+          case 42:
+            var a = console.log("PASS");
+        }
+    }
+    expect: {
+        switch (42) {
+          case console:
+            var a = function f() {
+                f(a);
+            };
+          case 42:
+            a = console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4958: {
+    options = {
+        collapse_vars: true,
+        ie8: true,
+    }
+    input: {
+        console.log(function arguments(a) {
+            a = 21;
+            return arguments[0] + 21;
+        }("FAIL"));
+    }
+    expect: {
+        console.log(function arguments(a) {
+            a = 21;
+            return arguments[0] + 21;
+        }("FAIL"));
+    }
+    expect_stdout: "42"
+}

test/compress/imports.js

@@ -0,0 +1,211 @@
+nought: {
+    input: {
+        import "foo";
+    }
+    expect_exact: 'import"foo";'
+}
+
+default_only: {
+    input: {
+        import foo from "bar";
+    }
+    expect_exact: 'import foo from"bar";'
+}
+
+all_only: {
+    input: {
+        import * as foo from "bar";
+    }
+    expect_exact: 'import*as foo from"bar";'
+}
+
+keys_only: {
+    input: {
+        import { as as foo, bar, delete as baz } from "moo";
+    }
+    expect_exact: 'import{as as foo,bar,delete as baz}from"moo";'
+}
+
+default_all: {
+    input: {
+        import foo, * as bar from "baz";
+    }
+    expect_exact: 'import foo,*as bar from"baz";'
+}
+
+default_keys: {
+    input: {
+        import foo, { bar } from "baz";
+    }
+    expect_exact: 'import foo,{bar}from"baz";'
+}
+
+dynamic: {
+    input: {
+        (async a => await import(a))("foo").then(bar);
+    }
+    expect_exact: '(async a=>await import(a))("foo").then(bar);'
+}
+
+dynamic_nought: {
+    input: {
+        import(foo);
+    }
+    expect_exact: "import(foo);"
+}
+
+import_meta_1: {
+    input: {
+        console.log(import.meta, import.meta.url);
+    }
+    expect_exact: "console.log(import.meta,import.meta.url);"
+}
+
+import_meta_2: {
+    input: {
+        import.meta.url.split("/").forEach(function(part, index) {
+            console.log(index, part);
+        });
+    }
+    expect_exact: 'import.meta.url.split("/").forEach(function(part,index){console.log(index,part)});'
+}
+
+same_quotes: {
+    beautify = {
+        beautify: true,
+        quote_style: 3,
+    }
+    input: {
+        import 'foo';
+        import "bar";
+    }
+    expect_exact: [
+        "import 'foo';",
+        "",
+        'import "bar";',
+    ]
+}
+
+drop_unused: {
+    options = {
+        imports: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        import a, * as b from "foo";
+        import { c, bar as d } from "baz";
+        console.log(c);
+    }
+    expect: {
+        import "foo";
+        import { c as c } from "baz";
+        console.log(c);
+    }
+}
+
+mangle: {
+    rename = false
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import foo, { bar } from "baz";
+        consoe.log(moo);
+        import * as moo from "moz";
+    }
+    expect: {
+        import o, { bar as m } from "baz";
+        consoe.log(r);
+        import * as r from "moz";
+    }
+}
+
+rename_mangle: {
+    rename = true
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import foo, { bar } from "baz";
+        consoe.log(moo);
+        import * as moo from "moz";
+    }
+    expect: {
+        import o, { bar as m } from "baz";
+        consoe.log(r);
+        import * as r from "moz";
+    }
+}
+
+keep_ref: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        import foo from "bar";
+        foo();
+    }
+    expect: {
+        import foo from "bar";
+        foo();
+    }
+}
+
+forbid_merge: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        import A from "foo";
+        export default class extends A {}
+        var f = () => () => {};
+        f();
+        f();
+    }
+    expect: {
+        import A from "foo";
+        export default class extends A {}
+        var f = () => () => {};
+        f();
+        f();
+    }
+}
+
+issue_4708_1: {
+    options = {
+        imports: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        import a from "foo";
+    }
+    expect: {
+        var a;
+        import a from "foo";
+    }
+}
+
+issue_4708_2: {
+    options = {
+        imports: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        console.log(a);
+        import a from "foo";
+    }
+    expect: {
+        var a;
+        console.log(a);
+        import a from "foo";
+    }
+}

test/compress/issue-12.js

@@ -2,61 +2,77 @@ keep_name_of_getter: {
     options = {
         unused: true,
     }
-    input: { a = { get foo () {} } }
-    expect: { a = { get foo () {} } }
+    input: {
+        a = {
+            get foo() {},
+        };
+    }
+    expect: {
+        a = {
+            get foo() {},
+        };
+    }
 }
 
 keep_name_of_setter: {
     options = {
         unused: true,
     }
-    input: { a = { set foo () {} } }
-    expect: { a = { set foo () {} } }
+    input: {
+        a = {
+            set foo(v) {},
+        };
+    }
+    expect: {
+        a = {
+            set foo(v) {},
+        };
+    }
 }
 
 setter_with_operator_keys: {
     input: {
-        var tokenCodes  = {
-            get instanceof(){
+        var tokenCodes = {
+            get instanceof() {
                 return test0;
             },
-            set instanceof(value){
+            set instanceof(value) {
                 test0 = value;
             },
-            set typeof(value){
+            set typeof(value) {
                 test1 = value;
             },
-            get typeof(){
+            get typeof() {
                 return test1;
             },
-            set else(value){
+            set else(value) {
                 test2 = value;
             },
-            get else(){
+            get else() {
                 return test2;
-            }
+            },
         };
     }
     expect: {
-        var tokenCodes  = {
-            get instanceof(){
+        var tokenCodes = {
+            get instanceof() {
                 return test0;
             },
-            set instanceof(value){
+            set instanceof(value) {
                 test0 = value;
             },
-            set typeof(value){
+            set typeof(value) {
                 test1 = value;
             },
-            get typeof(){
+            get typeof() {
                 return test1;
             },
-            set else(value){
+            set else(value) {
                 test2 = value;
             },
-            get else(){
+            get else() {
                 return test2;
-            }
+            },
         };
     }
-}
+}

test/compress/issue-1202.js

@@ -4,7 +4,7 @@ mangle_keep_fnames_false: {
         keep_fnames: true,
     }
     mangle = {
-        keep_fnames : false,
+        keep_fnames: false,
     }
     input: {
         "use strict";
@@ -30,7 +30,7 @@ mangle_keep_fnames_true: {
         keep_fnames: true,
     }
     mangle = {
-        keep_fnames : true,
+        keep_fnames: true,
     }
     input: {
         "use strict";

test/compress/issue-1261.js

@@ -1,5 +1,6 @@
 pure_function_calls: {
     options = {
+        annotations: true,
         booleans: true,
         comparisons: true,
         conditionals: true,
@@ -60,6 +61,7 @@ pure_function_calls: {
 
 pure_function_calls_toplevel: {
     options = {
+        annotations: true,
         booleans: true,
         comparisons: true,
         conditionals: true,
@@ -126,6 +128,7 @@ pure_function_calls_toplevel: {
 
 should_warn: {
     options = {
+        annotations: true,
         booleans: true,
         conditionals: true,
         evaluate: true,

test/compress/issue-269.js

@@ -17,7 +17,7 @@ issue_269_1: {
     expect: {
         var x = {};
         console.log(
-            x + "", +x, !!x,
+            "" + x, +("" + x), !!x,
             "", 0, false
         );
     }

test/compress/issue-281.js

@@ -426,6 +426,7 @@ wrap_iife_in_return_call: {
 
 pure_annotation_1: {
     options = {
+        annotations: true,
         inline: true,
         side_effects: true,
     }
@@ -439,6 +440,7 @@ pure_annotation_1: {
 
 pure_annotation_2: {
     options = {
+        annotations: true,
         collapse_vars: true,
         inline: true,
         side_effects: true,
@@ -463,15 +465,19 @@ drop_fargs: {
         var a = 1;
         !function(a_1) {
             a++;
-        }(a++ + (a && a.var));
+        }(a++ + (a && console.log(a)));
         console.log(a);
     }
     expect: {
         var a = 1;
-        ++a && a.var, a++;
+        ++a && console.log(a),
+        a++;
         console.log(a);
     }
-    expect_stdout: "3"
+    expect_stdout: [
+        "2",
+        "3",
+    ]
 }
 
 keep_fargs: {
@@ -486,13 +492,17 @@ keep_fargs: {
         var a = 1;
         !function(a_1) {
             a++;
-        }(a++ + (a && a.var));
+        }(a++ + (a && console.log(a)));
         console.log(a);
     }
     expect: {
         var a = 1;
-        ++a && a.var, a++;
+        ++a && console.log(a),
+        a++;
         console.log(a);
     }
-    expect_stdout: "3"
+    expect_stdout: [
+        "2",
+        "3",
+    ]
 }

test/compress/join_vars.js

@@ -1024,7 +1024,7 @@ issue_3856: {
     expect_stdout: "undefined"
 }
 
-issue_3916: {
+issue_3916_1: {
     options = {
         join_vars: true,
     }
@@ -1044,8 +1044,8 @@ issue_3916: {
         var o = {
             p: "PASS",
             __proto__: 42,
-            q: "FAIL",
         };
+        o.q = "FAIL";
         o.__proto__ = {
             p: "FAIL",
             q: "PASS",
@@ -1055,3 +1055,131 @@ issue_3916: {
     }
     expect_stdout: "object PASS true PASS"
 }
+
+issue_3916_2: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var log = console.log, o = {};
+        o.p = "FAIL 1";
+        o.__proto__ = {
+            get p() {
+                return "FAIL 2";
+            },
+            set p(u) {
+                log("FAIL 3");
+            },
+            set q(v) {
+                log("PASS 1");
+            },
+            get q() {
+                return "PASS 3";
+            },
+        };
+        o.p = "PASS 2";
+        o.q = "FAIL 4";
+        log(o.p);
+        log(o.q);
+    }
+    expect: {
+        var log = console.log, o = {
+            p: "FAIL 1",
+            __proto__: {
+                get p() {
+                    return "FAIL 2";
+                },
+                set p(u) {
+                    log("FAIL 3");
+                },
+                set q(v) {
+                    log("PASS 1");
+                },
+                get q() {
+                    return "PASS 3";
+                },
+            },
+        };
+        o.p = "PASS 2";
+        o.q = "FAIL 4";
+        log(o.p);
+        log(o.q);
+    }
+    expect_stdout: [
+        "PASS 1",
+        "PASS 2",
+        "PASS 3",
+    ]
+}
+
+assign_var: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        b = "foo";
+        var a = [ , "bar" ];
+        console.log(b);
+        for (var b in a)
+            console.log(b, a[b]);
+    }
+    expect: {
+        var b = "foo", a = [ , "bar" ], b;
+        console.log(b);
+        for (b in a)
+            console.log(b, a[b]);
+    }
+    expect_stdout: [
+        "foo",
+        "1 bar",
+    ]
+}
+
+assign_for_var: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        i = "foo",
+        a = new Array(i, "bar");
+        for (var i = 2; --i >= 0;) {
+            console.log(a[i]);
+            for (var a in i);
+        }
+    }
+    expect: {
+        for (var i = "foo", a = new Array(i, "bar"), i = 2; --i >= 0;) {
+            console.log(a[i]);
+            for (var a in i);
+        }
+    }
+    expect_stdout: [
+        "bar",
+        "foo",
+    ]
+}
+
+assign_sequence_var: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var a = 0, b = 1;
+        console.log(a),
+        a++,
+        b = 2;
+        var c = 3;
+        console.log(a, b, c);
+    }
+    expect: {
+        var a = 0, b = 1;
+        console.log(a),
+        a++;
+        var b = 2, c = 3;
+        console.log(a, b, c);
+    }
+    expect_stdout: [
+        "0",
+        "1 2 3",
+    ]
+}

test/compress/keep_fargs.js

@@ -117,6 +117,7 @@ issue_1858: {
         collapse_vars: true,
         keep_fargs: false,
         pure_getters: true,
+        reduce_vars: true,
         unused: true,
     }
     input: {
@@ -438,7 +439,7 @@ issue_2506: {
         function f0(bar) {
             (function() {
                 (function() {
-                    if (false <= NaN & this >> 1 >= 0)
+                    if (false <= 0/0 & this >> 1 >= 0)
                         c++;
                 })(c++);
             })();

test/compress/let.js

@@ -20,6 +20,39 @@ retain_block: {
     node_version: ">=4"
 }
 
+retain_assignment: {
+    options = {
+        dead_code: true,
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            return a = 0;
+            let a;
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        function f() {
+            return a = 0;
+            let a;
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 retain_catch: {
     options = {
         dead_code: true,
@@ -359,7 +392,7 @@ reduce_block_2_toplevel: {
     node_version: ">=4"
 }
 
-reduce_vars: {
+reduce_vars_1: {
     options = {
         evaluate: true,
         reduce_vars: true,
@@ -381,6 +414,86 @@ reduce_vars: {
     node_version: ">=4"
 }
 
+reduce_vars_2: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        (function() {
+            function f() {
+                console.log(typeof a);
+            }
+            for (let a in [ 42 ])
+                f();
+        })();
+    }
+    expect: {
+        "use strict";
+        (function() {
+            function f() {
+                console.log(typeof a);
+            }
+            for (let a in [ 42 ])
+                f();
+        })();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+reduce_vars_3: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        (function(a) {
+            let i = 1;
+            function f() {
+                i = 0;
+            }
+            for (let i = 0, x = 0; i < a.length; i++, x++) {
+                if (x != i) {
+                    console.log("FAIL");
+                    break;
+                }
+                f();
+                console.log(a[i]);
+            }
+            console.log(i);
+        })([ 4, 2 ]);
+    }
+    expect: {
+        "use strict";
+        (function(a) {
+            let i = 1;
+            function f() {
+                i = 0;
+            }
+            for (let i = 0, x = 0; i < a.length; i++, x++) {
+                if (x != i) {
+                    console.log("FAIL");
+                    break;
+                }
+                f();
+                console.log(a[i]);
+            }
+            console.log(i);
+        })([ 4, 2 ]);
+    }
+    expect_stdout: [
+        "4",
+        "2",
+        "0",
+    ]
+    node_version: ">=4"
+}
+
 hoist_props: {
     options = {
         hoist_props: true,
@@ -456,6 +569,38 @@ loop_block_2: {
     node_version: ">=4"
 }
 
+do_break: {
+    options = {
+        loops: true,
+    }
+    input: {
+        "use strict";
+        try {
+            do {
+                if (a)
+                    break;
+                let a;
+            } while (!console);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            do {
+                if (a)
+                    break;
+                let a;
+            } while (!console);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 do_continue: {
     options = {
         loops: true,
@@ -516,6 +661,82 @@ dead_block_after_return: {
     node_version: ">=4"
 }
 
+if_return_1: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            function g() {
+                return b = "PASS";
+            }
+            if (a)
+                return g();
+            let b;
+            return g();
+        };
+        console.log(f());
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            function g() {
+                return b = "PASS";
+            }
+            if (a)
+                return g();
+            let b;
+            return g();
+        };
+        console.log(f());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+if_return_2: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            function g() {
+                return b = "FAIL";
+            }
+            if (a)
+                return g();
+            let b;
+            return g();
+        };
+        try {
+            console.log(f(42));
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            function g() {
+                return b = "FAIL";
+            }
+            if (a)
+                return g();
+            let b;
+            return g();
+        };
+        try {
+            console.log(f(42));
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 do_if_continue_1: {
     options = {
         if_return: true,
@@ -610,6 +831,28 @@ drop_unused: {
     node_version: ">=4"
 }
 
+default_init: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        let a;
+        a = "PASS";
+        console.log(a);
+    }
+    expect: {
+        "use strict";
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 issue_4191: {
     options = {
         functions: true,
@@ -795,6 +1038,7 @@ issue_4210: {
 issue_4212_1: {
     options = {
         dead_code: true,
+        reduce_vars: true,
     }
     input: {
         "use strict";
@@ -1319,7 +1563,6 @@ issue_4531_2: {
         toplevel: true,
     }
     input: {
-        "use strict";
         var a = console;
         console.log(typeof a, function a() {
             let { [console]: a } = 0 && a;
@@ -1328,7 +1571,6 @@ issue_4531_2: {
         }());
     }
     expect: {
-        "use strict";
         var o = console;
         console.log(typeof o, function o() {
             let { [console]: o } = 0;
@@ -1339,3 +1581,134 @@ issue_4531_2: {
     expect_stdout: "object undefined"
     node_version: ">=6"
 }
+
+issue_4689: {
+    options = {
+        sequences: true,
+    }
+    input: {
+        "use strict";
+        var a = "PASS";
+        console.log(a);
+        for (let a in 42);
+    }
+    expect: {
+        "use strict";
+        var a = "PASS";
+        console.log(a);
+        for (let a in 42);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4691: {
+    options = {
+        if_return: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        function A() {}
+        A.prototype.f = function() {
+            if (!this)
+                return;
+            let a = "PA";
+            function g(b) {
+                h(a + b);
+            }
+            [ "SS" ].forEach(function(c) {
+                g(c);
+            });
+        };
+        function h(d) {
+            console.log(d);
+        }
+        new A().f();
+    }
+    expect: {
+        "use strict";
+        function A() {}
+        A.prototype.f = function() {
+            if (this) {
+                let a = "PA";
+                [ "SS" ].forEach(function(c) {
+                    g(c);
+                });
+                function g(b) {
+                    h(a + b);
+                }
+            }
+        };
+        function h(d) {
+            console.log(d);
+        }
+        new A().f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4848: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            a(function() {
+                console.log(b);
+            });
+            if (!console)
+                return;
+            let b = "PASS";
+        }
+        var g;
+        f(function(h) {
+            g = h;
+        });
+        g();
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            a(function() {
+                console.log(b);
+            });
+            if (!console)
+                return;
+            let b = "PASS";
+        }
+        var g;
+        f(function(h) {
+            g = h;
+        });
+        g();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4985: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        let a = { p: 42 };
+        console.log(function() {
+            a;
+        }());
+    }
+    expect: {
+        "use strict";
+        let a = { p: 42 };
+        console.log(function() {
+            a;
+        }());
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}

test/compress/loops.js

@@ -501,14 +501,14 @@ do_switch: {
     }
 }
 
-in_parenthesis_1: {
+in_parentheses_1: {
     input: {
         for (("foo" in {});0;);
     }
     expect_exact: 'for(("foo"in{});0;);'
 }
 
-in_parenthesis_2: {
+in_parentheses_2: {
     input: {
         for ((function(){ "foo" in {}; });0;);
     }
@@ -828,6 +828,44 @@ empty_for_in_prop_init: {
     ]
 }
 
+for_of: {
+    input: {
+        var a = [ "PASS", 42 ];
+        a.p = "FAIL";
+        for (a of (null, a))
+            console.log(a);
+    }
+    expect_exact: 'var a=["PASS",42];a.p="FAIL";for(a of(null,a))console.log(a);'
+    expect_stdout: true
+    node_version: ">=0.12"
+}
+
+for_async_of: {
+    input: {
+        var async = [ "PASS", 42 ];
+        async.p = "FAIL";
+        for (async of (null, async))
+            console.log(async);
+    }
+    expect_exact: 'var async=["PASS",42];async.p="FAIL";for(async of(null,async))console.log(async);'
+    expect_stdout: true
+    node_version: ">=0.12 <16"
+}
+
+for_of_regexp: {
+    input: {
+        for (var a of /foo/);
+    }
+    expect_exact: "for(var a of/foo/);"
+}
+
+for_await_of_regexp: {
+    input: {
+        for await (var a of /foo/);
+    }
+    expect_exact: "for await(var a of/foo/);"
+}
+
 issue_3631_1: {
     options = {
         dead_code: true,
@@ -1052,7 +1090,6 @@ issue_4084: {
     options = {
         keep_fargs: false,
         loops: true,
-        passes: 2,
         reduce_vars: true,
         unused: true,
     }
@@ -1261,6 +1298,7 @@ issue_4355: {
         dead_code: true,
         evaluate: true,
         loops: true,
+        passes: 2,
         side_effects: true,
         unused: true,
     }

test/compress/merge_vars.js

@@ -2620,9 +2620,9 @@ issue_4126_1: {
             try {
                 console.log("PASS");
             } catch (e) {
-                var b = a;
+                var c = a;
             } finally {
-                var c = b;
+                var c = c;
             }
             console.log(c);
         }
@@ -3183,3 +3183,198 @@ issue_4257: {
         "1",
     ]
 }
+
+issue_4628: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function() {
+            try {
+                console;
+            } finally {
+                var b = a;
+            }
+            for (var a in "foo");
+            console.log(b);
+        })();
+    }
+    expect: {
+        (function() {
+            try {
+                console;
+            } finally {
+                var b = a;
+            }
+            for (var a in "foo");
+            console.log(b);
+        })();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4653: {
+    options = {
+        evaluate: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1, b;
+        function f(c, d) {
+            c || console.log(d);
+        }
+        f(a++ + (b = b), b |= console.log(a));
+    }
+    expect: {
+        var b = 1;
+        (function(c, d) {
+            c || console.log(d);
+        })(+b + (b = void 0), b |= console.log(2));
+    }
+    expect_stdout: [
+        "2",
+        "0",
+    ]
+}
+
+issue_4759: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var i = 2, a = 1, b, c, d;
+        while (i--) {
+            try {
+                if (1 != b) {
+                    d = [];
+                    null.p;
+                    c = d;
+                } else {
+                    b = 0;
+                    a = c;
+                }
+            } catch (e) {}
+            b = a;
+        }
+        console.log(a);
+    }
+    expect: {
+        var i = 2, a = 1, b, c, d;
+        while (i--) {
+            try {
+                if (1 != b) {
+                    d = [];
+                    null.p;
+                    c = d;
+                } else {
+                    b = 0;
+                    a = c;
+                }
+            } catch (e) {}
+            b = a;
+        }
+        console.log(a);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4761: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL", b;
+        try {
+            !a && --a && (b = 0)[console] || console.log(b);
+        } catch (e) {}
+    }
+    expect: {
+        var a = "FAIL", b;
+        try {
+            !a && --a && (b = 0)[console] || console.log(b);
+        } catch (e) {}
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4956_1: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b;
+        function f(c) {
+            switch (c) {
+              case 0:
+                a = { p: 42 };
+
+              case 1:
+                b = a.p;
+                console.log(b);
+            }
+        }
+        f(0);
+        f(1);
+    }
+    expect: {
+        var a, b;
+        function f(c) {
+            switch (c) {
+              case 0:
+                a = { p: 42 };
+
+              case 1:
+                b = a.p;
+                console.log(b);
+            }
+        }
+        f(0);
+        f(1);
+    }
+    expect_stdout: [
+        "42",
+        "42",
+    ]
+}
+
+issue_4956_2: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b;
+        function f(c) {
+            if (0 == c) {
+                console;
+                a = { p: 42 };
+            }
+            b = a.p;
+            if (1 == c)
+                console.log(b);
+        }
+        f(0);
+        f(1);
+    }
+    expect: {
+        var a, b;
+        function f(c) {
+            if (0 == c) {
+                console;
+                a = { p: 42 };
+            }
+            b = a.p;
+            if (1 == c)
+                console.log(b);
+        }
+        f(0);
+        f(1);
+    }
+    expect_stdout: "42"
+}

test/compress/new.js

@@ -85,7 +85,7 @@ new_with_unary_prefix: {
     expect_exact: 'var bar=(+new Date).toString(32);';
 }
 
-dot_parenthesis_1: {
+dot_parentheses_1: {
     input: {
         console.log(new (Math.random().constructor) instanceof Number);
     }
@@ -93,7 +93,7 @@ dot_parenthesis_1: {
     expect_stdout: "true"
 }
 
-dot_parenthesis_2: {
+dot_parentheses_2: {
     input: {
         console.log(typeof new function(){Math.random()}.constructor);
     }

test/compress/nullish.js

@@ -0,0 +1,130 @@
+parentheses: {
+    input: {
+        (console.log("foo") || console.log("bar") ?? console.log("baz")) && console.log("moo");
+    }
+    expect_exact:'((console.log("foo")||console.log("bar"))??console.log("baz"))&&console.log("moo");'
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+    node_version: ">=14"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        void console.log("foo" ?? "bar") ?? console.log("baz");
+    }
+    expect: {
+        console.log("foo"),
+        console.log("baz");
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+    ]
+    node_version: ">=14"
+}
+
+conditional_assignment_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        console.log(function(a, b) {
+            b ?? (a = "FAIL");
+            return a;
+        }("PASS", !console));
+    }
+    expect: {
+        console.log(function(a, b) {
+            b ?? (a = "FAIL");
+            return a;
+        }("PASS", !console));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+conditional_assignment_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a, b = false;
+        a = "PASS",
+        b ?? (a = "FAIL"),
+        console.log(a);
+    }
+    expect: {
+        var a, b = false;
+        a = "PASS",
+        b ?? (a = "FAIL"),
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+conditional_assignment_3: {
+    options = {
+        conditionals: true,
+        join_vars: true,
+    }
+    input: {
+        var a, b = false;
+        a = "PASS",
+        b ?? (a = "FAIL"),
+        console.log(a);
+    }
+    expect: {
+        var a, b = false, a = "PASS";
+        b ?? (a = "FAIL"),
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+conditional_assignment_4: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        console.log(function(a) {
+            !console ?? (a = "FAIL");
+            return a;
+        }("PASS"));
+    }
+    expect: {
+        console.log(function(a) {
+            !console ?? (a = "FAIL");
+            return a;
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_4679: {
+    options = {
+        comparisons: true,
+        ie8: true,
+    }
+    input: {
+        var a;
+        if (void 0 === (undefined ?? a))
+            console.log("PASS");
+    }
+    expect: {
+        var a;
+        if (void 0 === (undefined ?? a))
+            console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}

test/compress/numbers.js

@@ -1,3 +1,10 @@
+literal_infinity: {
+    input: {
+        console.log(2e308, -1e2345);
+    }
+    expect_exact: "console.log(1/0,-(1/0));"
+}
+
 parentheses_for_prototype_functions: {
     beautify = {
         beautify: true,
@@ -97,6 +104,40 @@ parentheses_for_prototype_functions_galio: {
     expect_stdout: true
 }
 
+octal: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        (function() {
+            console.log(052);
+            console.log(-052);
+
+            console.log(018);
+            console.log(-018);
+
+            console.log(052.toFixed(0));
+            console.log(-052.toFixed(0));
+
+            console.log(018..toFixed(0));
+            console.log(-018..toFixed(0));
+        })();
+    }
+    expect_exact: [
+        "(function() {",
+        "    console.log(42);",
+        "    console.log(-42);",
+        "    console.log(18);",
+        "    console.log(-18);",
+        "    console.log(42..toFixed(0));",
+        "    console.log(-42..toFixed(0));",
+        "    console.log(18..toFixed(0));",
+        "    console.log(-18..toFixed(0));",
+        "})();",
+    ]
+    expect_stdout: true
+}
+
 comparisons: {
     options = {
         comparisons: true,
@@ -338,7 +379,7 @@ evaluate_3: {
         console.log(1 + Number(x) + 2);
     }
     expect: {
-        console.log(+x + 3);
+        console.log(+("" + x) + 3);
     }
 }
 
@@ -777,7 +818,7 @@ issue_1710: {
     expect_stdout: true
 }
 
-unary_binary_parenthesis: {
+unary_binary_parentheses: {
     options = {
         evaluate: true,
     }

test/compress/objects.js

@@ -280,6 +280,72 @@ shorthand_keywords: {
     node_version: ">=6"
 }
 
+object_super: {
+    input: {
+        var o = {
+            f() {
+                return super.p;
+            },
+            p: "FAIL",
+        };
+        Object.setPrototypeOf(o, { p: "PASS" });
+        console.log(o.f());
+    }
+    expect_exact: 'var o={f(){return super.p},p:"FAIL"};Object.setPrototypeOf(o,{p:"PASS"});console.log(o.f());'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+object_super_async: {
+    input: {
+        var o = {
+            async f() {
+                return super.p;
+            },
+            p: "FAIL",
+        };
+        Object.setPrototypeOf(o, { p: "PASS" });
+        o.f().then(console.log);
+    }
+    expect_exact: 'var o={async f(){return super.p},p:"FAIL"};Object.setPrototypeOf(o,{p:"PASS"});o.f().then(console.log);'
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+object_super_generator: {
+    input: {
+        var o = {
+            *f() {
+                yield super.p;
+            },
+            p: "FAIL",
+        };
+        Object.setPrototypeOf(o, { p: "PASS" });
+        console.log(o.f().next().value);
+    }
+    expect_exact: 'var o={*f(){yield super.p},p:"FAIL"};Object.setPrototypeOf(o,{p:"PASS"});console.log(o.f().next().value);'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+object_super_async_generator: {
+    input: {
+        var o = {
+            async *f() {
+                return super.p;
+            },
+            p: "FAIL",
+        };
+        Object.setPrototypeOf(o, { p: "PASS" });
+        o.f().next().then(function(v) {
+            console.log(v.value, v.done);
+        });
+    }
+    expect_exact: 'var o={async*f(){return super.p},p:"FAIL"};Object.setPrototypeOf(o,{p:"PASS"});o.f().next().then(function(v){console.log(v.value,v.done)});'
+    expect_stdout: "PASS true"
+    node_version: ">=10"
+}
+
 issue_4269_1: {
     options = {
         evaluate: true,

test/compress/optional-chains.js

@@ -0,0 +1,307 @@
+call: {
+    input: {
+        console.log?.(undefined?.(console.log("FAIL")));
+    }
+    expect_exact: 'console.log?.((void 0)?.(console.log("FAIL")));'
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+dot: {
+    input: {
+        console?.log((void 0)?.p);
+    }
+    expect_exact: "console?.log((void 0)?.p);"
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+dot_in: {
+    input: {
+        var o = { in: 42 };
+        console.log(o.in, o?.in);
+    }
+    expect_exact: "var o={in:42};console.log(o.in,o?.in);"
+    expect_stdout: "42 42"
+    node_version: ">=14"
+}
+
+sub: {
+    input: {
+        console?.["log"](null?.[console.log("FAIL")]);
+    }
+    expect_exact: 'console?.["log"](null?.[console.log("FAIL")]);'
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+ternary_decimal: {
+    input: {
+        null ? .42 : console.log("PASS");
+    }
+    expect_exact: 'null?.42:console.log("PASS");'
+    expect_stdout: "PASS"
+}
+
+assign_parentheses_call: {
+    input: {
+        var o = {};
+        ((() => o)?.()).p = "PASS";
+        console.log(o.p);
+    }
+    expect_exact: 'var o={};((()=>o)?.()).p="PASS";console.log(o.p);'
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+assign_parentheses_dot: {
+    input: {
+        (console?.log).name.p = console.log("PASS");
+    }
+    expect_exact: '(console?.log.name).p=console.log("PASS");'
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+assign_no_parentheses: {
+    input: {
+        console[console.log?.("PASS")] = 42;
+    }
+    expect_exact: 'console[console.log?.("PASS")]=42;'
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+unary_parentheses: {
+    input: {
+        var o = { p: 41 };
+        (function() {
+            return o;
+        }?.()).p++;
+        console.log(o.p);
+    }
+    expect_exact: "var o={p:41};(function(){return o}?.()).p++;console.log(o.p);"
+    expect_stdout: "42"
+    node_version: ">=14"
+}
+
+collapse_vars_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a;
+        A = 42;
+        a?.[42];
+        console.log(typeof A);
+    }
+    expect: {
+        var a;
+        A = 42;
+        a?.[42];
+        console.log(typeof A);
+    }
+    expect_stdout: "number"
+    node_version: ">=14"
+}
+
+collapse_vars_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a;
+        A = 42;
+        a?.(42);
+        console.log(typeof A);
+    }
+    expect: {
+        var a;
+        A = 42;
+        a?.(42);
+        console.log(typeof A);
+    }
+    expect_stdout: "number"
+    node_version: ">=14"
+}
+
+properties: {
+    options = {
+        evaluate: true,
+        properties: true,
+    }
+    input: {
+        var a;
+        console.log(a?.["FAIL"]);
+    }
+    expect: {
+        var a;
+        console.log(a?.FAIL);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+reduce_vars_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        null?.[a = 0];
+        console.log(a ? "PASS" : "FAIL");
+    }
+    expect: {
+        var a = 1;
+        null?.[a = 0];
+        console.log(a ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+reduce_vars_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        null?.(a = 0);
+        console.log(a ? "PASS" : "FAIL");
+    }
+    expect: {
+        var a = 1;
+        null?.(a = 0);
+        console.log(a ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+side_effects: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        var a;
+        a?.[a = "FAIL"];
+        console.log(a);
+    }
+    expect: {
+        var a;
+        a?.[a = "FAIL"];
+        console.log(a);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+trim_1: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        (function(a, b) {
+            console?.log?.(a?.p, b?.[console.log("FAIL")]);
+        })?.({ p: "PASS" });
+    }
+    expect: {
+        (function(a, b) {
+            console?.log?.(a.p, void 0);
+        })({ p: "PASS" });
+    }
+    expect_stdout: "PASS undefined"
+    node_version: ">=14"
+}
+
+trim_2: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+        side_effects: true,
+    }
+    input: {
+        (void console.log("PASS"))?.[console.log("FAIL")];
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_4906: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        do {
+            var a = a?.[42];
+        } while (console.log("PASS"));
+    }
+    expect: {
+        do {} while (console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_4928: {
+    options = {
+        ie8: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = a?.[function f() {
+            f(a);
+        }];
+        console.log(typeof f);
+    }
+    expect: {
+        var a = a?.[function f() {
+            f(a);
+        }];
+        console.log(typeof f);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+issue_4947_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        console.log(console.foo ? 42..p : console.bar?.p);
+    }
+    expect: {
+        console.log(console.foo ? 42..p : console.bar?.p);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+issue_4947_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var log = console.log, fail;
+        log("PASS") ? log(42) : fail?.(42);
+    }
+    expect: {
+        var log = console.log, fail;
+        log("PASS") ? log(42) : fail?.(42);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}

test/compress/properties.js

@@ -1378,3 +1378,88 @@ issue_3389: {
     }
     expect_stdout: "PASS"
 }
+
+object_super: {
+    options = {
+        properties: true,
+    }
+    input: {
+        ({
+            f(a) {
+                return a ? console.log("PASS") : super.log("PASS");
+            },
+        }).f(console);
+    }
+    expect: {
+        ({
+            f(a) {
+                return a ? console.log("PASS") : super.log("PASS");
+            },
+        }).f(console);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4831_1: {
+    options = {
+        properties: true,
+    }
+    input: {
+        console.log({
+            f() {
+                return arguments;
+            },
+        }.f("PASS")[0]);
+    }
+    expect: {
+        console.log([
+            function() {
+                return arguments;
+            },
+        ][0]("PASS")[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4831_2: {
+    options = {
+        properties: true,
+    }
+    input: {
+        var f = {
+            f() {
+                return arguments;
+            },
+        }.f;
+        console.log(f("PASS")[0]);
+    }
+    expect: {
+        var f = {
+            f() {
+                return arguments;
+            },
+        }.f;
+        console.log(f("PASS")[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4888: {
+    options = {
+        properties: true,
+    }
+    input: {
+        console.log(typeof {
+            __proto__: 42,
+        }.__proto__);
+    }
+    expect: {
+        console.log(typeof {
+            __proto__: 42,
+        }.__proto__);
+    }
+    expect_stdout: "object"
+}

test/compress/pure_funcs.js

@@ -133,7 +133,7 @@ conditional: {
 relational: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         foo() in new foo();
@@ -158,7 +158,7 @@ relational: {
 arithmetic: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         foo() + foo();
@@ -183,7 +183,7 @@ arithmetic: {
 boolean_and: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         foo() && foo();
@@ -208,7 +208,7 @@ boolean_and: {
 boolean_or: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         foo() || foo();
@@ -233,7 +233,7 @@ boolean_or: {
 assign: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         var a;
@@ -256,7 +256,7 @@ assign: {
 unary: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         typeof foo();
@@ -294,248 +294,6 @@ unary: {
     }
 }
 
-issue_2629_1: {
-    options = {
-        side_effects: true,
-    }
-    beautify = {
-        comments: "all",
-    }
-    input: {
-        /*@__PURE__*/ a();
-        /*@__PURE__*/ (b());
-        (/*@__PURE__*/ c)();
-        (/*@__PURE__*/ d());
-    }
-    expect_exact: [
-        "/* */c();",
-    ]
-}
-
-issue_2629_2: {
-    options = {
-        side_effects: true,
-    }
-    beautify = {
-        comments: "all",
-    }
-    input: {
-        /*@__PURE__*/ a(1)(2)(3);
-        /*@__PURE__*/ (b(1))(2)(3);
-        /*@__PURE__*/ (c(1)(2))(3);
-        /*@__PURE__*/ (d(1)(2)(3));
-        (/*@__PURE__*/ e)(1)(2)(3);
-        (/*@__PURE__*/ f(1))(2)(3);
-        (/*@__PURE__*/ g(1)(2))(3);
-        (/*@__PURE__*/ h(1)(2)(3));
-    }
-    expect_exact: [
-        "/* */e(1)(2)(3);",
-        "/* */f(1)(2)(3);",
-        "/* */g(1)(2)(3);",
-    ]
-}
-
-issue_2629_3: {
-    options = {
-        side_effects: true,
-    }
-    beautify = {
-        comments: "all",
-    }
-    input: {
-        /*@__PURE__*/ a.x(1).y(2).z(3);
-        /*@__PURE__*/ (b.x)(1).y(2).z(3);
-        /*@__PURE__*/ (c.x(1)).y(2).z(3);
-        /*@__PURE__*/ (d.x(1).y)(2).z(3);
-        /*@__PURE__*/ (e.x(1).y(2)).z(3);
-        /*@__PURE__*/ (f.x(1).y(2).z)(3);
-        /*@__PURE__*/ (g.x(1).y(2).z(3));
-        (/*@__PURE__*/ h).x(1).y(2).z(3);
-        (/*@__PURE__*/ i.x)(1).y(2).z(3);
-        (/*@__PURE__*/ j.x(1)).y(2).z(3);
-        (/*@__PURE__*/ k.x(1).y)(2).z(3);
-        (/*@__PURE__*/ l.x(1).y(2)).z(3);
-        (/*@__PURE__*/ m.x(1).y(2).z)(3);
-        (/*@__PURE__*/ n.x(1).y(2).z(3));
-    }
-    expect_exact: [
-        "/* */h.x(1).y(2).z(3);",
-        "/* */i.x(1).y(2).z(3);",
-        "/* */j.x(1).y(2).z(3);",
-        "/* */k.x(1).y(2).z(3);",
-        "/* */l.x(1).y(2).z(3);",
-        "/* */m.x(1).y(2).z(3);",
-    ]
-}
-
-issue_2629_4: {
-    options = {
-        side_effects: true,
-    }
-    input: {
-        (/*@__PURE__*/ x(), y());
-        (w(), /*@__PURE__*/ x(), y());
-    }
-    expect: {
-        y();
-        w(), y();
-    }
-}
-
-issue_2629_5: {
-    options = {
-        side_effects: true,
-    }
-    input: {
-        [ /*@__PURE__*/ x() ];
-        [ /*@__PURE__*/ x(), y() ];
-        [ w(), /*@__PURE__*/ x(), y() ];
-    }
-    expect: {
-        y();
-        w(), y();
-    }
-}
-
-issue_2638: {
-    options = {
-        side_effects: true,
-    }
-    beautify = {
-        comments: "all",
-    }
-    input: {
-        /*@__PURE__*/(g() || h())(x(), y());
-        (/*@__PURE__*/ (a() || b()))(c(), d());
-    }
-    expect_exact: [
-        "/* */x(),y();",
-        "/* */(a()||b())(c(),d());",
-    ]
-}
-
-issue_2705_1: {
-    options = {
-        side_effects: true,
-    }
-    beautify = {
-        comments: "all",
-    }
-    input: {
-        /*@__PURE__*/ new a();
-        /*@__PURE__*/ (new b());
-        new (/*@__PURE__*/ c)();
-        (/*@__PURE__*/ new d());
-    }
-    expect_exact: [
-        "new/* */c;",
-    ]
-}
-
-issue_2705_2: {
-    options = {
-        side_effects: true,
-    }
-    beautify = {
-        comments: "all",
-    }
-    input: {
-        /*@__PURE__*/ new a(1)(2)(3);
-        /*@__PURE__*/ new (b(1))(2)(3);
-        /*@__PURE__*/ new (c(1)(2))(3);
-        /*@__PURE__*/ new (d(1)(2)(3));
-        new (/*@__PURE__*/ e)(1)(2)(3);
-        (/*@__PURE__*/ new f(1))(2)(3);
-        (/*@__PURE__*/ new g(1)(2))(3);
-        (/*@__PURE__*/ new h(1)(2)(3));
-    }
-    expect_exact: [
-        "new/* */e(1)(2)(3);",
-        "/* */new f(1)(2)(3);",
-        "/* */new g(1)(2)(3);",
-    ]
-}
-
-issue_2705_3: {
-    options = {
-        side_effects: true,
-    }
-    beautify = {
-        comments: "all",
-    }
-    input: {
-        /*@__PURE__*/ new a.x(1).y(2).z(3);
-        /*@__PURE__*/ new (b.x)(1).y(2).z(3);
-        /*@__PURE__*/ new (c.x(1)).y(2).z(3);
-        /*@__PURE__*/ new (d.x(1).y)(2).z(3);
-        /*@__PURE__*/ new (e.x(1).y(2)).z(3);
-        /*@__PURE__*/ new (f.x(1).y(2).z)(3);
-        /*@__PURE__*/ new (g.x(1).y(2).z(3));
-        new (/*@__PURE__*/ h).x(1).y(2).z(3);
-        /* */ new (/*@__PURE__*/ i.x)(1).y(2).z(3);
-        (/*@__PURE__*/ new j.x(1)).y(2).z(3);
-        (/*@__PURE__*/ new k.x(1).y)(2).z(3);
-        (/*@__PURE__*/ new l.x(1).y(2)).z(3);
-        (/*@__PURE__*/ new m.x(1).y(2).z)(3);
-        (/*@__PURE__*/ new n.x(1).y(2).z(3));
-    }
-    expect_exact: [
-        "new/* */h.x(1).y(2).z(3);",
-        "/* */new/* */i.x(1).y(2).z(3);",
-        "/* */new j.x(1).y(2).z(3);",
-        "/* */new k.x(1).y(2).z(3);",
-        "/* */new l.x(1).y(2).z(3);",
-        "/* */new m.x(1).y(2).z(3);",
-    ]
-}
-
-issue_2705_4: {
-    options = {
-        side_effects: true,
-    }
-    input: {
-        (/*@__PURE__*/ new x(), y());
-        (w(), /*@__PURE__*/ new x(), y());
-    }
-    expect: {
-        y();
-        w(), y();
-    }
-}
-
-issue_2705_5: {
-    options = {
-        side_effects: true,
-    }
-    input: {
-        [ /*@__PURE__*/ new x() ];
-        [ /*@__PURE__*/ new x(), y() ];
-        [ w(), /*@__PURE__*/ new x(), y() ];
-    }
-    expect: {
-        y();
-        w(), y();
-    }
-}
-
-issue_2705_6: {
-    options = {
-        side_effects: true,
-    }
-    beautify = {
-        comments: "all",
-    }
-    input: {
-        /*@__PURE__*/new (g() || h())(x(), y());
-        /* */ new (/*@__PURE__*/ (a() || b()))(c(), d());
-    }
-    expect_exact: [
-        "/* */x(),y();",
-        "/* */new(/* */a()||b())(c(),d());",
-    ]
-}
-
 issue_3065_1: {
     options = {
         inline: true,
@@ -680,130 +438,3 @@ issue_3325_2: {
     }
     expect_stdout: "PASS"
 }
-
-issue_3858: {
-    options = {
-        collapse_vars: true,
-        inline: true,
-        keep_fargs: false,
-        unused: true,
-    }
-    input: {
-        var f = function(a) {
-            return /*@__PURE__*/ function(b) {
-                console.log(b);
-            }(a);
-        };
-        f("PASS");
-    }
-    expect: {
-        var f = function(a) {
-            return function() {
-                console.log(a);
-            }();
-        };
-        f("PASS");
-    }
-    expect_stdout: "PASS"
-}
-
-inline_pure_call_1: {
-    options = {
-        collapse_vars: true,
-        inline: true,
-        keep_fargs: false,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var f = function(a) {
-            return /*@__PURE__*/ function(b) {
-                console.log(b);
-            }(a);
-        };
-        f("PASS");
-    }
-    expect: {}
-}
-
-inline_pure_call_2: {
-    options = {
-        collapse_vars: true,
-        inline: true,
-        keep_fargs: false,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var f = function(a) {
-            return /*@__PURE__*/ function(b) {
-                console.log(b);
-            }(a);
-        };
-        var a = f("PASS");
-    }
-    expect: {}
-}
-
-inline_pure_call_3: {
-    options = {
-        collapse_vars: true,
-        evaluate: true,
-        inline: true,
-        keep_fargs: false,
-        passes: 2,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var f = function(a) {
-            return /*@__PURE__*/ function(b) {
-                console.log(b);
-            }(a);
-        };
-        var a = f("PASS");
-        console.log(a);
-    }
-    expect: {
-        var a = function() {
-            console.log("PASS");
-        }();
-        console.log(a);
-    }
-    expect_stdout: [
-        "PASS",
-        "undefined",
-    ]
-}
-
-inline_pure_call_4: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a = /*@__PURE__*/ function() {
-            return console.log("PASS"), 42;
-        }();
-        console.log(a);
-    }
-    expect: {
-        var a = function() {
-            return console.log("PASS"), 42;
-        }();
-        console.log(a);
-    }
-    expect_stdout: [
-        "PASS",
-        "42",
-    ]
-}

test/compress/pure_getters.js

@@ -248,6 +248,35 @@ issue_2110_2: {
     expect_stdout: "function"
 }
 
+issue_2110_3: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+    }
+    input: {
+        function g() {
+            return this;
+        }
+        console.log(typeof function() {
+            function f() {}
+            f.g = g;
+            return f.g();
+        }());
+    }
+    expect: {
+        function g() {
+            return this;
+        }
+        console.log(typeof function() {
+            function f() {}
+            f.g = g;
+            return f.g();
+        }());
+    }
+    expect_stdout: "function"
+}
+
 set_immutable_1: {
     options = {
         collapse_vars: true,
@@ -979,6 +1008,7 @@ collapse_vars_2_strict: {
 collapse_rhs_true: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: true,
     }
     input: {
@@ -1015,6 +1045,7 @@ collapse_rhs_true: {
 collapse_rhs_false: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: false,
     }
     input: {
@@ -1051,6 +1082,7 @@ collapse_rhs_false: {
 collapse_rhs_strict: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: "strict",
     }
     input: {
@@ -1087,6 +1119,7 @@ collapse_rhs_strict: {
 collapse_rhs_setter: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: "strict",
     }
     input: {
@@ -1187,13 +1220,110 @@ drop_arguments: {
     expect_stdout: "PASS"
 }
 
+lvalues_def: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = 0, b = 1;
+        var a = b++, b = +function() {}();
+        a && a[a++];
+        console.log(a, b);
+    }
+    expect: {
+        var a = 0, b = 1;
+        a = b++, b = +void 0;
+        a && a++;
+        console.log(a, b);
+    }
+    expect_stdout: true
+}
+
+side_effects_assign: {
+    options = {
+        evaluate: true,
+        pure_getters: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = typeof void (a && a.in == 1, 0);
+        console.log(a);
+    }
+    expect: {
+        var a = "undefined";
+        console.log(a);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_2062: {
+    options = {
+        booleans: true,
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 1;
+        if ([ a || a++ + a--, a++ + a--, a && a.var ]);
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        a || (a++, a--), a++, a--;
+        console.log(a);
+    }
+    expect_stdout: "1"
+}
+
+issue_2878: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+        sequences: true,
+    }
+    input: {
+        var c = 0;
+        (function(a, b) {
+            function f2() {
+                if (a) c++;
+            }
+            b = f2();
+            a = 1;
+            b && b.b;
+            f2();
+        })();
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        (function(a, b) {
+            function f2() {
+                if (a) c++;
+            }
+            b = f2(),
+            a = 1,
+            f2();
+        })(),
+        console.log(c);
+    }
+    expect_stdout: "1"
+}
+
 issue_3427: {
     options = {
-        assignments: true,
-        collapse_vars: true,
+        evaluate: true,
         inline: true,
-        passes: 2,
         pure_getters: "strict",
+        reduce_vars: true,
         sequences: true,
         side_effects: true,
         toplevel: true,
@@ -1209,6 +1339,74 @@ issue_3427: {
     expect_stdout: true
 }
 
+issue_3490_1: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        inline: true,
+        pure_getters: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var b = 42, c = "FAIL";
+        if ({
+            3: function() {
+                var a;
+                return (a && a.p) < this;
+            }(),
+        }) c = "PASS";
+        if (b) while ("" == typeof d);
+        console.log(c, b);
+    }
+    expect: {
+        var b = 42, c = "FAIL";
+        if (function() {
+            var a;
+        }(), c = "PASS", b) while ("" == typeof d);
+        console.log(c, b);
+    }
+    expect_stdout: "PASS 42"
+}
+
+issue_4135: {
+    options = {
+        evaluate: true,
+        inline: true,
+        merge_vars: true,
+        pure_getters: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0, b = 0;
+        --b;
+        a++;
+        if (!a)
+            var c = function() {
+                var d = 0;
+                function f() {
+                    d && d.p;
+                }
+                f();
+                this;
+            }(a++);
+        console.log(a, b, c);
+    }
+    expect: {
+        var a = 0;
+        0;
+        a++;
+        if (!a)
+            var c = void a++;
+        console.log(a, -1, c);
+    }
+    expect_stdout: "1 -1 undefined"
+}
+
 issue_4440: {
     options = {
         pure_getters: "strict",
@@ -1237,3 +1435,232 @@ issue_4440: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4730_1: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        var a;
+        console.log("PASS") + (a && a[a.p]);
+    }
+    expect: {
+        var a;
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4730_2: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        var a;
+        !console.log("PASS") || a && a[a.p];
+    }
+    expect: {
+        var a;
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4751: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            },
+        };
+        o && o.p;
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            },
+        };
+    }
+}
+
+super_toString: {
+    options = {
+        pure_getters: true,
+        unsafe: true,
+    }
+    input: {
+        console.log({
+            f() {
+                return super.toString();
+            },
+        }.f());
+    }
+    expect: {
+        console.log({
+            f() {
+                return super.toString();
+            },
+        }.f());
+    }
+    expect_stdout: "[object Object]"
+    node_version: ">=4"
+}
+
+this_toString: {
+    options = {
+        pure_getters: true,
+        unsafe: true,
+    }
+    input: {
+        console.log({
+            f() {
+                return this.toString();
+            },
+        }.f());
+    }
+    expect: {
+        console.log({
+            f() {
+                return "" + this;
+            },
+        }.f());
+    }
+    expect_stdout: "[object Object]"
+    node_version: ">=4"
+}
+
+issue_4803: {
+    options = {
+        hoist_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            get f() {
+                console.log("PASS");
+            },
+        } || 42;
+        for (var k in o)
+            o[k];
+    }
+    expect: {
+        var k, o = {
+            get f() {
+                console.log("PASS");
+            },
+        } || 42;
+        for (k in o)
+            o[k];
+    }
+    expect_stdout: "PASS"
+}
+
+nested_property_assignments_1: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var f;
+        ((f = function() {
+            console.log("FAIL");
+        }).p = f).q = console.log("PASS");
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+nested_property_assignments_2: {
+    options = {
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        var o = {};
+        (function() {
+            var a;
+            (o.p = a = {}).q = "PASS";
+        })();
+        console.log(o.p.q);
+    }
+    expect: {
+        var o = {};
+        (function() {
+            (o.p = {}).q = "PASS";
+        })();
+        console.log(o.p.q);
+    }
+    expect_stdout: "PASS"
+}
+
+nested_property_assignments_3: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var o = { p: {} };
+        (function(a) {
+            console && a;
+            if (console) {
+                a = a.p;
+                a.q = a;
+            }
+        })(o);
+        console.log(o.p.q === o.p ? "PASS" : "FAIL");
+    }
+    expect: {
+        var o = { p: {} };
+        (function(a) {
+            console;
+            if (console)
+                (a = a.p).q = a;
+        })(o);
+        console.log(o.p.q === o.p ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4939: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        ({
+            __proto__: {
+                get p() {
+                    console.log("PASS");
+                },
+            },
+        }).p;
+    }
+    expect: {
+        ({
+            __proto__: {
+                get p() {
+                    console.log("PASS");
+                },
+            },
+        }).p;
+    }
+    expect_stdout: "PASS"
+}

test/compress/reduce_vars.js

@@ -2460,6 +2460,7 @@ delay_def: {
         evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
+        side_effects: true,
         unused: true,
     }
     input: {
@@ -7630,3 +7631,114 @@ issue_4568: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4937: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            while (console.log("PASS"));
+        }
+        do {
+            function g() {
+                f();
+            }
+        } while (!g);
+        f();
+    }
+    expect: {
+        function f() {
+            while (console.log("PASS"));
+        }
+        do {
+            function g() {
+                f();
+            }
+        } while (!g);
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4943_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b = 1;
+        (function f() {
+            a = "foo";
+            b-- && f();
+            console.log(a);
+            a = "bar";
+        })();
+    }
+    expect: {
+        var a, b = 1;
+        (function f() {
+            a = "foo";
+            b-- && f();
+            console.log(a);
+            a = "bar";
+        })();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+issue_4943_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, b = 1;
+        (function f() {
+            a = "foo";
+            b-- && f();
+            console.log(a);
+            a = "bar";
+        })();
+    }
+    expect: {
+        var a, b = 1;
+        (function f() {
+            a = "foo";
+            b-- && f();
+            console.log(a);
+            a = "bar";
+        })();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+issue_4949: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            a = 0;
+            console.log(a++, arguments[0]);
+        })(0);
+    }
+    expect: {
+        (function(a) {
+            a = 0;
+            console.log(a++, arguments[0]);
+        })(0);
+    }
+    expect_stdout: "0 1"
+}

test/compress/rests.js

@@ -663,3 +663,124 @@ issue_4562: {
     expect_stdout: "f"
     node_version: ">=6"
 }
+
+issue_4575: {
+    options = {
+        collapse_vars: true,
+        ie8: true,
+        reduce_vars: true,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            var b = a;
+            var c = function a(...d) {
+                console.log(d.length);
+            }();
+        })();
+    }
+    expect: {
+        (function(a) {
+            (function a(...d) {
+                console.log(d.length);
+            })();
+        })();
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+issue_4621: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (function f(a, ...{
+            [console.log(a)]: b,
+        }) {})("PASS");
+    }
+    expect: {
+        (function f(a, ...{
+            [console.log(a)]: b,
+        }) {})("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4644_1: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function f(b, ...{
+            [a = "PASS"]: c,
+        }) {
+            return b;
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function f(b, ...{
+            [a = "PASS"]: c,
+        }) {
+            return b;
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4644_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(function(...a) {
+            return a[1];
+        }("FAIL", "PASS"), function(...b) {
+            return b.length;
+        }(), function(c, ...d) {
+            return d[0];
+        }("FAIL"));
+    }
+    expect: {
+        console.log("PASS", 0, function(c, ...d) {
+            return d[0];
+        }("FAIL"));
+    }
+    expect_stdout: "PASS 0 undefined"
+    node_version: ">=6"
+}
+
+issue_4666: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        rests: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = 0, b = 0;
+        var o = ((...c) => a++ + c)(b);
+        for (var k in o)
+            b++;
+        console.log(a, b);
+    }
+    expect: {
+        var a = 0, b = 0;
+        var o = (c => +a + c)([ b ]);
+        for(var k in o)
+            b++;
+        console.log(1, b);
+    }
+    expect_stdout: "1 2"
+    node_version: ">=6"
+}

test/compress/sandbox.js

@@ -13,6 +13,23 @@ console_log: {
     ]
 }
 
+console_log_console: {
+    input: {
+        var log = console.log;
+        log(console);
+        log(typeof console.log);
+    }
+    expect: {
+        var log = console.log;
+        log(console);
+        log(typeof console.log);
+    }
+    expect_stdout: [
+        "{ log: 'function(){}' }",
+        "function",
+    ]
+}
+
 typeof_arguments: {
     options = {
         evaluate: true,
@@ -81,6 +98,63 @@ log_global: {
     expect_stdout: "[object global]"
 }
 
+log_nested: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var o = { p: 42 };
+        for (var i = 0; i < 10; i++)
+            o = {
+                p: o,
+                q: function foo() {},
+            };
+        console.log(o);
+    }
+    expect: {
+        var o = { p: 42 };
+        for (var i = 0; i < 10; i++)
+            o = {
+                p: o,
+                q: function() {},
+            };
+        console.log(o);
+    }
+    expect_stdout: true
+}
+
+timers: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var count = 0, interval = 1000, duration = 3210;
+        var timer = setInterval(function() {
+            console.log(++count);
+        }, interval);
+        setTimeout(function() {
+            clearInterval(timer);
+        }, duration);
+    }
+    expect: {
+        var count = 0;
+        var timer = setInterval(function() {
+            console.log(++count);
+        }, 1000);
+        setTimeout(function() {
+            clearInterval(timer);
+        }, 3210);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "3",
+    ]
+    node_version: ">=0.12"
+}
+
 issue_4054: {
     input: {
         console.log({
@@ -98,3 +172,32 @@ issue_4054: {
     }
     expect_stdout: "{ p: [Setter] }"
 }
+
+issue_4811_1: {
+    input: {
+        for (var PASS in this);
+        console.log(PASS, this, {} < this);
+    }
+    expect: {
+        for (var PASS in this);
+        console.log(PASS, this, {} < this);
+    }
+    expect_stdout: "PASS [object global] true"
+}
+
+issue_4811_2: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (async function() {});
+        for (var PASS in this);
+        console.log(PASS, this, {} < this);
+    }
+    expect: {
+        for (var PASS in this);
+        console.log(PASS, this, {} < this);
+    }
+    expect_stdout: "PASS [object global] true"
+    node_version: ">=8"
+}

test/compress/sequences.js

@@ -564,6 +564,34 @@ delete_seq_3: {
 }
 
 delete_seq_4: {
+    options = {
+        booleans: true,
+        evaluate: false,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function f() {}
+        console.log(delete (f(), undefined));
+        console.log(delete (f(), void 0));
+        console.log(delete (f(), Infinity));
+        console.log(delete (f(), 1 / 0));
+        console.log(delete (f(), NaN));
+        console.log(delete (f(), 0 / 0));
+    }
+    expect: {
+        function f() {}
+        console.log(delete void f()),
+        console.log(delete void f()),
+        console.log((f(), delete (1 / 0))),
+        console.log((f(), delete (1 / 0))),
+        console.log(delete (f(), NaN)),
+        console.log((f(), delete(0 / 0)));
+    }
+    expect_stdout: true
+}
+
+delete_seq_4_evaluate: {
     options = {
         booleans: true,
         evaluate: true,
@@ -592,6 +620,35 @@ delete_seq_4: {
 }
 
 delete_seq_5: {
+    options = {
+        booleans: true,
+        evaluate: false,
+        keep_infinity: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function f() {}
+        console.log(delete (f(), undefined));
+        console.log(delete (f(), void 0));
+        console.log(delete (f(), Infinity));
+        console.log(delete (f(), 1 / 0));
+        console.log(delete (f(), NaN));
+        console.log(delete (f(), 0 / 0));
+    }
+    expect: {
+        function f() {}
+        console.log(delete void f()),
+        console.log(delete void f()),
+        console.log(delete (f(), Infinity)),
+        console.log((f(), delete (1 / 0))),
+        console.log(delete (f(), NaN)),
+        console.log((f(), delete (0 / 0)));
+    }
+    expect_stdout: true
+}
+
+delete_seq_5_evaluate: {
     options = {
         booleans: true,
         evaluate: true,
@@ -663,12 +720,21 @@ side_effects_cascade_1: {
             if (a < 0) a = 0;
             b.a = a;
         }
+        var m = {}, n = {};
+        f(13, m);
+        f("foo", n);
+        console.log(m.a, n.a);
     }
     expect: {
         function f(a, b) {
-            (a -= 42) < 0 && (a = 0), b.a = a;
+            b.a = a = (a -= 42) < 0 ? 0 : a;
         }
+        var m = {}, n = {};
+        f(13, m),
+        f("foo", n),
+        console.log(m.a, n.a);
     }
+    expect_stdout: "0 NaN"
 }
 
 side_effects_cascade_2: {

test/compress/side_effects.js

@@ -198,6 +198,36 @@ global_fns: {
     ]
 }
 
+global_constructors: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        Map;
+        new Map(console.log("foo"));
+        Set;
+        new Set(console.log("bar"));
+        WeakMap;
+        new WeakMap(console.log("baz"));
+        WeakSet;
+        new WeakSet(console.log("moo"));
+    }
+    expect: {
+        console.log("foo");
+        console.log("bar");
+        console.log("baz");
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+        "moo",
+    ]
+    node_version: ">=0.12"
+}
+
 unsafe_builtin_1: {
     options = {
         side_effects: true,
@@ -348,8 +378,6 @@ issue_3983_1: {
     }
     expect: {
         var a = "PASS";
-        g();
-        function g() {}
         console.log(a);
     }
     expect_stdout: "PASS"
@@ -458,14 +486,14 @@ issue_4325: {
     }
     expect: {
         (function() {
-            (function() {
+            (function(c) {
                 try {
-                    (void 0).p = 0;
+                    c.p = 0;
                 } catch (e) {
                     console.log("PASS");
                     return;
                 }
-            })();
+            })(void 0);
         })();
     }
     expect_stdout: "PASS"
@@ -506,3 +534,114 @@ issue_4366_2: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_4668: {
+    options = {
+        conditionals: true,
+        keep_fargs: false,
+        keep_fnames: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b, c;
+            function g() {
+                return a = 0 + a, !d || (a = 0);
+            }
+            c = g();
+        }
+        console.log(f());
+        var d = 0;
+    }
+    expect: {
+        console.log(function f() {
+            (function g() {
+                0;
+            })();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+drop_side_effect_free_call: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        function f(a) {
+            return "PA" + a;
+        }
+        f(42);
+        console.log(f("SS"));
+    }
+    expect: {
+        function f(a) {
+            return "PA" + a;
+        }
+        console.log(f("SS"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4730_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var a;
+        console.log("PASS") + (a && a[a.p]);
+    }
+    expect: {
+        var a;
+        console.log("PASS"),
+        a && a[a.p];
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4730_2: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var a;
+        !console.log("PASS") || a && a[a.p];
+    }
+    expect: {
+        var a;
+        !console.log("PASS") || a && a[a.p];
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4751: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            },
+        };
+        o && o.p;
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            },
+        };
+        o && o.p;
+    }
+    expect_stdout: "PASS"
+}

test/compress/spreads.js

@@ -85,7 +85,7 @@ collapse_vars_4: {
     node_version: ">=6"
 }
 
-conditionals_farg: {
+conditionals_farg_1: {
     options = {
         conditionals: true,
     }
@@ -107,6 +107,28 @@ conditionals_farg: {
     node_version: ">=6"
 }
 
+conditionals_farg_2: {
+    options = {
+        conditionals: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+    }
+    input: {
+        var log = console.log;
+        (function(a) {
+            return a.length ? log(...a) : log("FAIL");
+        })([ "PASS" ]);
+    }
+    expect: {
+        var log = console.log;
+        (function(a) {
+            return a.length ? log(...a) : log("FAIL");
+        })([ "PASS" ]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 dont_inline: {
     options = {
         inline: true,
@@ -272,6 +294,31 @@ reduce_vars_2: {
     node_version: ">=6"
 }
 
+reduce_vars_3: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        function g() {
+            return (a => a)(...[ f ]);
+        }
+        console.log(g() === g() ? "PASS" : "FAIL");
+    }
+    expect: {
+        function f() {}
+        function g() {
+            return (a => a)(...[ f ]);
+        }
+        console.log(g() === g() ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 convert_setter: {
     options = {
         objects: true,
@@ -667,6 +714,57 @@ unused_var_side_effects: {
     node_version: ">=8"
 }
 
+unsafe_join_1: {
+    options = {
+        unsafe: true,
+    }
+    input: {
+        console.log([ ..."foo" ].join());
+    }
+    expect: {
+        console.log([ ..."foo" ].join());
+    }
+    expect_stdout: "f,o,o"
+    node_version: ">=6"
+}
+
+unsafe_join_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log([ "foo", ..."bar" ].join(""));
+    }
+    expect: {
+        console.log([ "foo", ..."bar" ].join(""));
+    }
+    expect_stdout: "foobar"
+    node_version: ">=6"
+}
+
+unsafe_join_3: {
+    options = {
+        unsafe: true,
+    }
+    input: {
+        try {
+            [].join(...console);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            [].join(...console);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 issue_4329: {
     options = {
         objects: true,
@@ -918,3 +1016,143 @@ issue_4560_3: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_4614: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function(...[]) {
+                var arguments;
+                arguments[0];
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function(...[]) {
+                var arguments;
+                arguments[0];
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_4849: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        while (function() {
+            while (!console);
+        }(new function(a) {
+            console.log(typeof { ...a });
+        }(function() {})));
+    }
+    expect: {
+        while (function() {
+            while (!console);
+        }(function(a) {
+            console.log(typeof { ...function() {} });
+        }()));
+    }
+    expect_stdout: "object"
+    node_version: ">=8"
+}
+
+issue_4882_1: {
+    options = {
+        objects: true,
+        spreads: true,
+    }
+    input: {
+        var o = {
+            p: "PASS",
+            ... {
+                __proto__: {
+                    p: "FAIL 1",
+                    q: "FAIL 2",
+                },
+            },
+        };
+        console.log(o.p);
+        console.log(o.q);
+    }
+    expect: {
+        var o = {
+            p: "PASS",
+        };
+        console.log(o.p);
+        console.log(o.q);
+    }
+    expect_stdout: [
+        "PASS",
+        "undefined",
+    ]
+    node_version: ">=8"
+}
+
+issue_4882_2: {
+    options = {
+        objects: true,
+        spreads: true,
+    }
+    input: {
+        console.log(null == Object.getPrototypeOf({
+            ... {
+                __proto__: (console.log(42), null),
+            },
+        }) ? "FAIL" : "PASS");
+    }
+    expect: {
+        console.log(null == Object.getPrototypeOf({
+            ... {
+                __proto__: (console.log(42), null),
+            },
+        }) ? "FAIL" : "PASS");
+    }
+    expect_stdout: [
+        "42",
+        "PASS",
+    ]
+    node_version: ">=8"
+}
+
+issue_4882_3: {
+    options = {
+        objects: true,
+        spreads: true,
+    }
+    input: {
+        var o = {
+            __proto__: { p: 42 },
+            ... {
+                set __proto__(v) {},
+            },
+        };
+        console.log(o.__proto__ === Object.getPrototypeOf(o) ? "FAIL" : "PASS");
+        console.log(o.p);
+    }
+    expect: {
+        var o = {
+            __proto__: { p: 42 },
+            ["__proto__"]: void 0,
+        };
+        console.log(o.__proto__ === Object.getPrototypeOf(o) ? "FAIL" : "PASS");
+        console.log(o.p);
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=8"
+}

test/compress/templates.js

@@ -0,0 +1,436 @@
+simple: {
+    input: {
+        console.log(`foo
+        bar\nbaz`);
+    }
+    expect_exact: "console.log(`foo\n        bar\\nbaz`);"
+    expect_stdout: [
+        "foo",
+        "        bar",
+        "baz",
+    ]
+    node_version: ">=4"
+}
+
+placeholder: {
+    input: {
+        console.log(`foo ${ function(a, b) {
+            return a * b;
+        }(6, 7) }`);
+    }
+    expect_exact: "console.log(`foo ${function(a,b){return a*b}(6,7)}`);"
+    expect_stdout: "foo 42"
+    node_version: ">=4"
+}
+
+nested: {
+    input: {
+        console.log(`P${`A${"S"}`}S`);
+    }
+    expect_exact: 'console.log(`P${`A${"S"}`}S`);'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tagged: {
+    input: {
+        console.log(String.raw`foo\nbar`);
+    }
+    expect_exact: "console.log(String.raw`foo\\nbar`);"
+    expect_stdout: "foo\\nbar"
+    node_version: ">=4"
+}
+
+tagged_chain: {
+    input: {
+        function f(strings) {
+            return strings.join("") || f;
+        }
+        console.log(f```${42}``pass`.toUpperCase());
+    }
+    expect_exact: 'function f(strings){return strings.join("")||f}console.log(f```${42}``pass`.toUpperCase());'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tag_parentheses_arrow: {
+    input: {
+        console.log((s => s.raw[0])`\tPASS`.slice(2));
+    }
+    expect_exact: "console.log((s=>s.raw[0])`\\tPASS`.slice(2));"
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tag_parentheses_binary: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var f = function() {
+            console.log("PASS");
+        } || console
+        f``;
+    }
+    expect_exact: '(function(){console.log("PASS")}||console)``;'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tag_parentheses_new: {
+    input: {
+        (new function() {
+            return console.log;
+        })`foo`;
+    }
+    expect_exact: "(new function(){return console.log})`foo`;"
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+tag_parentheses_sequence: {
+    input: {
+        var o = {
+            f() {
+                console.log(this === o ? "FAIL" : "PASS");
+            },
+        };
+        (42, o.f)``;
+    }
+    expect_exact: 'var o={f(){console.log(this===o?"FAIL":"PASS")}};(42,o.f)``;'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tag_parentheses_unary: {
+    input: {
+        var a;
+        try {
+            (~a)``;
+            (a++)``;
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_exact: 'var a;try{(~a)``;(a++)``}catch(e){console.log("PASS")}'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+malformed_escape: {
+    input: {
+        (function(s) {
+            s.forEach((c, i) => console.log(i, c, s.raw[i]));
+            return () => console.log(arguments);
+        })`\uFo${42}`();
+    }
+    expect_exact: "(function(s){s.forEach((c,i)=>console.log(i,c,s.raw[i]));return()=>console.log(arguments)})`\\uFo${42}`();"
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        templates: false,
+    }
+    input: {
+        console.log(`foo ${ function(a, b) {
+            return a * b;
+        }(6, 7) }`);
+    }
+    expect: {
+        console.log(`foo ${42}`);
+    }
+    expect_stdout: "foo 42"
+    node_version: ">=4"
+}
+
+evaluate_templates: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`foo ${ function(a, b) {
+            return a * b;
+        }(6, 7) }`);
+    }
+    expect: {
+        console.log("foo 42");
+    }
+    expect_stdout: "foo 42"
+    node_version: ">=4"
+}
+
+partial_evaluate: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${6 * 7} foo ${console ? `PA` + "SS" : `FA` + `IL`}`);
+    }
+    expect: {
+        console.log(`42 foo ${console ? "PASS" : "FAIL"}`);
+    }
+    expect_stdout: "42 foo PASS"
+    node_version: ">=4"
+}
+
+malformed_evaluate_1: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\67 ${6 * 7}`);
+    }
+    expect: {
+        console.log(`\67 42`);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_evaluate_2: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\u0${0}b${5}`);
+    }
+    expect: {
+        console.log(`\u0${0}b5`);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_evaluate_3: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\u${0}b${5}`);
+    }
+    expect: {
+        console.log(`\u0b5`);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_evaluate_4: {
+    options = {
+        evaluate: true,
+        templates: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(String.raw`\u0${0}b${5}`);
+    }
+    expect: {
+        console.log("\\u00b5");
+    }
+    expect_stdout: "\\u00b5"
+    node_version: ">=8"
+}
+
+unsafe_evaluate: {
+    options = {
+        evaluate: true,
+        templates: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(String.raw`\uFo`);
+    }
+    expect: {
+        console.log("\\uFo");
+    }
+    expect_stdout: "\\uFo"
+    node_version: ">=8"
+}
+
+side_effects_1: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        `42`;
+        `${console.log("foo")}`;
+        console.log`\nbar`;
+    }
+    expect: {
+        console.log("foo");
+        console.log`\nbar`;
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+side_effects_2: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            f() {
+                console.log(this === o ? "FAIL" : "PASS");
+            },
+        };
+        (42, o.f)``;
+    }
+    expect: {
+        var o = {
+            f() {
+                console.log(this === o ? "FAIL" : "PASS");
+            },
+        };
+        (0, o.f)``;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+unsafe_side_effects: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        `42`;
+        `${console.log("foo")}`;
+        String.raw`\nbar`;
+    }
+    expect: {
+        console.log("foo");
+    }
+    expect_stdout: "foo"
+    node_version: ">=4"
+}
+
+pure_funcs: {
+    options = {
+        pure_funcs: "Math.random",
+        side_effects: true,
+    }
+    input: {
+        Math.random`${console.log("PASS")}`;
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4604: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 0, log = console.log;
+        a = "FAIL";
+        (function() {
+            a = "PASS";
+        })``;
+        log(a);
+    }
+    expect: {
+        var a = 0, log = console.log;
+        a = "FAIL";
+        (function() {
+            a = "PASS";
+        })``;
+        log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4606: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${typeof A} ${"\r"} ${"\\"} ${"`"}`);
+    }
+    expect: {
+        console.log(`${typeof A} \r \\ \``);
+    }
+    expect_stdout: "undefined \r \\ `"
+    node_version: ">=4"
+}
+
+issue_4630: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${/PASS/}`);
+    }
+    expect: {
+        console.log("/PASS/");
+    }
+    expect_stdout: "/PASS/"
+    node_version: ">=4"
+}
+
+issue_4676: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        templates: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b = `foo${a = "PASS"}`;
+            for (var c in f && b)
+                b.p;
+            return a;
+        }
+        console.log(f("FAIL"));
+    }
+    expect: {
+        console.log(function f(a) {
+            var b = "fooPASS";
+            for (var c in f, b)
+                b.p;
+            return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4931: {
+    options = {
+        evaluate: true,
+        templates: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(String.raw`${typeof A} ${"\r"}`);
+        console.log(String.raw`${"\\"} ${"`"}`);
+    }
+    expect: {
+        console.log(String.raw`${typeof A} ${"\r"}`);
+        console.log("\\ `");
+    }
+    expect_stdout: [
+        "undefined \r",
+        "\\ `",
+    ]
+    node_version: ">=4"
+}

test/compress/unicode.js

@@ -50,7 +50,7 @@ unicode_parse_variables: {
     }
 }
 
-unicode_escaped_identifier: {
+unicode_escaped_identifier_1: {
     input: {
         var \u0061 = "\ud800\udc00";
         console.log(a);
@@ -59,6 +59,17 @@ unicode_escaped_identifier: {
     expect_stdout: "\ud800\udc00"
 }
 
+unicode_escaped_identifier_2: {
+    input: {
+        var \u{61} = "foo";
+        var \u{10000} = "bar";
+        console.log(a, \u{10000});
+    }
+    expect_exact: 'var a="foo";var \u{10000}="bar";console.log(a,\u{10000});'
+    expect_stdout: "foo bar"
+    node_version: ">=4"
+}
+
 unicode_identifier_ascii_only: {
     beautify = {
         ascii_only: true,

test/compress/varify.js

@@ -354,6 +354,92 @@ forin_let_2: {
     node_version: ">=6"
 }
 
+loop_scope_1: {
+    options = {
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        var o = { foo: 1, bar: 2 };
+        for (let i in o) {
+            console.log(i);
+        }
+        for (const j in o)
+            setTimeout(() => console.log(j), 0);
+        for (let k in o)
+            setTimeout(function() {
+                console.log(k);
+            }, 0);
+    }
+    expect: {
+        "use strict";
+        var o = { foo: 1, bar: 2 };
+        for (var i in o)
+            console.log(i);
+        for (const j in o)
+            setTimeout(() => console.log(j), 0);
+        for (let k in o)
+            setTimeout(function() {
+                console.log(k);
+            }, 0);
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "foo",
+        "bar",
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+loop_scope_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        var a = [ "foo", "bar" ];
+        for (var i = 0; i < a.length; i++) {
+            const x = a[i];
+            console.log(x);
+            let y = a[i];
+            setTimeout(() => console.log(y), 0);
+            const z = a[i];
+            setTimeout(function() {
+                console.log(z);
+            }, 0);
+        }
+    }
+    expect: {
+        "use strict";
+        var a = [ "foo", "bar" ];
+        for (var i = 0; i < a.length; i++) {
+            var x = a[i];
+            console.log(x);
+            let y = a[i];
+            setTimeout(() => console.log(y), 0);
+            const z = a[i];
+            setTimeout(function() {
+                console.log(z);
+            }, 0);
+        }
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "foo",
+        "foo",
+        "bar",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
 issue_4290_1_const: {
     options = {
         reduce_vars: true,
@@ -409,3 +495,121 @@ drop_forin_let: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+default_init: {
+    options = {
+        join_vars: true,
+        reduce_vars: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        A = "PASS";
+        (function() {
+            "use strict";
+            let a;
+            a = A;
+            console.log(a);
+        })();
+    }
+    expect: {
+        A = "PASS";
+        (function() {
+            "use strict";
+            var a = A;
+            console.log(a);
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4933_1: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        console.log(f());
+        function f() {
+            var a;
+            for (console in a = [ f ]) {
+                const b = a;
+            }
+        }
+    }
+    expect: {
+        console.log(function f() {
+            var a;
+            for (console in a = [ f ]) {
+                const b = a;
+            }
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4933_2: {
+    options = {
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        console.log(f());
+        function f() {
+            var a;
+            for (console in a = [ f ]) {
+                const b = a;
+            }
+        }
+    }
+    expect: {
+        console.log(function f() {
+            for (console in [ f ]);
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4954: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        (function() {
+            {
+                let a = console;
+                console.log(typeof a);
+            }
+            {
+                let a = function() {};
+                a && console.log(typeof a);
+            }
+        })();
+    }
+    expect: {
+        "use strict";
+        (function() {
+            var a = console;
+            console.log(typeof a);
+            {
+                let a = function() {};
+                a && console.log(typeof a);
+            }
+        })();
+    }
+    expect_stdout: [
+        "object",
+        "function",
+    ]
+    node_version: ">=4"
+}

test/exports.js

@@ -1,5 +1,6 @@
 exports["Compressor"] = Compressor;
 exports["defaults"] = defaults;
+exports["is_statement"] = is_statement;
 exports["JS_Parse_Error"] = JS_Parse_Error;
 exports["List"] = List;
 exports["mangle_properties"] = mangle_properties;

test/input/invalid/assign_4.js

@@ -1 +1 @@
-++null
+console.log(4 || (null = 4));

test/input/invalid/assign_5.js

@@ -0,0 +1 @@
+console.log(5 || ([]?.length ^= 5));

test/input/invalid/for-await.js

@@ -0,0 +1 @@
+for await (; console.log(42););

test/input/invalid/for-of_1.js

@@ -0,0 +1,3 @@
+var a = [ 1 ], b;
+for (b = 2 of a)
+    console.log(b);

test/input/invalid/for-of_2.js

@@ -0,0 +1,3 @@
+var a = [ 1 ];
+for (var b = 2 of a)
+    console.log(b);

test/input/issue-3040/input.js.map

@@ -1,11 +1,11 @@
-{
-    "version": 3,
-    "sources": [
-        "input.js"
-    ],
-    "names": [],
-    "mappings": ";;;;;;;;;;;;;;eAAc,OAAO,CAAC,KAAD,C;IAAd,G,YAAA,G;;gBACS,OAAO,CAAC,OAAD,C;IAAhB,K,aAAA,K;;AAEP,GAAG,CAAC,CAAJ,OAAA,GAAG,qBAAM,GAAG,CAAC,CAAJ,CAAM,KAAK,CAAC,CAAZ,CAAN,EAAH",
-    "sourcesContent": [
-        "const {foo} = require(\"bar\");\nconst {hello} = require(\"world\");\n\nfoo.x(...foo.y(hello.z));\n"
-    ]
-}
+{
+    "version": 3,
+    "sources": [
+        "input.js"
+    ],
+    "names": [],
+    "mappings": ";;;;;;;;;;;;;;eAAc,OAAO,CAAC,KAAD,C;IAAd,G,YAAA,G;;gBACS,OAAO,CAAC,OAAD,C;IAAhB,K,aAAA,K;;AAEP,GAAG,CAAC,CAAJ,OAAA,GAAG,qBAAM,GAAG,CAAC,CAAJ,CAAM,KAAK,CAAC,CAAZ,CAAN,EAAH",
+    "sourcesContent": [
+        "const {foo} = require(\"bar\");\nconst {hello} = require(\"world\");\n\nfoo.x(...foo.y(hello.z));\n"
+    ]
+}

test/input/issue-3315/config.json

@@ -1,8 +1,8 @@
-{
-    "compress": false,
-    "mangle": {
-        "properties": {
-            "regex": "/^_/"
-        }
-    }
-}
+{
+    "compress": false,
+    "mangle": {
+        "properties": {
+            "regex": "/^_/"
+        }
+    }
+}

test/jetstream.js

@@ -58,22 +58,29 @@ if (typeof phantom == "undefined") {
     }).listen();
     server.on("listening", function() {
         var port = server.address().port;
-        if (debug) {
-            console.log("http://localhost:" + port + "/");
-        } else (function install() {
-            child_process.spawn(process.platform == "win32" ? "npm.cmd" : "npm", [
+        if (debug) return console.log("http://localhost:" + port + "/");
+        var cmd = process.platform == "win32" ? "npm.cmd" : "npm";
+
+        function npm(args, done) {
+            child_process.spawn(cmd, args, { stdio: [ "ignore", 1, 2 ] }).on("exit", done);
+        }
+
+        (function install() {
+            npm([
                 "install",
                 "phantomjs-prebuilt@2.1.14",
                 "--no-audit",
                 "--no-optional",
                 "--no-save",
                 "--no-update-notifier",
-            ], {
-                stdio: [ "ignore", 1, 2 ]
-            }).on("exit", function(code) {
+            ], function(code) {
                 if (code) {
                     console.log("npm install failed with code", code);
-                    return install();
+                    return npm([
+                        "cache",
+                        "clean",
+                        "--force",
+                    ], install);
                 }
                 var program = require("phantomjs-prebuilt").exec(process.argv[1], port);
                 program.stdout.pipe(process.stdout);

test/mocha/cli.js

@@ -29,7 +29,7 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + ' test/input/comments/filter.js --comments all';
         exec(command, function(err, stdout) {
             if (err) throw err;
-            assert.strictEqual(stdout, "// foo\n/*@preserve*/\n// bar\n\n");
+            assert.strictEqual(stdout, "// foo\n/*@preserve*/\n// bar\n");
             done();
         });
     });
@@ -37,7 +37,7 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + ' test/input/comments/filter.js --comments /r/';
         exec(command, function(err, stdout) {
             if (err) throw err;
-            assert.strictEqual(stdout, "/*@preserve*/\n// bar\n\n");
+            assert.strictEqual(stdout, "/*@preserve*/\n// bar\n");
             done();
         });
     });
@@ -45,7 +45,7 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + ' test/input/comments/filter.js --comments';
         exec(command, function(err, stdout) {
             if (err) throw err;
-            assert.strictEqual(stdout, "/*@preserve*/\n\n");
+            assert.strictEqual(stdout, "/*@preserve*/\n");
             done();
         });
     });
@@ -56,7 +56,7 @@ describe("bin/uglifyjs", function() {
             "--source-map", [
                 "names=true",
                 "url=inline",
-            ].join(","),
+            ].join(),
         ].join(" "), function(err, stdout) {
             if (err) throw err;
             var expected = [
@@ -84,7 +84,7 @@ describe("bin/uglifyjs", function() {
             "--source-map", [
                 "names=false",
                 "url=inline",
-            ].join(","),
+            ].join(),
         ].join(" "), function(err, stdout) {
             if (err) throw err;
             var expected = [
@@ -171,7 +171,7 @@ describe("bin/uglifyjs", function() {
                 "content=" + mapFile,
                 "includeSources",
                 "url=inline",
-            ].join(","),
+            ].join(),
         ].join(" ");
 
         var child = exec(command, function(err, stdout) {
@@ -333,11 +333,13 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + " test/input/invalid/simple.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/simple.js:1,12");
-            assert.strictEqual(lines[1], "function f(a{}");
-            assert.strictEqual(lines[2], "            ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: punc «{», expected: punc «,»");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/simple.js:1,12",
+                "function f(a{}",
+                "            ^",
+                "ERROR: Unexpected token: punc «{», expected: punc «,»",
+            ].join("\n"));
             done();
         });
     });
@@ -345,11 +347,13 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + " test/input/invalid/tab.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/tab.js:1,12");
-            assert.strictEqual(lines[1], "\t\tfoo(\txyz, 0abc);");
-            assert.strictEqual(lines[2], "\t\t    \t     ^");
-            assert.strictEqual(lines[3], "ERROR: Invalid syntax: 0abc");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/tab.js:1,12",
+                "\t\tfoo(\txyz, 0abc);",
+                "\t\t    \t     ^",
+                "ERROR: Invalid syntax: 0abc",
+            ].join("\n"));
             done();
         });
     });
@@ -357,11 +361,13 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + " test/input/invalid/eof.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/eof.js:2,0");
-            assert.strictEqual(lines[1], "foo, bar(");
-            assert.strictEqual(lines[2], "         ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: eof");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/eof.js:2,0",
+                "foo, bar(",
+                "         ^",
+                "ERROR: Unexpected token: eof",
+            ].join("\n"));
             done();
         });
     });
@@ -369,11 +375,13 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + " test/input/invalid/loop-no-body.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/loop-no-body.js:2,0");
-            assert.strictEqual(lines[1], "for (var i = 0; i < 1; i++) ");
-            assert.strictEqual(lines[2], "                            ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: eof");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/loop-no-body.js:2,0",
+                "for (var i = 0; i < 1; i++) ",
+                "                            ^",
+                "ERROR: Unexpected token: eof",
+            ].join("\n"));
             done();
         });
     });
@@ -386,7 +394,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_1.js:1,18",
                 "console.log(1 || 5--);",
                 "                  ^",
-                "ERROR: Invalid use of -- operator"
+                "ERROR: Invalid use of -- operator",
             ].join("\n"));
             done();
         });
@@ -400,7 +408,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_2.js:1,32",
                 "console.log(2 || (Math.random() /= 2));",
                 "                                ^",
-                "ERROR: Invalid assignment"
+                "ERROR: Invalid assignment",
             ].join("\n"));
             done();
         });
@@ -414,21 +422,35 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_3.js:1,17",
                 "console.log(3 || ++this);",
                 "                 ^",
-                "ERROR: Invalid use of ++ operator"
+                "ERROR: Invalid use of ++ operator",
             ].join("\n"));
             done();
         });
     });
-    it("Should throw syntax error (++null)", function(done) {
+    it("Should throw syntax error (null = 4)", function(done) {
         var command = uglifyjscmd + " test/input/invalid/assign_4.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
             assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/assign_4.js:1,0",
-                "++null",
-                "^",
-                "ERROR: Invalid use of ++ operator"
+                "Parse error at test/input/invalid/assign_4.js:1,23",
+                "console.log(4 || (null = 4));",
+                "                       ^",
+                "ERROR: Invalid assignment",
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error ([]?.length ^= 5)", function(done) {
+        var command = uglifyjscmd + " test/input/invalid/assign_5.js";
+        exec(command, function(err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_5.js:1,29",
+                "console.log(5 || ([]?.length ^= 5));",
+                "                             ^",
+                "ERROR: Invalid assignment",
             ].join("\n"));
             done();
         });
@@ -442,7 +464,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/dot_1.js:1,2",
                 "a.=",
                 "  ^",
-                "ERROR: Unexpected token: operator «=», expected: name"
+                "ERROR: Unexpected token: operator «=», expected: name",
             ].join("\n"));
             done();
         });
@@ -456,7 +478,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/dot_2.js:1,0",
                 "%.a;",
                 "^",
-                "ERROR: Unexpected token: operator «%»"
+                "ERROR: Unexpected token: operator «%»",
             ].join("\n"));
             done();
         });
@@ -470,7 +492,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/dot_3.js:1,2",
                 "a./();",
                 "  ^",
-                "ERROR: Unexpected token: operator «/», expected: name"
+                "ERROR: Unexpected token: operator «/», expected: name",
             ].join("\n"));
             done();
         });
@@ -484,7 +506,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/object.js:1,13",
                 "console.log({%: 1});",
                 "             ^",
-                "ERROR: Unexpected token: operator «%»"
+                "ERROR: Unexpected token: operator «%»",
             ].join("\n"));
             done();
         });
@@ -498,7 +520,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/delete.js:13,11",
                 "    delete x;",
                 "           ^",
-                "ERROR: Calling delete on expression not allowed in strict mode"
+                "ERROR: Calling delete on expression not allowed in strict mode",
             ].join("\n"));
             done();
         });
@@ -512,7 +534,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/function_1.js:4,11",
                 "function g(arguments) {",
                 "           ^",
-                "ERROR: Unexpected arguments in strict mode"
+                "ERROR: Unexpected arguments in strict mode",
             ].join("\n"));
             done();
         });
@@ -526,7 +548,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/function_2.js:4,9",
                 "function eval() {",
                 "         ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
@@ -540,7 +562,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/function_3.js:4,10",
                 "!function arguments() {",
                 "          ^",
-                "ERROR: Unexpected arguments in strict mode"
+                "ERROR: Unexpected arguments in strict mode",
             ].join("\n"));
             done();
         });
@@ -554,7 +576,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/try.js:7,18",
                 "    try {} catch (eval) {}",
                 "                  ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
@@ -568,7 +590,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/var.js:7,8",
                 "    var eval;",
                 "        ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
@@ -582,7 +604,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/destructured_var.js:7,10",
                 "    var { eval } = 42;",
                 "          ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
@@ -596,7 +618,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/else.js:1,7",
                 "if (0) else 1;",
                 "       ^",
-                "ERROR: Unexpected token: keyword «else»"
+                "ERROR: Unexpected token: keyword «else»",
             ].join("\n"));
             done();
         });
@@ -610,7 +632,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/return.js:1,0",
                 "return 42;",
                 "^",
-                "ERROR: 'return' outside of function"
+                "ERROR: 'return' outside of function",
             ].join("\n"));
             done();
         });
@@ -624,7 +646,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/for-in_1.js:2,5",
                 "for (1, 2, a in b) {",
                 "     ^",
-                "ERROR: Invalid left-hand side in for..in loop"
+                "ERROR: Invalid left-hand side in for..in/of loop",
             ].join("\n"));
             done();
         });
@@ -638,7 +660,49 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/for-in_2.js:2,5",
                 "for (var a, b in c) {",
                 "     ^",
-                "ERROR: Only one variable declaration allowed in for..in loop"
+                "ERROR: Only one variable declaration allowed in for..in/of loop",
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-of init)", function(done) {
+        var command = uglifyjscmd + " test/input/invalid/for-of_1.js";
+        exec(command, function(err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-of_1.js:2,5",
+                "for (b = 2 of a)",
+                "     ^",
+                "ERROR: Invalid left-hand side in for..in/of loop",
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-of var)", function(done) {
+        var command = uglifyjscmd + " test/input/invalid/for-of_2.js";
+        exec(command, function(err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-of_2.js:2,13",
+                "for (var b = 2 of a)",
+                "             ^",
+                "ERROR: No initializers allowed in for..of loop",
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-await)", function(done) {
+        var command = uglifyjscmd + " test/input/invalid/for-await.js";
+        exec(command, function(err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-await.js:1,11",
+                "for await (; console.log(42););",
+                "           ^",
+                "ERROR: Unexpected token: punc «;»",
             ].join("\n"));
             done();
         });
@@ -647,11 +711,13 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + " test/input/invalid/switch.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/switch.js:3,2");
-            assert.strictEqual(lines[1], "  default:");
-            assert.strictEqual(lines[2], "  ^");
-            assert.strictEqual(lines[3], "ERROR: More than one default clause in switch statement");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/switch.js:3,2",
+                "  default:",
+                "  ^",
+                "ERROR: More than one default clause in switch statement",
+            ].join("\n"));
             done();
         });
     });

test/mocha/comments.js

@@ -259,7 +259,7 @@ describe("comments", function() {
         assert.strictEqual(result.code, code);
     });
 
-    it("Should handle comments around parenthesis correctly", function() {
+    it("Should handle comments around parentheses correctly", function() {
         var code = [
             "a();",
             "/* foo */",
@@ -392,12 +392,12 @@ describe("comments", function() {
     describe("comment filters", function() {
         it("Should be able to filter comments by passing regexp", function() {
             var ast = UglifyJS.parse("/*!test1*/\n/*test2*/\n//!test3\n//test4\n<!--test5\n<!--!test6\n-->test7\n-->!test8");
-            assert.strictEqual(ast.print_to_string({comments: /^!/}), "/*!test1*/\n//!test3\n//!test6\n//!test8\n");
+            assert.strictEqual(ast.print_to_string({comments: /^!/}), "/*!test1*/\n//!test3\n//!test6\n//!test8");
         });
 
         it("Should be able to filter comments with the 'all' option", function() {
             var ast = UglifyJS.parse("/*!test1*/\n/*test2*/\n//!test3\n//test4\n<!--test5\n<!--!test6\n-->test7\n-->!test8");
-            assert.strictEqual(ast.print_to_string({comments: "all"}), "/*!test1*/\n/*test2*/\n//!test3\n//test4\n//test5\n//!test6\n//test7\n//!test8\n");
+            assert.strictEqual(ast.print_to_string({comments: "all"}), "/*!test1*/\n/*test2*/\n//!test3\n//test4\n//test5\n//!test6\n//test7\n//!test8");
         });
 
         it("Should be able to filter commments with the 'some' option", function() {
@@ -410,13 +410,12 @@ describe("comments", function() {
             var f = function(node, comment) {
                 return comment.value.length === 8;
             };
-
-            assert.strictEqual(ast.print_to_string({comments: f}), "/*TEST 123*/\n//8 chars.\n");
+            assert.strictEqual(ast.print_to_string({comments: f}), "/*TEST 123*/\n//8 chars.");
         });
 
         it("Should be able to filter comments by passing regex in string format", function() {
             var ast = UglifyJS.parse("/*!test1*/\n/*test2*/\n//!test3\n//test4\n<!--test5\n<!--!test6\n-->test7\n-->!test8");
-            assert.strictEqual(ast.print_to_string({comments: "/^!/"}), "/*!test1*/\n//!test3\n//!test6\n//!test8\n");
+            assert.strictEqual(ast.print_to_string({comments: "/^!/"}), "/*!test1*/\n//!test3\n//!test6\n//!test8");
         });
 
         it("Should be able to get the comment and comment type when using a function", function() {
@@ -424,14 +423,12 @@ describe("comments", function() {
             var f = function(node, comment) {
                 return comment.type == "comment1" || comment.type == "comment3";
             };
-
-            assert.strictEqual(ast.print_to_string({comments: f}), "//!test3\n//test4\n//test5\n//!test6\n");
+            assert.strictEqual(ast.print_to_string({comments: f}), "//!test3\n//test4\n//test5\n//!test6");
         });
 
         it("Should be able to filter comments by passing a boolean", function() {
             var ast = UglifyJS.parse("/*!test1*/\n/*test2*/\n//!test3\n//test4\n<!--test5\n<!--!test6\n-->test7\n-->!test8");
-
-            assert.strictEqual(ast.print_to_string({comments: true}), "/*!test1*/\n/*test2*/\n//!test3\n//test4\n//test5\n//!test6\n//test7\n//!test8\n");
+            assert.strictEqual(ast.print_to_string({comments: true}), "/*!test1*/\n/*test2*/\n//!test3\n//test4\n//test5\n//!test6\n//test7\n//!test8");
             assert.strictEqual(ast.print_to_string({comments: false}), "");
         });
 
@@ -439,10 +436,8 @@ describe("comments", function() {
             var ast = UglifyJS.parse("#!Random comment\n//test1\n/*test2*/");
             var f = function(node, comment) {
                 assert.strictEqual(comment.type === "comment5", false);
-
                 return true;
             };
-
             assert.strictEqual(ast.print_to_string({comments: f}), "#!Random comment\n//test1\n/*test2*/");
         });
 
@@ -453,9 +448,8 @@ describe("comments", function() {
 
         it("Should have no problem on multiple calls", function() {
             const options = {
-                comments: /ok/
+                comments: /ok/,
             };
-
             assert.strictEqual(UglifyJS.parse("/* ok */ function a(){}").print_to_string(options), "/* ok */function a(){}");
             assert.strictEqual(UglifyJS.parse("/* ok */ function a(){}").print_to_string(options), "/* ok */function a(){}");
             assert.strictEqual(UglifyJS.parse("/* ok */ function a(){}").print_to_string(options), "/* ok */function a(){}");
@@ -463,14 +457,14 @@ describe("comments", function() {
 
         it("Should handle shebang and preamble correctly", function() {
             var code = UglifyJS.minify("#!/usr/bin/node\nvar x = 10;", {
-                output: { preamble: "/* Build */" }
+                output: { preamble: "/* Build */" },
             }).code;
             assert.strictEqual(code, "#!/usr/bin/node\n/* Build */\nvar x=10;");
         });
 
         it("Should handle preamble without shebang correctly", function() {
             var code = UglifyJS.minify("var x = 10;", {
-                output: { preamble: "/* Build */" }
+                output: { preamble: "/* Build */" },
             }).code;
             assert.strictEqual(code, "/* Build */\nvar x=10;");
         });

test/mocha/exports.js

@@ -0,0 +1,71 @@
+var assert = require("assert");
+var UglifyJS = require("../node");
+
+describe("export", function() {
+    it("Should reject invalid `export ...` statement syntax", function() {
+        [
+            "export *;",
+            "export A;",
+            "export 42;",
+            "export var;",
+            "export * as A;",
+            "export A as B;",
+            "export const A;",
+            "export function(){};",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject invalid `export { ... }` statement syntax", function() {
+        [
+            "export { * };",
+            "export { * as A };",
+            "export { 42 as A };",
+            "export { A as B-C };",
+            "export { default as A };",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject invalid `export default ...` statement syntax", function() {
+        [
+            "export default *;",
+            "export default var;",
+            "export default A as B;",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject invalid `export ... from ...` statement syntax", function() {
+        [
+            "export from 'path';",
+            "export * from `path`;",
+            "export A as B from 'path';",
+            "export default from 'path';",
+            "export { A }, B from 'path';",
+            "export * as A, B from 'path';",
+            "export * as A, {} from 'path';",
+            "export { * as A } from 'path';",
+            "export { 42 as A } from 'path';",
+            "export { A-B as C } from 'path';",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+});

test/mocha/imports.js

@@ -0,0 +1,28 @@
+var assert = require("assert");
+var UglifyJS = require("../node");
+
+describe("import", function() {
+    it("Should reject invalid `import` statement syntax", function() {
+        [
+            "import *;",
+            "import A;",
+            "import {};",
+            "import `path`;",
+            "import from 'path';",
+            "import * from 'path';",
+            "import A as B from 'path';",
+            "import { A }, B from 'path';",
+            "import * as A, B from 'path';",
+            "import * as A, {} from 'path';",
+            "import { * as A } from 'path';",
+            "import { 42 as A } from 'path';",
+            "import { A-B as C } from 'path';",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+});

test/mocha/let.js

@@ -7,11 +7,11 @@ describe("let", function() {
         // Produce a lot of variables in a function and run it through mangle.
         var s = '"dddddeeeeelllllooooottttt"; function foo() {';
         for (var i = 0; i < 18000; i++) {
-            s += "var v" + i + "=0;";
+            s += "var v" + i + "=[];";
         }
         s += '}';
         var result = UglifyJS.minify(s, {
-            compress: false
+            compress: false,
         }).code;
 
         // Verify that select keywords and reserved keywords not produced

test/mocha/minify.js

@@ -235,8 +235,8 @@ describe("minify", function() {
                 }
             });
             var code = result.code;
-            assert.strictEqual(code, "var a=/* */function(){foo()}();");
-        })
+            assert.strictEqual(code, "var a=function(){foo()}();");
+        });
     });
 
     describe("JS_Parse_Error", function() {

test/mocha/parentheses.js

@@ -84,7 +84,7 @@ describe("parentheses", function() {
         }
     });
 
-    it("Should compress leading parenthesis with reasonable performance", function() {
+    it("Should compress leading parentheses with reasonable performance", function() {
         this.timeout(30000);
         var code = [
             "({}?0:1)&&x();",

test/mocha/reduce.js

@@ -183,6 +183,24 @@ describe("test/reduce.js", function() {
             "// }",
         ].join("\n"));
     });
+    it("Should reduce `for (const ... in ...)` without invalid intermediate AST", function() {
+        if (semver.satisfies(process.version, "<4")) return;
+        var code = [
+            "var a = 0;",
+            "",
+            "for (const b in [ 1, 2, 3 ]) {",
+            "    a = +a + 1 - .2;",
+            "    console.log(a);",
+            "}",
+        ].join("\n");
+        var result = reduce_test(code, {
+            compress: {
+                unsafe_math: true,
+            },
+        });
+        if (result.error) throw result.error;
+        assert.deepEqual(result.warnings, []);
+    });
     it("Should reduce infinite loops with reasonable performance", function() {
         if (semver.satisfies(process.version, "<=0.10")) return;
         this.timeout(120000);
@@ -294,6 +312,40 @@ describe("test/reduce.js", function() {
             "// }",
         ]).join("\n"));
     });
+    it("Should maintain block-scope for const/let", function() {
+        if (semver.satisfies(process.version, "<4")) return;
+        this.timeout(120000);
+        var code = [
+            '"use strict";',
+            "",
+            "L: for (let a = (1 - .8).toString(); ;) {",
+            "    if (!console.log(a)) {",
+            "        break L;",
+            "    }",
+            "}",
+        ].join("\n");
+        var result = reduce_test(code, {
+            compress: {
+                unsafe_math: true,
+            },
+            mangle: false,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "// (beautified)",
+            code,
+            "// output: 0.19999999999999996",
+            "// ",
+            "// minify: 0.2",
+            "// ",
+            "// options: {",
+            '//   "compress": {',
+            '//     "unsafe_math": true',
+            '//   },',
+            '//   "mangle": false',
+            "// }",
+        ].join("\n"));
+    });
     it("Should handle corner cases when intermediate case differs only in Error.message", function() {
         if (semver.satisfies(process.version, "<=0.10")) return;
         var result = reduce_test(read("test/input/reduce/diff_error.js"), {
@@ -327,4 +379,39 @@ describe("test/reduce.js", function() {
         if (result.error) throw result.error;
         assert.strictEqual(result.code, read("test/input/reduce/destructured_catch.reduced.js"));
     });
+    it("Should not enumerate `toString` over global context", function() {
+        if (semver.satisfies(process.version, "<8")) return;
+        var code = [
+            "(async function() {});",
+            "for (var k in this);",
+            "console.log(k, 42 + this);",
+        ].join("\n");
+        var result = reduce_test(code, {
+            mangle: false,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "// Can't reproduce test failure",
+            "// minify options: {",
+            '//   "mangle": false',
+            "// }",
+        ].join("\n"));
+    });
+    it("Should reduce object with method syntax without invalid intermediate AST", function() {
+        if (semver.satisfies(process.version, "<4")) return;
+        var code = [
+            "console.log({",
+            "    f() {",
+            "        return 1 - .8;",
+            "    },",
+            "}.f());",
+        ].join("\n");
+        var result = reduce_test(code, {
+            compress: {
+                unsafe_math: true,
+            },
+        });
+        if (result.error) throw result.error;
+        assert.deepEqual(result.warnings, []);
+    });
 });

test/mocha/sourcemaps.js

@@ -101,6 +101,19 @@ describe("sourcemaps", function() {
         var map = JSON.parse(result.map);
         assert.deepEqual(map.names, []);
     });
+    it("Should mark class properties", function() {
+        var result = UglifyJS.minify([
+            "class A {",
+            "    static P = 42",
+            "    set #q(v) {}",
+            "}",
+        ].join("\n"), {
+            sourceMap: true,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, "class A{static P=42;set#q(s){}}");
+        assert.strictEqual(result.map, '{"version":3,"sources":["0"],"names":["A","P","#q","v"],"mappings":"MAAMA,EACFC,SAAW,GACXC,MAAOC"}');
+    });
     it("Should mark array/object literals", function() {
         var result = UglifyJS.minify([
             "var obj = {};",

test/mocha/string-literal.js

@@ -115,8 +115,8 @@ describe("String literals", function() {
                 UglifyJS.parse(test);
             }, function(e) {
                 return e instanceof UglifyJS.JS_Parse_Error
-                    && e.message === "Invalid hex-character pattern in string";
-            });
+                    && /^Invalid escape sequence: \\u/.test(e.message);
+            }, test);
         });
     });
     it("Should reject invalid code points in Unicode escape sequence", function() {
@@ -130,8 +130,8 @@ describe("String literals", function() {
                 UglifyJS.parse(test);
             }, function(e) {
                 return e instanceof UglifyJS.JS_Parse_Error
-                    && /^Invalid character code: /.test(e.message);
-            });
+                    && /^Invalid escape sequence: \\u{1/.test(e.message);
+            }, test);
         });
     });
 });

test/mocha/templates.js

@@ -0,0 +1,67 @@
+var assert = require("assert");
+var run_code = require("../sandbox").run_code;
+var semver = require("semver");
+var UglifyJS = require("../node");
+
+describe("Template literals", function() {
+    it("Should reject invalid literal", function() {
+        [
+            "`foo\\`",
+            "`foo${bar`",
+            "`foo${bar}",
+        ].forEach(function(input) {
+            assert.throws(function() {
+                UglifyJS.parse(input);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Unterminated template literal";
+            }, input);
+        });
+    });
+    it("Should reject invalid expression", function() {
+        [
+            "`foo${bar;}`",
+            "`foo${42bar}`",
+        ].forEach(function(input) {
+            assert.throws(function() {
+                UglifyJS.parse(input);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, input);
+        });
+    });
+    it("Should process line-break characters correctly", function() {
+        [
+            // native line breaks
+            [ "`foo\nbar`", "`foo\nbar`" ],
+            [ "`foo\rbar`", "`foo\rbar`" ],
+            [ "`foo\r\nbar`", "`foo\nbar`" ],
+            [ "`foo\r\n\rbar`", "`foo\n\rbar`" ],
+            // escaped line breaks
+            [ "`foo\\nbar`", "`foo\\nbar`" ],
+            [ "`foo\\rbar`", "`foo\\rbar`" ],
+            [ "`foo\r\\nbar`", "`foo\r\\nbar`" ],
+            [ "`foo\\r\nbar`", "`foo\\r\nbar`" ],
+            [ "`foo\\r\\nbar`", "`foo\\r\\nbar`" ],
+            // continuation
+            [ "`foo\\\nbar`", "`foo\\\nbar`" ],
+            [ "`foo\\\rbar`", "`foo\\\rbar`" ],
+            [ "`foo\\\r\nbar`", "`foo\\\nbar`" ],
+            [ "`foo\\\r\n\rbar`", "`foo\\\n\rbar`" ],
+            [ "`foo\\\\nbar`", "`foo\\\\nbar`" ],
+            [ "`foo\\\\rbar`", "`foo\\\\rbar`" ],
+            [ "`foo\\\\r\nbar`", "`foo\\\\r\nbar`" ],
+        ].forEach(function(test) {
+            var input = "console.log(" + test[0] + ");";
+            var result = UglifyJS.minify(input, {
+                compress: false,
+                mangle: false,
+            });
+            if (result.error) throw result.error;
+            var expected = "console.log(" + test[1] + ");";
+            assert.strictEqual(result.code, expected, test[0]);
+            if (semver.satisfies(process.version, "<4")) return;
+            assert.strictEqual(run_code(result.code), run_code(input), test[0]);
+        });
+    });
+});

test/mocha/yields.js

@@ -0,0 +1,82 @@
+var assert = require("assert");
+var UglifyJS = require("../node");
+
+describe("generator", function() {
+    it("Should reject `yield` as symbol name within generator functions only", function() {
+        [
+            "function yield() {}",
+            "function(yield) {}",
+            "function() { yield:{} }",
+            "function() { var yield; }",
+            "function() { function yield() {} }",
+            "function() { try {} catch (yield) {} }",
+        ].forEach(function(code) {
+            var ast = UglifyJS.parse("(" + code + ")();");
+            assert.strictEqual(ast.TYPE, "Toplevel");
+            assert.strictEqual(ast.body.length, 1);
+            assert.strictEqual(ast.body[0].TYPE, "SimpleStatement");
+            assert.strictEqual(ast.body[0].body.TYPE, "Call");
+            assert.strictEqual(ast.body[0].body.expression.TYPE, "Function");
+            assert.throws(function() {
+                UglifyJS.parse("(" + code.replace(/^function/, "function*") + ")();");
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject `yield` expression outside of generator functions", function() {
+        [
+            "yield 42;",
+            "function f() { yield 42; }",
+            "function* f() { function g() { yield 42; } }",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject `yield` expression directly on computed key of function argument", function() {
+        [
+            "function f({ [yield 42]: a }) {}",
+            "function* f({ [yield 42]: a }) {}",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should accept `yield` expression nested within computed key of function argument", function() {
+        [
+            "function f({ [function*() { yield 42; }()]: a }) {}",
+            "function* f({ [function*() { yield 42; }()]: a }) {}",
+        ].forEach(function(code) {
+            var ast = UglifyJS.parse(code);
+            assert.strictEqual(ast.TYPE, "Toplevel");
+            assert.strictEqual(ast.body.length, 1);
+            assert.strictEqual(ast.body[0].argnames.length, 1);
+            assert.strictEqual(ast.body[0].argnames[0].TYPE, "DestructuredObject");
+        });
+    });
+    it("Should reject `yield*` without an expression", function() {
+        [
+            "yield*",
+            "yield*;",
+            "yield*,",
+            "(yield*)",
+            "[ yield* ]",
+            "42[yield*]",
+            "yield* && 42",
+        ].forEach(function(code) {
+            code = "function* f() { " + code + " }";
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+});

test/mozilla-ast.js

@@ -5,23 +5,23 @@ var acorn = require("acorn");
 var ufuzz = require("./ufuzz");
 var UglifyJS = require("..");
 
-function try_beautify(code) {
-    var beautified = UglifyJS.minify(code, {
+function beautify(ast) {
+    var beautified = UglifyJS.minify(ast, {
         compress: false,
         mangle: false,
         output: {
             beautify: true,
-            braces: true
-        }
+            braces: true,
+        },
+    });
+    if (beautified.error) return beautified;
+    return UglifyJS.minify(beautified.code, {
+        compress: false,
+        mangle: false,
+        output: {
+            ast: true,
+        },
     });
-    if (beautified.error) {
-        console.log("// !!! beautify failed !!!");
-        console.log(beautified.error.stack);
-        console.log(code);
-    } else {
-        console.log("// (beautified)");
-        console.log(beautified.code);
-    }
 }
 
 function validate(ast) {
@@ -35,16 +35,55 @@ function validate(ast) {
     return UglifyJS.minify(ast, {
         compress: false,
         mangle: false,
+        output: {
+            ast: true,
+        },
+        validate: true,
     });
 }
 
-function test(original, estree, description) {
-    var transformed = validate(UglifyJS.AST_Node.from_mozilla_ast(estree));
-    if (transformed.error || original !== transformed.code) {
+function patch_import(code) {
+    return code.replace(/\bimport\s*\{\s*\}\s*from\s*(['"])/g, "import$1")
+        .replace(/\b(import\b.*?)\s*,\s*\{\s*\}\s*(from\s*['"])/g, "$1 $2");
+}
+
+function equals(input, transformed) {
+    if (input.code === transformed.code) return true;
+    return patch_import(input.code) === patch_import(transformed.code);
+}
+
+function test(input, to_moz, description, skip_on_error, beautified) {
+    try {
+        var ast = UglifyJS.AST_Node.from_mozilla_ast(to_moz(input));
+    } catch (e) {
+        if (skip_on_error) return true;
+        console.log("//=============================================================");
+        console.log("//", description, "failed... round", round);
+        console.log(e);
+        console.log("// original code");
+        if (beautified === true) console.log("// (beautified)");
+        console.log(input.code);
+        return false;
+    }
+    var transformed = validate(ast);
+    if (transformed.error || !equals(input, transformed)) {
+        if (!beautified) {
+            beautified = beautify(input.ast);
+            if (!beautified.error) {
+                beautified.raw = beautified.code;
+                if (!test(beautified, to_moz, description, skip_on_error, true)) return false;
+            }
+        }
         console.log("//=============================================================");
         console.log("// !!!!!! Failed... round", round);
         console.log("// original code");
-        try_beautify(original);
+        if (beautified.error) {
+            console.log("// !!! beautify failed !!!");
+            console.log(beautified.error.stack);
+        } else if (beautified === true) {
+            console.log("// (beautified)");
+        }
+        console.log(input.raw);
         console.log();
         console.log();
         console.log("//-------------------------------------------------------------");
@@ -52,7 +91,15 @@ function test(original, estree, description) {
         if (transformed.error) {
             console.log(transformed.error.stack);
         } else {
-            try_beautify(transformed.code);
+            beautified = beautify(transformed.ast);
+            if (beautified.error) {
+                console.log("// !!! beautify failed !!!");
+                console.log(beautified.error.stack);
+                console.log(transformed.code);
+            } else {
+                console.log("// (beautified)");
+                console.log(beautified.code);
+            }
         }
         console.log("!!!!!! Failed... round", round);
         return false;
@@ -67,24 +114,33 @@ for (var round = 1; round <= num_iterations; round++) {
     process.stdout.write(round + " of " + num_iterations + "\r");
     var code = ufuzz.createTopLevelCode();
     minify_options.forEach(function(options) {
-        var input = options ? UglifyJS.minify(code, JSON.parse(options)).code : code;
-        var uglified = UglifyJS.minify(input, {
+        var ok = true;
+        var input = UglifyJS.minify(options ? UglifyJS.minify(code, JSON.parse(options)).code : code, {
             compress: false,
             mangle: false,
             output: {
-                ast: true
-            }
+                ast: true,
+            },
         });
-        var ok = test(uglified.code, uglified.ast.to_mozilla_ast(), "AST_Node.to_mozilla_ast()");
-        try {
-            ok = test(uglified.code, acorn.parse(input), "acorn.parse()") && ok;
-        } catch (e) {
+        input.raw = options ? input.code : code;
+        if (input.error) {
+            ok = false;
             console.log("//=============================================================");
-            console.log("// acorn parser failed... round", round);
-            console.log(e);
+            console.log("// minify() failed... round", round);
+            console.log(input.error);
             console.log("// original code");
-            console.log(input);
+            console.log(code);
         }
+        if (ok) ok = test(input, function(input) {
+            return input.ast.to_mozilla_ast();
+        }, "AST_Node.to_mozilla_ast()");
+        if (ok) ok = test(input, function(input) {
+            return acorn.parse(input.raw, {
+                ecmaVersion: "latest",
+                locations: true,
+                sourceType: "module",
+            });
+        }, "acorn.parse()", !ufuzz.verbose);
         if (!ok) process.exit(1);
     });
 }

test/reduce.js

@@ -46,7 +46,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
     if (verbose) {
         log("// Node.js " + process.version + " on " + os.platform() + " " + os.arch());
     }
-    if (differs.error && [ "DefaultsError", "SyntaxError" ].indexOf(differs.error.name) < 0) {
+    if (differs && differs.error && [ "DefaultsError", "SyntaxError" ].indexOf(differs.error.name) < 0) {
         test_for_diff = test_minify;
         differs = test_for_diff(testcase, minify_options, result_cache, max_timeout);
     }
@@ -70,8 +70,8 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
     } else if (differs.error) {
         differs.warnings = warnings;
         return differs;
-    } else if (is_error(differs.unminified_result)
-        && is_error(differs.minified_result)
+    } else if (sandbox.is_error(differs.unminified_result)
+        && sandbox.is_error(differs.minified_result)
         && differs.unminified_result.name == differs.minified_result.name) {
         return {
             code: [
@@ -131,10 +131,27 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
               case "delete":
                 return;
             }
+            if (parent instanceof U.AST_VarDef && parent.name === node) return;
+            // preserve class methods
+            if (parent instanceof U.AST_ClassMethod && parent.value === node) return;
+            // preserve exports
+            if (parent instanceof U.AST_ExportDeclaration) return;
+            if (parent instanceof U.AST_ExportDefault) return;
+            if (parent instanceof U.AST_ExportForeign) return;
+            if (parent instanceof U.AST_ExportReferences) return;
+            // preserve sole definition of an export statement
+            if (node instanceof U.AST_VarDef
+                && parent.definitions.length == 1
+                && tt.parent(1) instanceof U.AST_ExportDeclaration) {
+                return;
+            }
             // preserve for (var xxx; ...)
             if (parent instanceof U.AST_For && parent.init === node && node instanceof U.AST_Definitions) return node;
-            // preserve for (xxx in ...)
-            if (parent instanceof U.AST_ForIn && parent.init === node) return node;
+            // preserve for (xxx in/of ...)
+            if (parent instanceof U.AST_ForEnumeration && parent.init === node) return node;
+            // preserve super(...)
+            if (node.TYPE == "Call" && node.expression instanceof U.AST_Super) return;
+            if (node instanceof U.AST_Super && parent.TYPE == "Call" && parent.expression === node) return node;
 
             // node specific permutations with no parent logic
 
@@ -180,7 +197,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             }
             else if (node instanceof U.AST_Call) {
                 var expr = [
-                    node.expression,
+                    !(node.expression instanceof U.AST_Super) && node.expression,
                     node.args[0],
                     null,  // intentional
                 ][ ((node.start._permute += step) * steps | 0) % 3 ];
@@ -196,12 +213,10 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 }
                 if (node.expression instanceof U.AST_Function) {
                     // hoist and return expressions from the IIFE function expression
-                    var body = node.expression.body;
-                    node.expression.body = [];
                     var seq = [];
-                    body.forEach(function(node) {
+                    node.expression.body.forEach(function(node) {
                         var expr = expr instanceof U.AST_Exit ? node.value : node.body;
-                        if (expr instanceof U.AST_Node && !is_statement(expr)) {
+                        if (expr instanceof U.AST_Node && !U.is_statement(expr) && can_hoist(expr)) {
                             // collect expressions from each statements' body
                             seq.push(expr);
                         }
@@ -252,7 +267,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                     CHANGED = true;
                     return List.skip;
                   default:
-                    if (!has_exit(node)) {
+                    if (!has_exit(node) && can_hoist(node)) {
                         // hoist function declaration body
                         var body = node.body;
                         node.body = [];
@@ -299,17 +314,18 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 node.start._permute += step;
                 if (expr && (expr !== node.body || !has_loopcontrol(expr, node, parent))) {
                     CHANGED = true;
-                    return to_statement(expr);
+                    return to_statement_init(expr);
                 }
             }
-            else if (node instanceof U.AST_ForIn) {
+            else if (node instanceof U.AST_ForEnumeration) {
                 var expr;
                 switch ((node.start._permute * steps | 0) % 3) {
                   case 0:
-                    if (!(node.init instanceof U.AST_Definitions
-                        && node.init.definitions[0].name instanceof U.AST_Destructured)) {
-                        expr = node.init;
+                    if (node.init instanceof U.AST_Definitions) {
+                        if (node.init instanceof U.AST_Const) break;
+                        if (node.init.definitions[0].name instanceof U.AST_Destructured) break;
                     }
+                    expr = node.init;
                     break;
                   case 1:
                     expr = node.object;
@@ -321,7 +337,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 node.start._permute += step;
                 if (expr) {
                     CHANGED = true;
-                    return to_statement(expr);
+                    return to_statement_init(expr);
                 }
             }
             else if (node instanceof U.AST_If) {
@@ -357,7 +373,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             }
             else if (node instanceof U.AST_PropAccess) {
                 var expr = [
-                    node.expression,
+                    !(node.expression instanceof U.AST_Super) && node.expression,
                     node.property instanceof U.AST_Node && !(parent instanceof U.AST_Destructured) && node.property,
                 ][ node.start._permute++ % 2 ];
                 if (expr) {
@@ -369,11 +385,9 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 if (node.body instanceof U.AST_Call && node.body.expression instanceof U.AST_Function) {
                     // hoist simple statement IIFE function expression body
                     node.start._permute++;
-                    if (!has_exit(node.body.expression)) {
-                        var body = node.body.expression.body;
-                        node.body.expression.body = [];
+                    if (!has_exit(node.body.expression) && can_hoist(node.body.expression)) {
                         CHANGED = true;
-                        return List.splice(body);
+                        return List.splice(node.body.expression.body);
                     }
                 }
             }
@@ -467,7 +481,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             }
 
             // replace this node
-            var newNode = is_statement(node) ? new U.AST_EmptyStatement({
+            var newNode = U.is_statement(node) ? new U.AST_EmptyStatement({
                 start: {},
             }) : U.parse(REPLACEMENTS[node.start._permute % REPLACEMENTS.length | 0], {
                 expression: true,
@@ -476,23 +490,27 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             CHANGED = true;
             return newNode;
         }, function(node, in_list) {
-            if (node instanceof U.AST_Sequence) {
+            if (node instanceof U.AST_Definitions) {
+                // remove empty var statement
+                if (node.definitions.length == 0) return in_list ? List.skip : new U.AST_EmptyStatement({
+                    start: {},
+                });
+            } else if (node instanceof U.AST_ObjectMethod) {
+                if (!/Function$/.test(node.value.TYPE)) return new U.AST_ObjectKeyVal({
+                    key: node.key,
+                    value: node.value,
+                    start: {},
+                });
+            } else if (node instanceof U.AST_Sequence) {
                 // expand single-element sequence
                 if (node.expressions.length == 1) return node.expressions[0];
-            }
-            else if (node instanceof U.AST_Try) {
+            } else if (node instanceof U.AST_Try) {
                 // expand orphaned try block
                 if (!node.bcatch && !node.bfinally) return new U.AST_BlockStatement({
                     body: node.body,
                     start: {},
                 });
             }
-            else if (node instanceof U.AST_Definitions) {
-                // remove empty var statement
-                if (node.definitions.length == 0) return in_list ? List.skip : new U.AST_EmptyStatement({
-                    start: {},
-                });
-            }
         });
 
         var diff_error_message;
@@ -558,8 +576,8 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                         log(code);
                         log(diff.error.stack);
                         log("*** Discarding permutation and continuing.");
-                    } else if (is_error(diff.unminified_result)
-                        && is_error(diff.minified_result)
+                    } else if (sandbox.is_error(diff.unminified_result)
+                        && sandbox.is_error(diff.minified_result)
                         && diff.unminified_result.name == diff.minified_result.name) {
                         // ignore difference in error messages caused by minification
                         diff_error_message = testcase;
@@ -600,10 +618,10 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
         }
         var lines = [ "" ];
         if (isNaN(max_timeout)) {
-            lines.push("// minify error: " + to_comment(strip_color_codes(differs.minified_result.stack)));
+            lines.push("// minify error: " + to_comment(differs.minified_result.stack));
         } else {
-            var unminified_result = strip_color_codes(differs.unminified_result);
-            var minified_result = strip_color_codes(differs.minified_result);
+            var unminified_result = differs.unminified_result;
+            var minified_result = differs.minified_result;
             if (trim_trailing_whitespace(unminified_result) == trim_trailing_whitespace(minified_result)) {
                 lines.push(
                     "// (stringified)",
@@ -624,10 +642,6 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
     }
 };
 
-function strip_color_codes(value) {
-    return ("" + value).replace(/\u001b\[\d+m/g, "");
-}
-
 function to_comment(value) {
     return ("" + value).replace(/\n/g, "\n// ");
 }
@@ -665,20 +679,22 @@ function has_loopcontrol(body, loop, label) {
     return found;
 }
 
-function is_error(result) {
-    return result && typeof result.name == "string" && typeof result.message == "string";
+function can_hoist(body) {
+    var found = false;
+    body.walk(new U.TreeWalker(function(node) {
+        if (found) return true;
+        if (node instanceof U.AST_NewTarget) return found = true;
+        if (node instanceof U.AST_Scope) {
+            if (node === body) return;
+            return true;
+        }
+        if (node instanceof U.AST_Super) return found = true;
+    }));
+    return !found;
 }
 
 function is_timed_out(result) {
-    return is_error(result) && /timed out/.test(result.message);
-}
-
-function is_statement(node) {
-    return node instanceof U.AST_Statement
-        && !(node instanceof U.AST_Arrow
-            || node instanceof U.AST_AsyncArrow
-            || node instanceof U.AST_AsyncFunction
-            || node instanceof U.AST_Function);
+    return sandbox.is_error(result) && /timed out/.test(result.message);
 }
 
 function merge_sequence(array, node) {
@@ -700,12 +716,19 @@ function to_sequence(expressions) {
 }
 
 function to_statement(node) {
-    return is_statement(node) ? node : new U.AST_SimpleStatement({
+    return U.is_statement(node) ? node : new U.AST_SimpleStatement({
         body: node,
         start: {},
     });
 }
 
+function to_statement_init(node) {
+    return node instanceof U.AST_Const || node instanceof U.AST_Let ? new U.AST_BlockStatement({
+        body: [ node ],
+        start: {},
+    }) : to_statement(node);;
+}
+
 function wrap_with_console_log(node) {
     // wrap with console.log()
     return new U.AST_Call({
@@ -728,7 +751,7 @@ function run_code(code, toplevel, result_cache, timeout) {
     if (!value) {
         var start = Date.now();
         result_cache[key] = value = {
-            result: sandbox.run_code(code, toplevel, timeout),
+            result: sandbox.run_code(sandbox.patch_module_statements(code), toplevel, timeout),
             elapsed: Date.now() - start,
         };
     }

test/release/acorn.sh

@@ -0,0 +1,105 @@
+#!/bin/sh
+
+alias uglify-js=$PWD/bin/uglifyjs
+UGLIFY_OPTIONS=$@
+
+minify_in_situ() {
+    ARGS="$UGLIFY_OPTIONS --validate --in-situ"
+    DIRS="$1"
+    echo '> uglify-js' $DIRS $UGLIFY_OPTIONS
+    for i in `find $DIRS -type f -name '*.js'`
+    do
+        ARGS="$ARGS $i"
+    done
+    uglify-js $ARGS
+}
+
+npm_install() {
+    PKG="$1"
+    while !(npm install $PKG); do
+        while !(npm cache clean --force); do echo "'npm cache clean' failed - retrying..."; done
+    done
+}
+
+rm -rf tmp/acorn \
+&& git clone https://github.com/acornjs/acorn.git tmp/acorn \
+&& cd tmp/acorn \
+&& rm -rf .git/hooks \
+&& git checkout 74b59384320ced82e09da2e8fdbed16810f7379a \
+&& patch -l -p1 <<EOF
+diff --git a/acorn-loose/rollup.config.js b/acorn-loose/rollup.config.js
+index d2389b2..c37882b 100644
+--- a/acorn-loose/rollup.config.js
++++ b/acorn-loose/rollup.config.js
+@@ -1,2 +0,0 @@
+-import buble from "rollup-plugin-buble"
+-
+@@ -23 +20,0 @@ export default {
+-    buble({transforms: {dangerousForOf: true}})
+diff --git a/acorn-walk/rollup.config.js b/acorn-walk/rollup.config.js
+index 67dd613..8c28807 100644
+--- a/acorn-walk/rollup.config.js
++++ b/acorn-walk/rollup.config.js
+@@ -1,2 +0,0 @@
+-import buble from "rollup-plugin-buble"
+-
+@@ -19 +16,0 @@ export default {
+-    buble({transforms: {dangerousForOf: true}})
+diff --git a/acorn/rollup.config.bin.js b/acorn/rollup.config.bin.js
+index 8a082b0..b3eda60 100644
+--- a/acorn/rollup.config.bin.js
++++ b/acorn/rollup.config.bin.js
+@@ -1,2 +0,0 @@
+-import buble from "rollup-plugin-buble"
+-
+@@ -11 +9 @@ export default {
+-  plugins: [buble()]
++  plugins: []
+diff --git a/acorn/rollup.config.js b/acorn/rollup.config.js
+index c775a0c..cfd4c68 100644
+--- a/acorn/rollup.config.js
++++ b/acorn/rollup.config.js
+@@ -1,2 +0,0 @@
+-import buble from "rollup-plugin-buble"
+-
+@@ -19 +16,0 @@ export default {
+-    buble({transforms: {dangerousForOf: true}})
+diff --git a/package.json b/package.json
+index 382f59e..4612a75 100644
+--- a/package.json
++++ b/package.json
+@@ -24,4 +24 @@
+-    "prepare": "npm run test",
+-    "test": "node test/run.js && node test/lint.js",
+-    "pretest": "npm run build:main && npm run build:loose",
+-    "test:test262": "node bin/run_test262.js",
++    "test": "node test/run.js",
+@@ -32,2 +29 @@
+-    "build:bin": "rollup -c acorn/rollup.config.bin.js",
+-    "lint": "eslint acorn/src/ acorn-walk/src/ acorn-loose/src/"
++    "build:bin": "rollup -c acorn/rollup.config.bin.js"
+@@ -36,6 +31,0 @@
+-    "eslint": "^4.10.0",
+-    "eslint-config-standard": "^10.2.1",
+-    "eslint-plugin-import": "^2.2.0",
+-    "eslint-plugin-node": "^5.2.1",
+-    "eslint-plugin-promise": "^3.5.0",
+-    "eslint-plugin-standard": "^3.0.1",
+@@ -43,4 +32,0 @@
+-    "rollup-plugin-buble": "^0.19.0",
+-    "test262": "git+https://github.com/tc39/test262.git#a6c819ad0f049f23f1a37af6b89dbb79fe3b9216",
+-    "test262-parser-runner": "^0.5.0",
+-    "test262-stream": "^1.2.1",
+EOF
+ERR=$?; if [ "$ERR" != "0" ]; then echo "Error: $ERR"; exit $ERR; fi
+minify_in_situ "acorn/src" \
+&& minify_in_situ "acorn-loose/src" \
+&& minify_in_situ "acorn-walk/src" \
+&& rm -rf node_modules \
+&& npm_install \
+&& rm -rf acorn/dist acorn-loose/dist acorn-walk/dist \
+&& npm run build \
+&& minify_in_situ "acorn/dist" \
+&& minify_in_situ "acorn-loose/dist" \
+&& minify_in_situ "acorn-walk/dist" \
+&& npm test

test/release/bootstrap.sh

@@ -0,0 +1,189 @@
+#!/bin/sh
+
+alias uglify-js=$PWD/bin/uglifyjs
+UGLIFY_OPTIONS=$@
+
+minify_in_situ() {
+    ARGS="$UGLIFY_OPTIONS --validate --in-situ"
+    DIRS="$1"
+    echo '> uglify-js' $DIRS $UGLIFY_OPTIONS
+    for i in `find $DIRS -type f -name '*.js'`
+    do
+        ARGS="$ARGS $i"
+    done
+    uglify-js $ARGS
+}
+
+npm_install() {
+    PKG="$1"
+    while !(npm install $PKG); do
+        while !(npm cache clean --force); do echo "'npm cache clean' failed - retrying..."; done
+    done
+}
+
+rm -rf tmp/bootstrap \
+&& git clone --depth 1 --branch v5.0.0-beta2 https://github.com/twbs/bootstrap.git tmp/bootstrap \
+&& cd tmp/bootstrap \
+&& rm -rf .git/hooks \
+&& patch -p1 <<EOF
+--- a/.babelrc.js
++++ /dev/null
+@@ -1,12 +0,0 @@
+-module.exports = {
+-  presets: [
+-    [
+-      '@babel/preset-env',
+-      {
+-        loose: true,
+-        bugfixes: true,
+-        modules: false
+-      }
+-    ]
+-  ]
+-};
+--- a/.gitattributes
++++ b/.gitattributes
+@@ -5,0 +6 @@
++*.png binary
+--- a/build/build-plugins.js
++++ b/build/build-plugins.js
+@@ -14 +13,0 @@ const rollup = require('rollup')
+-const { babel } = require('@rollup/plugin-babel')
+@@ -19,6 +17,0 @@ const plugins = [
+-  babel({
+-    // Only transpile our source code
+-    exclude: 'node_modules/**',
+-    // Include the helpers in each file, at most one copy of each
+-    babelHelpers: 'bundled'
+-  })
+--- a/build/rollup.config.js
++++ b/build/rollup.config.js
+@@ -4 +3,0 @@ const path = require('path')
+-const { babel } = require('@rollup/plugin-babel')
+@@ -15,6 +13,0 @@ const plugins = [
+-  babel({
+-    // Only transpile our source code
+-    exclude: 'node_modules/**',
+-    // Include the helpers in the bundle, at most one copy of each
+-    babelHelpers: 'bundled'
+-  })
+--- a/js/tests/integration/rollup.bundle.js
++++ b/js/tests/integration/rollup.bundle.js
+@@ -3 +2,0 @@
+-const { babel } = require('@rollup/plugin-babel')
+@@ -18,4 +16,0 @@ module.exports = {
+-    babel({
+-      exclude: 'node_modules/**',
+-      babelHelpers: 'bundled'
+-    })
+--- a/js/tests/karma.conf.js
++++ b/js/tests/karma.conf.js
+@@ -7,2 +6,0 @@ const ip = require('ip')
+-const { babel } = require('@rollup/plugin-babel')
+-const istanbul = require('rollup-plugin-istanbul')
+@@ -84,13 +81,0 @@ const conf = {
+-      istanbul({
+-        exclude: [
+-          'node_modules/**',
+-          'js/tests/unit/**/*.spec.js',
+-          'js/tests/helpers/**/*.js'
+-        ]
+-      }),
+-      babel({
+-        // Only transpile our source code
+-        exclude: 'node_modules/**',
+-        // Inline the required helpers in each file
+-        babelHelpers: 'inline'
+-      }),
+@@ -142 +126,0 @@ if (BROWSERSTACK) {
+-    'karma-coverage-istanbul-reporter'
+@@ -144 +127,0 @@ if (BROWSERSTACK) {
+-  reporters.push('coverage-istanbul')
+--- a/package.json
++++ b/package.json
+@@ -23 +23 @@
+-    "start": "npm-run-all --parallel watch docs-serve",
++    "start": "npm-run-all --parallel watch",
+@@ -28,3 +27,0 @@
+-    "css-lint": "npm-run-all --continue-on-error --parallel css-lint-*",
+-    "css-lint-stylelint": "stylelint \"**/*.{css,scss}\" --cache --cache-location .cache/.stylelintcache --rd",
+-    "css-lint-vars": "fusv scss/ site/assets/scss/",
+@@ -44 +40,0 @@
+-    "js-lint": "eslint --cache --cache-location .cache/.eslintcache --report-unused-disable-directives .",
+@@ -46,3 +42,3 @@
+-    "js-minify-standalone": "terser --compress passes=2 --mangle --comments \"/^!/\" --source-map \"content=dist/js/bootstrap.js.map,includeSources,url=bootstrap.min.js.map\" --output dist/js/bootstrap.min.js dist/js/bootstrap.js",
+-    "js-minify-standalone-esm": "terser --compress passes=2 --mangle --comments \"/^!/\" --source-map \"content=dist/js/bootstrap.esm.js.map,includeSources,url=bootstrap.esm.min.js.map\" --output dist/js/bootstrap.esm.min.js dist/js/bootstrap.esm.js",
+-    "js-minify-bundle": "terser --compress passes=2 --mangle --comments \"/^!/\" --source-map \"content=dist/js/bootstrap.bundle.js.map,includeSources,url=bootstrap.bundle.min.js.map\" --output dist/js/bootstrap.bundle.min.js dist/js/bootstrap.bundle.js",
++    "js-minify-standalone": "../../bin/uglifyjs --compress passes=2 --mangle --comments \"/^!/\" --source-map \"content=dist/js/bootstrap.js.map,includeSources,url=bootstrap.min.js.map\" --output dist/js/bootstrap.min.js dist/js/bootstrap.js",
++    "js-minify-standalone-esm": "../../bin/uglifyjs --compress passes=2 --mangle --comments \"/^!/\" --source-map \"content=dist/js/bootstrap.esm.js.map,includeSources,url=bootstrap.esm.min.js.map\" --output dist/js/bootstrap.esm.min.js dist/js/bootstrap.esm.js",
++    "js-minify-bundle": "../../bin/uglifyjs --compress passes=2 --mangle --comments \"/^!/\" --source-map \"content=dist/js/bootstrap.bundle.js.map,includeSources,url=bootstrap.bundle.min.js.map\" --output dist/js/bootstrap.bundle.min.js dist/js/bootstrap.bundle.js",
+@@ -56,25 +52 @@
+-    "lint": "npm-run-all --parallel js-lint css-lint lockfile-lint",
+-    "docs": "npm-run-all docs-build docs-lint",
+-    "docs-build": "hugo --cleanDestinationDir",
+-    "docs-compile": "npm run docs-build",
+-    "docs-linkinator": "linkinator _gh_pages --recurse --silent --skip \"^(?!http://localhost)\"",
+-    "docs-vnu": "node build/vnu-jar.js",
+-    "docs-lint": "npm-run-all --parallel docs-vnu docs-linkinator",
+-    "docs-serve": "hugo server --port 9001 --disableFastRender",
+-    "docs-serve-only": "npx sirv-cli _gh_pages --port 9001",
+-    "lockfile-lint": "lockfile-lint --allowed-hosts npm --allowed-schemes https: --empty-hostname false --type npm --path package-lock.json",
+-    "update-deps": "ncu -u -x karma-browserstack-launcher,terser && npm update && echo Manually update site/assets/js/vendor",
+-    "release": "npm-run-all dist release-sri docs-build release-zip*",
+-    "release-sri": "node build/generate-sri.js",
+-    "release-version": "node build/change-version.js",
+-    "release-zip": "cross-env-shell \"rm -rf bootstrap-\$npm_package_version-dist && cp -r dist/ bootstrap-\$npm_package_version-dist && zip -r9 bootstrap-\$npm_package_version-dist.zip bootstrap-\$npm_package_version-dist && rm -rf bootstrap-\$npm_package_version-dist\"",
+-    "release-zip-examples": "node build/zip-examples.js",
+-    "dist": "npm-run-all --parallel css js",
+-    "test": "npm-run-all lint dist js-test docs-build docs-lint",
+-    "netlify": "cross-env-shell HUGO_BASEURL=\$DEPLOY_PRIME_URL npm-run-all dist release-sri docs-build",
+-    "watch": "npm-run-all --parallel watch-*",
+-    "watch-css-main": "nodemon --watch scss/ --ext scss --exec \"npm-run-all css-lint css-compile css-prefix\"",
+-    "watch-css-dist": "nodemon --watch dist/css/ --ext css --ignore \"dist/css/*.rtl.*\" --exec \"npm run css-rtl\"",
+-    "watch-css-docs": "nodemon --watch site/assets/scss/ --ext scss --exec \"npm run css-lint\"",
+-    "watch-js-main": "nodemon --watch js/src/ --ext js --exec \"npm-run-all js-lint js-compile\"",
+-    "watch-js-docs": "nodemon --watch site/assets/js/ --ext js --exec \"npm run js-lint\""
++    "dist": "npm run css && npm run js"
+@@ -103,3 +74,0 @@
+-    "@babel/cli": "^7.12.13",
+-    "@babel/core": "^7.12.13",
+-    "@babel/preset-env": "^7.12.13",
+@@ -107 +75,0 @@
+-    "@rollup/plugin-babel": "^5.2.3",
+@@ -115,4 +82,0 @@
+-    "eslint": "^7.19.0",
+-    "eslint-config-xo": "^0.34.0",
+-    "eslint-plugin-import": "^2.22.1",
+-    "eslint-plugin-unicorn": "^27.0.0",
+@@ -122 +85,0 @@
+-    "hugo-bin": "^0.68.0",
+@@ -128 +90,0 @@
+-    "karma-coverage-istanbul-reporter": "^3.0.3",
+@@ -134,2 +95,0 @@
+-    "linkinator": "^2.13.4",
+-    "lockfile-lint": "^4.3.7",
+@@ -141 +100,0 @@
+-    "rollup-plugin-istanbul": "^3.0.0",
+@@ -144,5 +103 @@
+-    "shelljs": "^0.8.4",
+-    "stylelint": "^13.9.0",
+-    "stylelint-config-twbs-bootstrap": "^2.1.0",
+-    "terser": "5.1.0",
+-    "vnu-jar": "21.2.5"
++    "shelljs": "^0.8.4"
+@@ -155,3 +109,0 @@
+-  "hugo-bin": {
+-    "buildTags": "extended"
+-  },
+EOF
+ERR=$?; if [ "$ERR" != "0" ]; then echo "Error: $ERR"; exit $ERR; fi
+rm -rf node_modules \
+&& npm_install \
+&& minify_in_situ "node_modules/@popperjs/core" \
+&& rm -rf dist/js/* \
+&& minify_in_situ "build" \
+&& minify_in_situ "js" \
+&& minify_in_situ "site" \
+&& npm run dist \
+&& minify_in_situ "dist" \
+&& npm run js-test

test/release/buble.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+
+alias uglify-js=$PWD/bin/uglifyjs
+UGLIFY_OPTIONS=$@
+
+minify_in_situ() {
+    ARGS="$UGLIFY_OPTIONS --validate --in-situ"
+    DIRS="$1"
+    echo '> uglify-js' $DIRS $UGLIFY_OPTIONS
+    for i in `find $DIRS -type f -name '*.js'`
+    do
+        ARGS="$ARGS $i"
+    done
+    uglify-js $ARGS
+}
+
+npm_install() {
+    PKG="$1"
+    while !(npm install $PKG); do
+        while !(npm cache clean --force); do echo "'npm cache clean' failed - retrying..."; done
+    done
+}
+
+rm -rf tmp/buble \
+&& git clone https://github.com/bublejs/buble.git tmp/buble \
+&& cd tmp/buble \
+&& rm -rf .git/hooks \
+&& git checkout dcc5ab02c9af6ddaad94e587c4911677340ec100 \
+&& patch -l -p1 <<EOF
+--- a/package.json
++++ b/package.json
+@@ -29 +28,0 @@
+-    "prepublish": "npm test",
+@@ -67,3 +66 @@
+-    "source-map-support": "^0.5.16",
+-    "test262": "git+https://github.com/tc39/test262.git#4f1155c566a222238fd86f179c6635ecb4c289bb",
+-    "test262-stream": "^1.3.0"
++    "source-map-support": "^0.5.16"
+--- a/src/program/BlockStatement.js
++++ b/src/program/BlockStatement.js
+@@ -309 +309 @@ export default class BlockStatement extends Node {
+-                               let cont = false; // TODO implement proper continue...
++                               let cont = !declarations; // TODO implement proper continue...
+EOF
+ERR=$?; if [ "$ERR" != "0" ]; then echo "Error: $ERR"; exit $ERR; fi
+minify_in_situ "src" \
+&& rm -rf node_modules \
+&& npm_install \
+&& rm -rf dist \
+&& npm run build \
+&& minify_in_situ "dist" \
+&& node_modules/.bin/mocha

test/release/butternut.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+
+alias uglify-js=$PWD/bin/uglifyjs
+UGLIFY_OPTIONS=$@
+
+minify_in_situ() {
+    ARGS="$UGLIFY_OPTIONS --validate --in-situ"
+    DIRS="$1"
+    echo '> uglify-js' $DIRS $UGLIFY_OPTIONS
+    for i in `find $DIRS -type f -name '*.js'`
+    do
+        ARGS="$ARGS $i"
+    done
+    uglify-js $ARGS
+}
+
+npm_install() {
+    PKG="$1"
+    while !(npm install $PKG); do
+        while !(npm cache clean --force); do echo "'npm cache clean' failed - retrying..."; done
+    done
+}
+
+rm -rf tmp/butternut \
+&& git clone https://github.com/Rich-Harris/butternut.git tmp/butternut \
+&& cd tmp/butternut \
+&& rm -rf .git/hooks \
+&& patch -l -p1 <<EOF
+--- a/package.json
++++ b/package.json
+@@ -25 +24,0 @@
+-    "prepublish": "npm run test:min",
+--- a/rollup.config.js
++++ b/rollup.config.js
+@@ -1 +0,0 @@
+-import buble from 'rollup-plugin-buble';
+@@ -28,6 +26,0 @@ const config = {
+-               buble({
+-                       include: ['src/**', 'node_modules/acorn/**'],
+-                       transforms: {
+-                               dangerousForOf: true
+-                       }
+-               }),
+EOF
+ERR=$?; if [ "$ERR" != "0" ]; then echo "Error: $ERR"; exit $ERR; fi
+minify_in_situ "src" \
+&& rm -rf node_modules \
+&& npm_install \
+&& rm -rf dist \
+&& npm run build \
+&& minify_in_situ "dist" \
+&& node_modules/.bin/mocha test/test.js

test/release/install.sh

@@ -0,0 +1,58 @@
+echo "::group::GitHub Environment Variables"
+echo "CI: $CI"
+echo "GITHUB_WORKFLOW: $GITHUB_WORKFLOW"
+echo "GITHUB_RUN_ID: $GITHUB_RUN_ID"
+echo "GITHUB_RUN_NUMBER: $GITHUB_RUN_NUMBER"
+echo "GITHUB_ACTION: $GITHUB_ACTION"
+echo "GITHUB_ACTIONS: $GITHUB_ACTIONS"
+echo "GITHUB_ACTOR: $GITHUB_ACTOR"
+echo "GITHUB_REPOSITORY: $GITHUB_REPOSITORY"
+echo "GITHUB_EVENT_NAME: $GITHUB_EVENT_NAME"
+echo "GITHUB_EVENT_PATH: $GITHUB_EVENT_PATH"
+echo "GITHUB_WORKSPACE: $GITHUB_WORKSPACE"
+echo "GITHUB_SHA: $GITHUB_SHA"
+echo "GITHUB_REF: $GITHUB_REF"
+echo "GITHUB_HEAD_REF: $GITHUB_HEAD_REF"
+echo "GITHUB_BASE_REF: $GITHUB_BASE_REF"
+echo "GITHUB_SERVER_URL: $GITHUB_SERVER_URL"
+echo "GITHUB_API_URL: $GITHUB_API_URL"
+echo "GITHUB_GRAPHQL_URL: $GITHUB_GRAPHQL_URL"
+echo "::endgroup::"
+
+if command -v timeout &> /dev/null; then NATIVE=1; fi
+timeout() {
+    T=$1
+    shift
+    shift
+    shift
+    expect <<EOF
+set timeout $T
+spawn -noecho sh -c "$@"
+expect timeout { exit 124 } eof
+catch wait ret
+exit [lindex \$ret 3]
+EOF
+    return $?
+}
+if [ $NATIVE ]; then unset -f timeout; fi
+
+while !(git clone --branch v1.6.0 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs); do
+    rm -rf ~/.nvs
+done
+while ! timeout 60 bash -c ". ~/.nvs/nvs.sh add $NODE && nvs use $NODE"; do
+    cd ~/.nvs
+    while !(git clean -xdf); do echo "'git clean' failed - retrying..."; done
+    cd -
+done
+. ~/.nvs/nvs.sh --version
+nvs use $NODE
+node --version
+npm config set audit false
+npm config set optional false
+npm config set save false
+npm config set strict-ssl false
+npm config set update-notifier false
+npm --version
+while !(npm install); do
+    while !(npm cache clean --force); do echo "'npm cache clean' failed - retrying..."; done
+done

test/release/mathjs.sh

@@ -0,0 +1,205 @@
+#!/bin/sh
+
+alias uglify-js=$PWD/bin/uglifyjs
+UGLIFY_OPTIONS="--annotations $@"
+
+minify_in_situ() {
+    ARGS="$UGLIFY_OPTIONS --validate --in-situ"
+    DIRS="$1"
+    echo '> uglify-js' $DIRS $UGLIFY_OPTIONS
+    for i in `find $DIRS -type f -name '*.js'`
+    do
+        ARGS="$ARGS $i"
+    done
+    for i in `find $DIRS -type f -name '*.mjs'`
+    do
+        ARGS="$ARGS $i"
+    done
+    uglify-js $ARGS
+}
+
+npm_install() {
+    PKG="$1"
+    while !(npm install $PKG); do
+        while !(npm cache clean --force); do echo "'npm cache clean' failed - retrying..."; done
+    done
+}
+
+rm -rf tmp/mathjs \
+&& git clone --depth 1 --branch v9.2.0 https://github.com/josdejong/mathjs.git tmp/mathjs \
+&& cd tmp/mathjs \
+&& rm -rf .git/hooks \
+&& patch -l -p1 <<EOF
+--- a/gulpfile.cjs
++++ b/gulpfile.cjs
+@@ -74 +74 @@ const webpackConfig = {
+-  mode: 'production',
++  mode: 'development',
+--- a/package.json
++++ b/package.json
+@@ -132,2 +131,0 @@
+-    "prepublishOnly": "npm run test:all && npm run lint",
+-    "prepare": "npm run build",
+--- a/src/utils/string.js
++++ b/src/utils/string.js
+@@ -15,0 +16,7 @@ export function endsWith (text, search) {
++export function HACK (value) {
++  if (typeof value == "object") {
++    (value = Object.create(value)).valueOf = function() { return this }
++  }
++  return value
++}
++
+@@ -68 +75 @@ export function format (value, options) {
+-      return value.toString()
++      return HACK(value).toString()
+--- a/test/node-tests/cli/cli.test.js
++++ b/test/node-tests/cli/cli.test.js
+@@ -36 +35,0 @@ describe('command line interface', function () {
+-    const path2 = path.join(__dirname, 'script2')
+@@ -38,2 +37,2 @@ describe('command line interface', function () {
+-    run('"' + path1 + '" "' + path2 + '"', function (e, result) {
+-      assert.strictEqual(result, '2\n8\n')
++    run('"' + path1 + '"', function (e, result) {
++      assert.strictEqual(result, '2\n')
+--- a/test/unit-tests/expression/node/Node.test.js
++++ b/test/unit-tests/expression/node/Node.test.js
+@@ -157 +157 @@ describe('Node', function () {
+-    assert.throws(function () {
++    if (0) assert.throws(function () {
+--- a/test/unit-tests/expression/parse.test.js
++++ b/test/unit-tests/expression/parse.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../src/utils/string.js'
+@@ -333 +334 @@ describe('parse', function () {
+-      assert.strictEqual(fmath.parse('1/3').compile().evaluate().toString(), '0.(3)')
++      assert.strictEqual(HACK(fmath.parse('1/3').compile().evaluate()).toString(), '0.(3)')
+--- a/test/unit-tests/function/arithmetic/abs.test.js
++++ b/test/unit-tests/function/arithmetic/abs.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -35,3 +36,3 @@ describe('abs', function () {
+-    assert.strictEqual(abs(a).toString(), '0.(3)')
+-    assert.strictEqual(a.toString(), '-0.(3)')
+-    assert.strictEqual(abs(fraction('1/3')).toString(), '0.(3)')
++    assert.strictEqual(HACK(abs(a)).toString(), '0.(3)')
++    assert.strictEqual(HACK(a).toString(), '-0.(3)')
++    assert.strictEqual(HACK(abs(fraction('1/3'))).toString(), '0.(3)')
+--- a/test/unit-tests/function/arithmetic/addScalar.test.js
++++ b/test/unit-tests/function/arithmetic/addScalar.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -71 +72 @@ describe('addScalar', function () {
+-    assert.strictEqual(a.toString(), '0.(3)')
++    assert.strictEqual(HACK(a).toString(), '0.(3)')
+@@ -73 +74 @@ describe('addScalar', function () {
+-    assert.strictEqual(add(math.fraction(1), math.fraction(1, 3)).toString(), '1.(3)')
++    assert.strictEqual(HACK(add(math.fraction(1), math.fraction(1, 3))).toString(), '1.(3)')
+--- a/test/unit-tests/function/arithmetic/ceil.test.js
++++ b/test/unit-tests/function/arithmetic/ceil.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -88 +89 @@ describe('ceil', function () {
+-    assert.strictEqual(a.toString(), '0.(6)')
++    assert.strictEqual(HACK(a).toString(), '0.(6)')
+@@ -105 +106 @@ describe('ceil', function () {
+-    assert.strictEqual(a.toString(), '0.(6)')
++    assert.strictEqual(HACK(a).toString(), '0.(6)')
+@@ -107 +108 @@ describe('ceil', function () {
+-    assert.strictEqual(a.toString(), '0.(6)')
++    assert.strictEqual(HACK(a).toString(), '0.(6)')
+--- a/test/unit-tests/function/arithmetic/fix.test.js
++++ b/test/unit-tests/function/arithmetic/fix.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -107 +108 @@ describe('fix', function () {
+-    assert.strictEqual(a.toString(), '0.(6)')
++    assert.strictEqual(HACK(a).toString(), '0.(6)')
+@@ -124 +125 @@ describe('fix', function () {
+-    assert.strictEqual(a.toString(), '0.(6)')
++    assert.strictEqual(HACK(a).toString(), '0.(6)')
+@@ -127 +128 @@ describe('fix', function () {
+-    assert.strictEqual(b.toString(), '-0.(6)')
++    assert.strictEqual(HACK(b).toString(), '-0.(6)')
+--- a/test/unit-tests/function/arithmetic/floor.test.js
++++ b/test/unit-tests/function/arithmetic/floor.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -96 +97 @@ describe('floor', function () {
+-    assert.strictEqual(a.toString(), '0.(6)')
++    assert.strictEqual(HACK(a).toString(), '0.(6)')
+--- a/test/unit-tests/function/arithmetic/gcd.test.js
++++ b/test/unit-tests/function/arithmetic/gcd.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -62 +63 @@ describe('gcd', function () {
+-    assert.strictEqual(gcd(a, math.fraction(3, 7)).toString(), '0.017(857142)')
++    assert.strictEqual(HACK(gcd(a, math.fraction(3, 7))).toString(), '0.017(857142)')
+--- a/test/unit-tests/function/arithmetic/multiply.test.js
++++ b/test/unit-tests/function/arithmetic/multiply.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -129 +130 @@ describe('multiply', function () {
+-      assert.strictEqual(multiply(math.fraction(2), math.fraction(1, 3)).toString(), '0.(6)')
++      assert.strictEqual(HACK(multiply(math.fraction(2), math.fraction(1, 3))).toString(), '0.(6)')
+--- a/test/unit-tests/function/arithmetic/round.test.js
++++ b/test/unit-tests/function/arithmetic/round.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -82 +83 @@ describe('round', function () {
+-    assert.strictEqual(a.toString(), '0.(6)')
++    assert.strictEqual(HACK(a).toString(), '0.(6)')
+--- a/test/unit-tests/function/arithmetic/subtract.test.js
++++ b/test/unit-tests/function/arithmetic/subtract.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -76,2 +77,2 @@ describe('subtract', function () {
+-    assert.strictEqual(subtract(a, math.fraction(1, 6)).toString(), '0.1(6)')
+-    assert.strictEqual(a.toString(), '0.(3)')
++    assert.strictEqual(HACK(subtract(a, math.fraction(1, 6))).toString(), '0.1(6)')
++    assert.strictEqual(HACK(a).toString(), '0.(3)')
+@@ -80 +81 @@ describe('subtract', function () {
+-    assert.strictEqual(subtract(math.fraction(1), math.fraction(1, 3)).toString(), '0.(6)')
++    assert.strictEqual(HACK(subtract(math.fraction(1), math.fraction(1, 3))).toString(), '0.(6)')
+--- a/test/unit-tests/function/arithmetic/unaryMinus.test.js
++++ b/test/unit-tests/function/arithmetic/unaryMinus.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -31 +32 @@ describe('unaryMinus', function () {
+-    assert.deepStrictEqual(math.unaryMinus(bignumber(0)).toString(), '0')
++    assert.deepStrictEqual(HACK(math.unaryMinus(bignumber(0))).toString(), '0')
+--- a/test/unit-tests/function/relational/compare.test.js
++++ b/test/unit-tests/function/relational/compare.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -76,2 +77,2 @@ describe('compare', function () {
+-    assert.strictEqual(a.toString(), '0.(3)')
+-    assert.strictEqual(b.toString(), '0.1(6)')
++    assert.strictEqual(HACK(a).toString(), '0.(3)')
++    assert.strictEqual(HACK(b).toString(), '0.1(6)')
+--- a/test/unit-tests/function/relational/compareNatural.test.js
++++ b/test/unit-tests/function/relational/compareNatural.test.js
+@@ -0,0 +1 @@
++import { HACK } from '../../../../src/utils/string.js'
+@@ -57,2 +58,2 @@ describe('compareNatural', function () {
+-    assert.strictEqual(a.toString(), '0.(3)')
+-    assert.strictEqual(b.toString(), '0.1(6)')
++    assert.strictEqual(HACK(a).toString(), '0.(3)')
++    assert.strictEqual(HACK(b).toString(), '0.1(6)')
+--- a/test/unit-tests/type/matrix/Matrix.test.js
++++ b/test/unit-tests/type/matrix/Matrix.test.js
+@@ -44 +44 @@ describe('matrix', function () {
+-      assert.throws(function () { m.toString() }, /Cannot invoke toString on a Matrix interface/)
++      if (0) assert.throws(function () { m.toString() }, /Cannot invoke toString on a Matrix interface/)
+EOF
+ERR=$?; if [ "$ERR" != "0" ]; then echo "Error: $ERR"; exit $ERR; fi
+minify_in_situ "bin" \
+&& minify_in_situ "src" \
+&& minify_in_situ "test" \
+&& minify_in_situ "tools" \
+&& rm -rf node_modules \
+&& npm_install \
+&& rm -rf lib \
+&& npm run build \
+&& minify_in_situ "lib" \
+&& npm run test:all

test/release/rollup-es.sh

@@ -0,0 +1,91 @@
+#!/bin/sh
+
+alias uglify-js=$PWD/bin/uglifyjs
+UGLIFY_OPTIONS=$@
+
+minify_in_situ() {
+    ARGS="$UGLIFY_OPTIONS --validate --in-situ"
+    DIRS="$1"
+    echo '> uglify-js' $DIRS $UGLIFY_OPTIONS
+    for i in `find $DIRS -type f -name '*.js'`
+    do
+        ARGS="$ARGS $i"
+    done
+    uglify-js $ARGS
+}
+
+npm_install() {
+    PKG="$1"
+    while !(npm install $PKG); do
+        while !(npm cache clean --force); do echo "'npm cache clean' failed - retrying..."; done
+    done
+}
+
+rm -rf tmp/rollup \
+&& git clone https://github.com/rollup/rollup.git tmp/rollup \
+&& cd tmp/rollup \
+&& rm -rf .git/hooks \
+&& git checkout 3d80c06f895eab41e648ee99786fa68c72458b80 \
+&& patch -l -p1 <<EOF
+--- a/package.json
++++ b/package.json
+@@ -23 +22,0 @@
+-    "prepublishOnly": "npm run lint && npm run test:only && npm run test:leak",
+--- a/rollup.config.js
++++ b/rollup.config.js
+@@ -1,5 +1,4 @@
+ import { readFileSync } from 'fs';
+-import buble from 'rollup-plugin-buble';
+ import resolve from 'rollup-plugin-node-resolve';
+ import commonjs from 'rollup-plugin-commonjs';
+ import json from 'rollup-plugin-json';
+@@ -25,12 +24,6 @@ export default [
+         input: 'src/node-entry.js',
+         plugins: [
+             json(),
+-            buble({
+-                include: ['src/**', 'node_modules/acorn/**'],
+-                target: {
+-                    node: '4'
+-                }
+-            }),
+             resolve(),
+             commonjs()
+         ],
+@@ -48,12 +41,6 @@ export default [
+         input: 'src/browser-entry.js',
+         plugins: [
+             json(),
+-            buble({
+-                include: ['src/**', 'node_modules/acorn/**'],
+-                target: {
+-                    node: '4'
+-                }
+-            }),
+             resolve(),
+             commonjs(),
+             {
+@@ -80,7 +67,6 @@ export default [
+         plugins: [
+             string({ include: '**/*.md' }),
+             json(),
+-            buble({ target: { node: 4 } }),
+             commonjs({
+                 include: 'node_modules/**'
+             }),
+--- a/test/mocha.opts
++++ b/test/mocha.opts
+@@ -1,2 +1 @@
+---require buble/register
+ test/test.js
+EOF
+ERR=$?; if [ "$ERR" != "0" ]; then echo "Error: $ERR"; exit $ERR; fi
+minify_in_situ "bin" \
+&& minify_in_situ "browser" \
+&& minify_in_situ "src" \
+&& rm -rf node_modules \
+&& npm_install \
+&& rm -rf dist \
+&& npm run build \
+&& minify_in_situ "dist" \
+&& node_modules/.bin/mocha

test/release/rollup-ts.sh

@@ -0,0 +1,63 @@
+#!/bin/sh
+
+alias uglify-js=$PWD/bin/uglifyjs
+UGLIFY_OPTIONS=$@
+
+minify_in_situ() {
+    ARGS="$UGLIFY_OPTIONS --validate --in-situ"
+    DIRS="$1"
+    echo '> esbuild' $DIRS
+    for i in `find $DIRS -type f -name '*.ts' | grep -v '\.d\.ts'`
+    do
+        echo "$i"
+        CODE=`cat "$i"`
+        node_modules/.bin/esbuild --loader=ts --target=esnext > "$i" <<EOF
+$CODE
+EOF
+        ARGS="$ARGS $i"
+    done
+    echo '> uglify-js' $DIRS $UGLIFY_OPTIONS
+    for i in `find $DIRS -type f -name '*.js'`
+    do
+        ARGS="$ARGS $i"
+    done
+    uglify-js $ARGS
+}
+
+npm_install() {
+    PKG="$1"
+    while !(npm install $PKG); do
+        while !(npm cache clean --force); do echo "'npm cache clean' failed - retrying..."; done
+    done
+}
+
+rm -rf tmp/rollup \
+&& git clone --depth 1 --branch v2.39.1 https://github.com/rollup/rollup.git tmp/rollup \
+&& cd tmp/rollup \
+&& rm -rf .git/hooks \
+&& patch -l -p1 <<EOF
+--- a/package.json
++++ b/package.json
+@@ -27,4 +26,0 @@
+-    "postinstall": "husky install",
+-    "postpublish": "pinst --enable",
+-    "prepare": "npm run build",
+-    "prepublishOnly": "pinst --disable && npm ci && npm run lint:nofix && npm run security && npm run build:bootstrap && npm run test:all",
+--- a/test/cli/index.js
++++ b/test/cli/index.js
+@@ -13,0 +14,3 @@ sander.rimrafSync(__dirname, 'node_modules');
++sander.rimrafSync(__dirname, 'samples', 'watch', 'bundle-error');
++sander.rimrafSync(__dirname, 'samples', 'watch', 'watch-config-error');
++sander.rimrafSync(__dirname, 'samples', 'watch', 'watch-config-initial-error');
+EOF
+ERR=$?; if [ "$ERR" != "0" ]; then echo "Error: $ERR"; exit $ERR; fi
+npm_install esbuild-wasm@0.8.56 \
+&& minify_in_situ "cli" \
+&& minify_in_situ "src" \
+&& rm -rf node_modules \
+&& npm_install \
+&& rm -rf dist \
+&& npm run build \
+&& minify_in_situ "dist" \
+&& node_modules/.bin/mocha test/test.js \
+&& node_modules/.bin/mocha test/browser/index.js