v3.13.2

fixes #4809

.github/ISSUE_TEMPLATE.md

@@ -1,25 +0,0 @@
-**Bug report or feature request?**
-
-<!-- Note: sub-optimal but correct code is not a bug -->
-
-**Uglify version (`uglifyjs -V`)**
-
-**JavaScript input**
-
-<!--
-    A complete parsable JS program exhibiting the issue with
-    UglifyJS alone - without third party tools or libraries.
-    Ideally the input should be as small as possible.
-    Post a link to a gist if necessary.
-
-    Issues without a reproducible test case will be closed.
--->
-
-**The `uglifyjs` CLI command executed or `minify()` options used.**
-
-**JavaScript output or error produced.**
-
-<!--
-    Note: `uglify-js` only supports JavaScript.
-    Those wishing to minify ES6+ should transpile first.
--->

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,51 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!-- Note: sub-optimal but correct code is not a bug -->
+
+**Uglify version (`uglifyjs -V`)**
+
+**JavaScript input**
+
+<!--
+A complete parsable JS program exhibiting the issue with UglifyJS alone
+- without third party tools or libraries.
+
+Ideally the input should be as small as possible, but may be large if isolating
+the problem proves to be difficult. The most important thing is that the
+standalone program reliably exhibits the bug when minified. Provide a link to a
+gist if necessary.
+
+Solely providing minified output without the original uglify JS input is not
+useful in determining the cause of the problem. Issues without a reproducible
+test case will be closed.
+-->
+
+**The `uglifyjs` CLI command executed or `minify()` options used.**
+
+<!--
+Command-line or API call to UglifyJS without third party tools or libraries.
+
+For users using bundlers or transpilers, you may be able to gather the required
+information through setting the `UGLIFY_BUG_REPORT` environment variable:
+
+    export UGLIFY_BUG_REPORT=1      (bash)
+    set UGLIFY_BUG_REPORT=1         (Command Prompt)
+    $Env:UGLIFY_BUG_REPORT=1        (PowerShell)
+
+before running your usual build process. The resulting "minified" output should
+contain the necessary details for this report.
+-->
+
+**JavaScript output or error produced.**
+
+<!--
+Only minified code that produces different output (or error) from the original
+upon execution would be considered a bug.
+-->

.github/workflows/build.yml

@@ -0,0 +1,53 @@
+name: Build testing
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+jobs:
+  ufuzz:
+    strategy:
+      fail-fast: false
+      matrix:
+        options: [ '-mb braces', '--ie8 -c', '-mc', '--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

@@ -0,0 +1,33 @@
+name: CI
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+jobs:
+  test:
+    strategy:
+      matrix:
+        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:
+          - node: '0.8'
+            script: release/benchmark
+          - node: '0.8'
+            script: release/jetstream
+    name: ${{ matrix.node }} ${{ matrix.os }} ${{ matrix.script }}
+    runs-on: ${{ matrix.os }}
+    env:
+      NODE: ${{ matrix.node }}
+      TYPE: ${{ matrix.script }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: tmp
+          key: tmp ${{ matrix.script }}
+      - name: Perform tests
+        shell: bash
+        run: |
+          . ./test/release/install.sh
+          node test/$TYPE

.github/workflows/ufuzz.yml

@@ -0,0 +1,41 @@
+name: Fuzzing
+on:
+  pull_request:
+  schedule:
+    - cron: '*/5 * * * *'
+env:
+  BASE_URL: https://api.github.com/repos/${{ github.repository }}
+  CAUSE: ${{ github.event_name }}
+  RUN_NUM: ${{ github.run_number }}
+  TOKEN: ${{ github.token }}
+jobs:
+  ufuzz:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - node: latest
+            os: macos-latest
+          - node: '8'
+            os: ubuntu-latest
+          - node: '8'
+            os: ubuntu-latest
+          - node: '8'
+            os: windows-latest
+          - node: '8'
+            os: windows-latest
+    name: ${{ matrix.node }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    env:
+      NODE: ${{ matrix.node }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Perform fuzzing
+        shell: bash
+        run: |
+          . ./test/release/install.sh
+          if [[ $CAUSE == "schedule" ]]; then
+            node test/ufuzz/job $BASE_URL $TOKEN $RUN_NUM
+          else
+            node test/ufuzz/job 5000
+          fi

.travis.yml

@@ -1,34 +0,0 @@
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-    packages:
-      - libstdc++-4.9-dev
-cache:
-  directories: tmp
-language: generic
-matrix:
-  fast_finish: true
-sudo: false
-env:
-  global:
-    - UGLIFYJS_TEST_ALL=1
-  matrix:
-    - NODEJS_VER=node/0.10
-    - NODEJS_VER=node/0.12
-    - NODEJS_VER=node/4
-    - NODEJS_VER=node/6
-    - NODEJS_VER=node/8
-    - NODEJS_VER=node/latest
-before_install:
-  - git clone --branch v1.4.2 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
-  - . ~/.nvs/nvs.sh
-  - nvs --version
-install:
-  - nvs add $NODEJS_VER
-  - nvs use $NODEJS_VER
-  - node --version
-  - npm --version --no-update-notifier
-  - npm install --no-optional --no-save --no-update-notifier
-script:
-  - npm test --no-update-notifier

LICENSE

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

README.md

@@ -4,10 +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/UglifyJS2/tree/v2.x)**.
-- **Documentation for UglifyJS `2.x` releases can be found [here](https://github.com/mishoo/UglifyJS2/tree/v2.x)**.
-- `uglify-js` only supports JavaScript (ECMAScript 5).
-- To minify ECMAScript 2015 or above, 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
 -------
@@ -84,12 +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
@@ -125,14 +130,23 @@ a double dash to prevent input files being used as option arguments:
                                 `includeSources`  Pass this flag if you want to include
                                                   the content of source files in the
                                                   source map as sourcesContent property.
+                                `names` Include symbol names in the source map.
                                 `root`  Path to the original source to be included in
                                         the source map.
                                 `url`  If specified, path to the source map to append in
                                        `//# sourceMappingURL`.
     --timings                   Display operations run time on STDERR.
     --toplevel                  Compress and/or mangle variables in top level scope.
+    --v8                        Support non-standard Chrome & Node.js
+                                Equivalent to setting `v8: true` in `minify()`
+                                for `mangle` and `output` options.
+                                By default UglifyJS will not try to be v8-proof.
     --verbose                   Print diagnostic messages.
     --warn                      Print warning messages.
+    --webkit                    Support non-standard Safari/Webkit.
+                                Equivalent to setting `webkit: true` in `minify()`
+                                for `mangle` and `output` options.
+                                By default UglifyJS will not try to be Safari-proof.
     --wrap <name>               Embed everything in a big function, making the
                                 “exports” and “global” variables available. You
                                 need to pass an argument to this option to
@@ -158,6 +172,9 @@ Additional options:
 
 - `--source-map "root='<URL>'"` to pass the URL where the original files can be found.
 
+- `--source-map "names=false"` to omit symbol names if you want to reduce size
+  of the source map file.
+
 - `--source-map "url='<URL>'"` to specify the URL where the source map can be found.
   Otherwise UglifyJS assumes HTTP `X-SourceMap` is being used and will omit the
   `//# sourceMappingURL=` directive.
@@ -207,17 +224,16 @@ Example:
 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:
 
-- `toplevel` (default `false`) -- mangle names declared in the top level scope.
+- `eval` (default: `false`) — mangle names visible in scopes where `eval` or
+  `with` are used.
 
-- `eval` (default `false`) -- mangle names visible in scopes where `eval` or `with` are used.
+- `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:
 
-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:
+      uglifyjs ... -m reserved=['$','require','exports']
 
-    uglifyjs ... -m reserved=['$','require','exports']
-
-to prevent the `require`, `exports` and `$` names from being changed.
+  to prevent the `require`, `exports` and `$` names from being changed.
 
 ### CLI mangling property names (`--mangle-props`)
 
@@ -478,42 +494,52 @@ if (result.error) throw result.error;
 
 ## Minify options
 
-- `warnings` (default `false`) — pass `true` to return compressor warnings
-  in `result.warnings`. Use the value `"verbose"` for more detailed warnings.
+- `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.
 
-- `parse` (default `{}`) — pass an object if you wish to specify some
-  additional [parse options](#parse-options).
-
-- `compress` (default `{}`) — pass `false` to skip compressing entirely.
+- `compress` (default: `{}`) — pass `false` to skip compressing entirely.
   Pass an object to specify custom [compress options](#compress-options).
 
-- `mangle` (default `true`) — pass `false` to skip mangling names, or pass
+- `ie8` (default: `false`) — set to `true` to support IE8.
+
+- `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
   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).
 
-- `output` (default `null`) — pass an object if you wish to specify
-  additional [output options](#output-options).  The defaults are optimized
-  for best compression.
-
-- `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
-  variable and function name mangling and to drop unused variables and functions.
-
-- `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.
 
-- `ie8` (default `false`) - set to `true` to support IE8.
+- `output` (default: `null`) — pass an object if you wish to specify
+  additional [output options](#output-options).  The defaults are optimized
+  for best compression.
 
-- `keep_fnames` (default: `false`) - pass `true` to prevent discarding or mangling
-  of function names.  Useful for code relying on `Function.prototype.name`.
+- `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
+  [source map options](#source-map-options).
+
+- `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.
+
+- `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.
+  PhantomJS users should set this option to `true`.
 
 ## Minify options structure
 
@@ -592,98 +618,126 @@ var result = UglifyJS.minify({"compiled.js": "compiled code"}, {
 
 If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.url`.
 
+If you wish to reduce file size of the source map, set option `sourceMap.names`
+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.
 
-- `booleans` (default: `true`) -- various optimizations for boolean context,
+- `arrows` (default: `true`) — apply optimizations to arrow functions
+
+- `assignments` (default: `true`) — apply optimizations to assignment expressions
+
+- `awaits` (default: `true`) — apply optimizations to `await` expressions
+
+- `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
 
-- `directives` (default: `true`) -- remove redundant or non-standard directives
+- `default_values` (default: `true`) — drop overshadowed default values
 
-- `drop_console` (default: `false`) -- Pass `true` to discard calls to
+- `directives` (default: `true`) — remove redundant or non-standard directives
+
+- `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`) -- attempt to evaluate constant expressions
+- `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.
 
-- `global_defs` (default: `{}`) -- see [conditional compilation](#conditional-compilation)
+- `functions` (default: `true`) — convert declarations from `var` to `function`
+  whenever possible.
 
-- `hoist_funs` (default: `false`) -- hoist function declarations
+- `global_defs` (default: `{}`) — see [conditional compilation](#conditional-compilation)
 
-- `hoist_props` (default: `true`) -- hoist properties from constant object and
+- `hoist_exports` (default: `true`) — hoist `export` statements to facilitate
+  various `compress` and `mangle` optimizations.
+
+- `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 `mangle` enabled, the `compress` option `passes` set to `2` or higher,
-  and the `compress` option `toplevel` enabled.
+  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: `true`) -- Prevents the compressor from discarding unused
-  function arguments.  You need this for code which relies on `Function.length`.
+- `join_vars` (default: `true`) — join consecutive `var` statements
 
-- `keep_fnames` (default: `false`) -- Pass `true` to prevent the
-  compressor from discarding function names.  Useful for code relying on
-  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
+- `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.
 
-- `negate_iife` (default: `true`) -- negate "Immediately-Called Function Expressions"
+- `merge_vars` (default: `true`) — combine and reuse variables.
+
+- `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.
 
-- `passes` (default: `1`) -- The maximum number of times to run compress.
+- `objects` (default: `true`) — compact duplicate keys in object literals.
+
+- `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
@@ -695,22 +749,24 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
   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.
 
-- `sequences` (default: `true`) -- join consecutive simple statements using the
+- `rests` (default: `true`) — apply optimizations to rest parameters
+
+- `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`
@@ -719,65 +775,68 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
   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.
 
-- `switches` (default: `true`) -- de-duplicate and remove unreachable `switch` branches
+- `spreads` (default: `true`) — flatten spread expressions.
 
-- `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)
+- `strings` (default: `true`) — compact string concatenations.
 
-- `top_retain` (default: `null`) -- prevent specific toplevel functions and
+- `switches` (default: `true`) — de-duplicate and remove unreachable `switch` branches
+
+- `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`)
 
-- `typeofs` (default: `true`) -- Transforms `typeof foo == "undefined"` into
+- `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
   `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"`)
 
-- `warnings` (default: `false`) -- display warnings when dropping unreachable
-  code or unused declarations etc.
+- `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.
 
-- `keep_fnames` (default `false`) -- Pass `true` to not mangle function names.
-  Useful for code relying on `Function.prototype.name`. See also: the `keep_fnames`
-  [compress option](#compress-options).
-
-- `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:
@@ -804,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
@@ -824,72 +883,81 @@ 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, `"some"` to preserve some comments, a regular expression string
-  (e.g. `/^!/`) or a function.
+- `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.
+  ```javascript
+  function(node, comment) {
+      return comment.value.indexOf("@type " + node.TYPE) >= 0;
+  }
+  ```
 
-- `indent_level` (default `4`)
+- `galio` (default: `false`) — enable workarounds for ANT Galio bugs
 
-- `indent_start` (default `0`) -- prefix all lines by that many spaces
+- `indent_level` (default: `4`)
 
-- `inline_script` (default `true`) -- escape HTML comments and the slash in
+- `indent_start` (default: `0`) — prefix all lines by that many spaces
+
+- `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)
 
-- `webkit` (default `false`) -- enable workarounds for WebKit bugs.
-  PhantomJS users should set this option to `true`.
-
-- `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/UglifyJS2/issues/640) for more details.
+  [#640](https://github.com/mishoo/UglifyJS/issues/640) for more details.
 
 # Miscellaneous
 
@@ -1048,8 +1116,8 @@ var result = UglifyJS.minify(ast, {
 ### Working with Uglify AST
 
 Transversal and transformation of the native AST can be performed through
-[`TreeWalker`](https://github.com/mishoo/UglifyJS2/blob/master/lib/ast.js) and
-[`TreeTransformer`](https://github.com/mishoo/UglifyJS2/blob/master/lib/transform.js)
+[`TreeWalker`](https://github.com/mishoo/UglifyJS/blob/master/lib/ast.js) and
+[`TreeTransformer`](https://github.com/mishoo/UglifyJS/blob/master/lib/transform.js)
 respectively.
 
 ### ESTree / SpiderMonkey AST
@@ -1088,29 +1156,25 @@ 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:
 ```
 uglifyjs file.js -m
 ```
 To enable fast minify mode with the API use:
-```js
+```javascript
 UglifyJS.minify(code, { compress: false, mangle: true });
 ```
 
-#### Source maps and debugging
+### Source maps and debugging
 
 Various `compress` transforms that simplify, rearrange, inline and remove code
 are known to have an adverse effect on debugging with source maps. This is
@@ -1122,6 +1186,10 @@ disable the Uglify `compress` option and just use `mangle`.
 
 To allow for better optimizations, the compiler makes various assumptions:
 
+- The code does not rely on preserving its runtime performance characteristics.
+  Typically uglified code will run faster due to less instructions and easier
+  inlining, but may be slower on rare occasions for a specific platform, e.g.
+  see [`reduce_funcs`](#compress-options).
 - `.toString()` and `.valueOf()` don't have side effects, and for built-in
   objects they have not been overridden.
 - `undefined`, `NaN` and `Infinity` have not been externally redefined.
@@ -1133,3 +1201,111 @@ To allow for better optimizations, the compiler makes various assumptions:
 - Object properties can be added, removed and modified (not prevented with
   `Object.defineProperty()`, `Object.defineProperties()`, `Object.freeze()`,
   `Object.preventExtensions()` or `Object.seal()`).
+- Earlier versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  ({
+      p: 42,
+      get p() {},
+  });
+  // SyntaxError: Object literal may not have data and accessor property with
+  //              the same name
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Iteration order of keys over an object which contains spread syntax in later
+  versions of Chrome and Node.js may be altered.
+- When `toplevel` is enabled, UglifyJS effectively assumes input code is wrapped
+  within `function(){ ... }`, thus forbids aliasing of declared global variables:
+  ```javascript
+  A = "FAIL";
+  var B = "FAIL";
+  // can be `global`, `self`, `window` etc.
+  var top = function() {
+      return this;
+  }();
+  // "PASS"
+  top.A = "PASS";
+  console.log(A);
+  // "FAIL" after compress and/or mangle
+  top.B = "PASS";
+  console.log(B);
+  ```
+- Use of `arguments` alongside destructuring as function parameters, e.g.
+  `function({}, arguments) {}` will result in `SyntaxError` in earlier versions
+  of Chrome and Node.js - UglifyJS may modify the input which in turn may
+  suppress those errors.
+- Earlier versions of Chrome and Node.js will throw `ReferenceError` with the
+  following:
+  ```javascript
+  var a;
+  try {
+      throw 42;
+  } catch ({
+      [a]: b,
+      // ReferenceError: a is not defined
+  }) {
+      let a;
+  }
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  a => {
+      let a;
+  };
+  // SyntaxError: Identifier 'a' has already been declared
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  try {
+      // ...
+  } catch ({ message: a }) {
+      var a;
+  }
+  // SyntaxError: Identifier 'a' has already been declared
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of Chrome and Node.js will throw `ReferenceError` with the
+  following:
+  ```javascript
+  console.log(((a, b = function() {
+      return a;
+      // ReferenceError: a is not defined
+  }()) => 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.

appveyor.yml

@@ -1,25 +0,0 @@
-environment:
-  UGLIFYJS_TEST_ALL: 1
-  matrix:
-    - NODEJS_VER: node/0.10
-    - NODEJS_VER: node/0.12
-    - NODEJS_VER: node/4
-    - NODEJS_VER: node/6
-    - NODEJS_VER: node/8
-    - NODEJS_VER: node/latest
-install:
-  - git clone --branch v1.4.2 --depth 1 https://github.com/jasongin/nvs.git %LOCALAPPDATA%\nvs
-  - set PATH=%LOCALAPPDATA%\nvs;%PATH%
-  - nvs --version
-  - nvs add %NODEJS_VER%
-  - nvs use %NODEJS_VER%
-  - node --version
-  - npm --version --no-update-notifier
-  - npm install --no-optional --no-save --no-update-notifier
-build: off
-cache:
-  - tmp
-matrix:
-  fast_finish: true
-test_script:
-  - npm test --no-update-notifier

bin/uglifyjs

@@ -3,168 +3,294 @@
 
 "use strict";
 
-require("../tools/exit");
+require("../tools/tty");
 
 var fs = require("fs");
 var info = require("../package.json");
 var path = require("path");
-var program = require("commander");
 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 = {
-    compress: false,
-    mangle: false
+var options = {};
+var short_forms = {
+    b: "beautify",
+    c: "compress",
+    d: "define",
+    e: "enclose",
+    h: "help",
+    m: "mangle",
+    o: "output",
+    O: "output-opts",
+    p: "parse",
+    v: "version",
+    V: "version",
 };
-program.version(info.name + " " + info.version);
-program.parseArgv = program.parse;
-program.parse = undefined;
-if (process.argv.indexOf("ast") >= 0) program.helpInformation = UglifyJS.describe_ast;
-else if (process.argv.indexOf("options") >= 0) program.helpInformation = function() {
-    var text = [];
-    var options = UglifyJS.default_options();
-    for (var option in options) {
-        text.push("--" + (option == "output" ? "beautify" : option == "sourceMap" ? "source-map" : option) + " options:");
-        text.push(format_object(options[option]));
-        text.push("");
-    }
-    return text.join("\n");
-};
-program.option("-p, --parse <options>", "Specify parser options.", parse_js());
-program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js());
-program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js());
-program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js());
-program.option("-b, --beautify [options]", "Beautify output/specify output options.", parse_js());
-program.option("-o, --output <file>", "Output file (default STDOUT).");
-program.option("--comments [filter]", "Preserve copyright comments in the output.");
-program.option("--config-file <file>", "Read minify() options from JSON file.");
-program.option("-d, --define <expr>[=value]", "Global definitions.", parse_js("define"));
-program.option("-e, --enclose [arg[,...][:value[,...]]]", "Embed everything in a big function, with configurable argument(s) & value(s).");
-program.option("--ie8", "Support non-standard Internet Explorer 8.");
-program.option("--keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.");
-program.option("--name-cache <file>", "File to hold mangled name mappings.");
-program.option("--rename", "Force symbol expansion.");
-program.option("--no-rename", "Disable symbol expansion.");
-program.option("--self", "Build UglifyJS as a library (implies --wrap UglifyJS)");
-program.option("--source-map [options]", "Enable source map/specify source map options.", parse_js());
-program.option("--timings", "Display operations run time on STDERR.");
-program.option("--toplevel", "Compress and/or mangle variables in toplevel scope.");
-program.option("--verbose", "Print diagnostic messages.");
-program.option("--warn", "Print warning messages.");
-program.option("--wrap <name>", "Embed everything as a function with “exports” corresponding to “name” globally.");
-program.arguments("[files...]").parseArgv(process.argv);
-if (program.configFile) {
-    options = JSON.parse(read_file(program.configFile));
+var args = process.argv.slice(2);
+var paths = [];
+var output, nameCache;
+var specified = {};
+while (args.length) {
+    var arg = args.shift();
+    if (arg[0] != "-") {
+        paths.push(arg);
+    } else if (arg == "--") {
+        paths = paths.concat(args);
+        break;
+    } else if (arg[1] == "-") {
+        process_option(arg.slice(2));
+    } else [].forEach.call(arg.slice(1), function(letter, index, arg) {
+        if (!(letter in short_forms)) fatal("invalid option -" + letter);
+        process_option(short_forms[letter], index + 1 < arg.length);
+    });
 }
-if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
-    fatal("ERROR: cannot write source map to STDOUT");
-}
-[
-    "compress",
-    "enclose",
-    "ie8",
-    "mangle",
-    "sourceMap",
-    "toplevel",
-    "wrap"
-].forEach(function(name) {
-    if (name in program) {
-        options[name] = program[name];
+
+function process_option(name, no_value) {
+    specified[name] = true;
+    switch (name) {
+      case "help":
+        switch (read_value()) {
+          case "ast":
+            print(UglifyJS.describe_ast());
+            break;
+          case "options":
+            var text = [];
+            var toplevels = [];
+            var padding = "";
+            var defaults = UglifyJS.default_options();
+            for (var name in defaults) {
+                var option = defaults[name];
+                if (option && typeof option == "object") {
+                    text.push("--" + ({
+                        output: "beautify",
+                        sourceMap: "source-map",
+                    }[name] || name) + " options:");
+                    text.push(format_object(option));
+                    text.push("");
+                } else {
+                    if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
+                    toplevels.push([ {
+                        keep_fnames: "keep-fnames",
+                        nameCache: "name-cache",
+                    }[name] || name, option ]);
+                }
+            }
+            toplevels.forEach(function(tokens) {
+                text.push("--" + tokens[0] + padding.slice(tokens[0].length - 2) + tokens[1]);
+            });
+            print(text.join("\n"));
+            break;
+          default:
+            print([
+                "Usage: uglifyjs [files...] [options]",
+                "",
+                "Options:",
+                "  -h, --help                               Print usage information.",
+                "                                           `--help options` for details on available options.",
+                "  -v, -V, --version                        Print version number.",
+                "  -p, --parse <options>                    Specify parser options.",
+                "  -c, --compress [options]                 Enable compressor/specify compressor options.",
+                "  -m, --mangle [options]                   Mangle names/specify mangler options.",
+                "  --mangle-props [options]                 Mangle properties/specify mangler options.",
+                "  -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.",
+                "  -e, --enclose [arg[,...][:value[,...]]]  Embed everything in a big function, with configurable argument(s) & value(s).",
+                "  --ie8                                    Support non-standard Internet Explorer 8.",
+                "  --keep-fnames                            Do not mangle/drop function names. Useful for code relying on Function.prototype.name.",
+                "  --name-cache <file>                      File to hold mangled name mappings.",
+                "  --rename                                 Force symbol expansion.",
+                "  --no-rename                              Disable symbol expansion.",
+                "  --self                                   Build UglifyJS as a library (implies --wrap UglifyJS)",
+                "  --source-map [options]                   Enable source map/specify source map options.",
+                "  --timings                                Display operations run time on STDERR.",
+                "  --toplevel                               Compress and/or mangle variables in toplevel scope.",
+                "  --validate                               Perform validation during AST manipulations.",
+                "  --verbose                                Print diagnostic messages.",
+                "  --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"));
+        }
+        process.exit();
+      case "version":
+        print(info.name + " " + info.version);
+        process.exit();
+      case "config-file":
+        var config = JSON.parse(read_file(read_value(true)));
+        if (config.mangle && config.mangle.properties && config.mangle.properties.regex) {
+            config.mangle.properties.regex = UglifyJS.parse(config.mangle.properties.regex, {
+                expression: true,
+            }).value;
+        }
+        for (var key in config) if (!(key in options)) options[key] = config[key];
+        break;
+      case "compress":
+      case "mangle":
+        options[name] = parse_js(read_value(), options[name]);
+        break;
+      case "source-map":
+        options.sourceMap = parse_js(read_value(), options.sourceMap);
+        break;
+      case "enclose":
+        options[name] = read_value();
+        break;
+      case "annotations":
+      case "ie8":
+      case "timings":
+      case "toplevel":
+      case "validate":
+      case "webkit":
+        options[name] = true;
+        break;
+      case "no-annotations":
+        options.annotations = false;
+        break;
+      case "keep-fnames":
+        options.keep_fnames = true;
+        break;
+      case "wrap":
+        options[name] = read_value(true);
+        break;
+      case "verbose":
+        options.warnings = "verbose";
+        break;
+      case "warn":
+        if (!options.warnings) options.warnings = true;
+        break;
+      case "beautify":
+        options.output = parse_js(read_value(), options.output);
+        if (!("beautify" in options.output)) options.output.beautify = true;
+        break;
+      case "output-opts":
+        options.output = parse_js(read_value(true), options.output);
+        break;
+      case "comments":
+        if (typeof options.output != "object") options.output = {};
+        options.output.comments = read_value();
+        if (options.output.comments === true) options.output.comments = "some";
+        break;
+      case "define":
+        if (typeof options.compress != "object") options.compress = {};
+        options.compress.global_defs = parse_js(read_value(true), options.compress.global_defs, "define");
+        break;
+      case "mangle-props":
+        if (typeof options.mangle != "object") options.mangle = {};
+        options.mangle.properties = parse_js(read_value(), options.mangle.properties);
+        break;
+      case "name-cache":
+        nameCache = read_value(true);
+        options.nameCache = JSON.parse(read_file(nameCache, "{}"));
+        break;
+      case "output":
+        output = read_value(true);
+        break;
+      case "parse":
+        options.parse = parse_js(read_value(true), options.parse);
+        break;
+      case "rename":
+        options.rename = true;
+        break;
+      case "no-rename":
+        options.rename = false;
+        break;
+      case "in-situ":
+      case "reduce-test":
+      case "self":
+        break;
+      default:
+        fatal("invalid option --" + name);
     }
+
+    function read_value(required) {
+        if (no_value || !args.length || args[0][0] == "-") {
+            if (required) fatal("missing option argument for --" + name);
+            return true;
+        }
+        return args.shift();
+    }
+}
+if (!output && options.sourceMap && options.sourceMap.url != "inline") fatal("cannot write source map to STDOUT");
+if (specified["beautify"] && specified["output-opts"]) fatal("--beautify cannot be used with --output-opts");
+[ "compress", "mangle" ].forEach(function(name) {
+    if (!(name in options)) options[name] = false;
 });
-if (program.beautify) {
-    options.output = typeof program.beautify == "object" ? program.beautify : {};
-    if (!("beautify" in options.output)) {
-        options.output.beautify = true;
-    }
-}
-if (program.comments) {
-    if (typeof options.output != "object") options.output = {};
-    options.output.comments = typeof program.comments == "string" ? program.comments : "some";
-}
-if (program.define) {
-    if (typeof options.compress != "object") options.compress = {};
-    if (typeof options.compress.global_defs != "object") options.compress.global_defs = {};
-    for (var expr in program.define) {
-        options.compress.global_defs[expr] = program.define[expr];
-    }
-}
-if (program.keepFnames) {
-    options.keep_fnames = true;
-}
-if (program.mangleProps) {
-    if (program.mangleProps.domprops) {
-        delete program.mangleProps.domprops;
+if (options.mangle && options.mangle.properties) {
+    if (options.mangle.properties.domprops) {
+        delete options.mangle.properties.domprops;
     } else {
-        if (typeof program.mangleProps != "object") program.mangleProps = {};
-        if (!Array.isArray(program.mangleProps.reserved)) program.mangleProps.reserved = [];
+        if (typeof options.mangle.properties != "object") options.mangle.properties = {};
+        if (!Array.isArray(options.mangle.properties.reserved)) options.mangle.properties.reserved = [];
         require("../tools/domprops").forEach(function(name) {
-            UglifyJS.push_uniq(program.mangleProps.reserved, name);
+            UglifyJS.push_uniq(options.mangle.properties.reserved, name);
         });
     }
-    if (typeof options.mangle != "object") options.mangle = {};
-    options.mangle.properties = program.mangleProps;
 }
-if (program.nameCache) {
-    options.nameCache = JSON.parse(read_file(program.nameCache, "{}"));
+if (output == "ast") options.output = {
+    ast: true,
+    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");
 }
-if (program.output == "ast") {
-    options.output = {
-        ast: true,
-        code: false
-    };
-}
-if (program.parse) {
-    if (!program.parse.acorn && !program.parse.spidermonkey) {
-        options.parse = program.parse;
-    } else if (program.sourceMap && program.sourceMap.content == "inline") {
-        fatal("ERROR: inline source map only works with built-in parser");
-    }
-}
-if (~program.rawArgs.indexOf("--rename")) {
-    options.rename = true;
-} else if (!program.rename) {
-    options.rename = false;
+if (options.warnings) {
+    UglifyJS.AST_Node.log_function(print_error, options.warnings == "verbose");
+    delete options.warnings;
 }
 var convert_path = function(name) {
     return name;
 };
-if (typeof program.sourceMap == "object" && "base" in program.sourceMap) {
+if (typeof options.sourceMap == "object" && "base" in options.sourceMap) {
     convert_path = function() {
-        var base = program.sourceMap.base;
+        var base = options.sourceMap.base;
         delete options.sourceMap.base;
         return function(name) {
             return path.relative(base, name);
         };
     }();
 }
-if (program.verbose) {
-    options.warnings = "verbose";
-} else if (program.warn) {
-    options.warnings = true;
-}
-if (program.self) {
-    if (program.args.length) {
-        print_error("WARN: Ignoring input files since --self was passed");
-    }
+if (specified["self"]) {
+    if (paths.length) UglifyJS.AST_Node.warn("Ignoring input files since --self was passed");
     if (!options.wrap) options.wrap = "UglifyJS";
-    simple_glob(UglifyJS.FILES).forEach(function(name) {
+    paths = UglifyJS.FILES;
+}
+if (specified["in-situ"]) {
+    if (output || 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();
     });
-    run();
-} else if (program.args.length) {
-    simple_glob(program.args).forEach(function(name) {
+} 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 = [ chunks.join("") ];
+        files = { STDIN: chunks.join("") };
         run();
     });
     process.stdin.resume();
@@ -175,18 +301,16 @@ function convert_ast(fn) {
 }
 
 function run() {
-    UglifyJS.AST_Node.warn_function = function(msg) {
-        print_error("WARN: " + msg);
-    };
-    var content = program.sourceMap && program.sourceMap.content;
+    var content = options.sourceMap && options.sourceMap.content;
     if (content && content != "inline") {
-        print_error("INFO: Using input source map: " + content);
+        UglifyJS.AST_Node.info("Using input source map: {content}", {
+            content : content,
+        });
         options.sourceMap.content = read_file(content, content);
     }
-    if (program.timings) options.timings = true;
     try {
-        if (program.parse) {
-            if (program.parse.acorn) {
+        if (options.parse) {
+            if (options.parse.acorn) {
                 files = convert_ast(function(toplevel, name) {
                     return require("acorn").parse(files[name], {
                         locations: true,
@@ -194,7 +318,7 @@ function run() {
                         sourceFile: name
                     });
                 });
-            } else if (program.parse.spidermonkey) {
+            } else if (options.parse.spidermonkey) {
                 files = convert_ast(function(toplevel, name) {
                     var obj = JSON.parse(files[name]);
                     if (!toplevel) return obj;
@@ -206,47 +330,69 @@ function run() {
     } catch (ex) {
         fatal(ex);
     }
-    var result = UglifyJS.minify(files, options);
+    var result;
+    if (specified["reduce-test"]) {
+        // load on demand - assumes cloned repository
+        var reduce_test = require("../test/reduce");
+        if (Object.keys(files).length != 1) fatal("can only test on a single file");
+        result = reduce_test(files[Object.keys(files)[0]], options, {
+            log: print_error,
+            verbose: true,
+        });
+    } else {
+        result = UglifyJS.minify(files, options);
+    }
     if (result.error) {
         var ex = result.error;
         if (ex.name == "SyntaxError") {
             print_error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
-            var col = ex.col;
-            var lines = files[ex.filename].split(/\r?\n/);
-            var line = lines[ex.line - 1];
-            if (!line && !col) {
-                line = lines[ex.line - 2];
-                col = line.length;
-            }
-            if (line) {
-                var limit = 70;
-                if (col > limit) {
-                    line = line.slice(col - limit);
-                    col = limit;
+            var file = files[ex.filename];
+            if (file) {
+                var col = ex.col;
+                var lines = file.split(/\r?\n/);
+                var line = lines[ex.line - 1];
+                if (!line && !col) {
+                    line = lines[ex.line - 2];
+                    col = line.length;
+                }
+                if (line) {
+                    var limit = 70;
+                    if (col > limit) {
+                        line = line.slice(col - limit);
+                        col = limit;
+                    }
+                    print_error(line.slice(0, 80));
+                    print_error(line.slice(0, col).replace(/\S/g, " ") + "^");
                 }
-                print_error(line.slice(0, 80));
-                print_error(line.slice(0, col).replace(/\S/g, " ") + "^");
             }
-        }
-        if (ex.defs) {
+        } else if (ex.defs) {
             print_error("Supported options:");
             print_error(format_object(ex.defs));
         }
         fatal(ex);
-    } else if (program.output == "ast") {
+    } else if (output == "ast") {
         if (!options.compress && !options.mangle) {
-            result.ast.figure_out_scope({});
+            var toplevel = result.ast;
+            if (!(toplevel instanceof UglifyJS.AST_Toplevel)) {
+                if (!(toplevel instanceof UglifyJS.AST_Statement)) toplevel = new UglifyJS.AST_SimpleStatement({
+                    body: toplevel,
+                });
+                toplevel = new UglifyJS.AST_Toplevel({
+                    body: [ toplevel ],
+                });
+            }
+            toplevel.figure_out_scope({});
         }
         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;
@@ -262,33 +408,33 @@ function run() {
             }
             return value;
         }, 2));
-    } else if (program.output == "spidermonkey") {
+    } 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));
-    } else if (program.output) {
-        fs.writeFileSync(program.output, result.code);
-        if (result.map) {
-            fs.writeFileSync(program.output + ".map", result.map);
-        }
+    } else if (output) {
+        fs.writeFileSync(output, result.code);
+        if (result.map) fs.writeFileSync(output + ".map", result.map);
     } else {
         print(result.code);
     }
-    if (program.nameCache) {
-        fs.writeFileSync(program.nameCache, JSON.stringify(options.nameCache));
-    }
+    if (nameCache) fs.writeFileSync(nameCache, JSON.stringify(options.nameCache));
     if (result.timings) for (var phase in result.timings) {
         print_error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
     }
 }
 
 function fatal(message) {
-    if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:")
+    if (message instanceof Error) {
+        message = message.stack.replace(/^\S*?Error:/, "ERROR:")
+    } else {
+        message = "ERROR: " + message;
+    }
     print_error(message);
     process.exit(1);
 }
@@ -313,7 +459,7 @@ function simple_glob(glob) {
                 .replace(/\?/g, "[^/\\\\]") + "$";
             var mod = process.platform === "win32" ? "i" : "";
             var rx = new RegExp(pattern, mod);
-            var results = entries.filter(function(name) {
+            var results = entries.sort().filter(function(name) {
                 return rx.test(name);
             }).map(function(name) {
                 return path.join(dir, name);
@@ -333,55 +479,45 @@ function read_file(path, default_value) {
     }
 }
 
-function parse_js(flag) {
-    return function(value, options) {
-        options = options || {};
-        try {
-            UglifyJS.minify(value, {
-                parse: {
-                    expression: true
-                },
-                compress: false,
-                mangle: false,
-                output: {
-                    ast: true,
-                    code: false
+function parse_js(value, options, flag) {
+    if (!options || typeof options != "object") options = {};
+    if (typeof value == "string") try {
+        UglifyJS.parse(value, {
+            expression: true
+        }).walk(new UglifyJS.TreeWalker(function(node) {
+            if (node instanceof UglifyJS.AST_Assign) {
+                var name = node.left.print_to_string();
+                var value = node.right;
+                if (flag) {
+                    options[name] = value;
+                } else if (value instanceof UglifyJS.AST_Array) {
+                    options[name] = value.elements.map(to_string);
+                } else {
+                    options[name] = to_string(value);
                 }
-            }).ast.walk(new UglifyJS.TreeWalker(function(node) {
-                if (node instanceof UglifyJS.AST_Assign) {
-                    var name = node.left.print_to_string();
-                    var value = node.right;
-                    if (flag) {
-                        options[name] = value;
-                    } else if (value instanceof UglifyJS.AST_Array) {
-                        options[name] = value.elements.map(to_string);
-                    } else {
-                        options[name] = to_string(value);
-                    }
-                    return true;
-                }
-                if (node instanceof UglifyJS.AST_Symbol || node instanceof UglifyJS.AST_PropAccess) {
-                    var name = node.print_to_string();
-                    options[name] = true;
-                    return true;
-                }
-                if (!(node instanceof UglifyJS.AST_Sequence)) throw node;
-
-                function to_string(value) {
-                    return value instanceof UglifyJS.AST_Constant ? value.getValue() : value.print_to_string({
-                        quote_keys: true
-                    });
-                }
-            }));
-        } catch(ex) {
-            if (flag) {
-                fatal("Error parsing arguments for '" + flag + "': " + value);
-            } else {
-                options[value] = null;
+                return true;
             }
+            if (node instanceof UglifyJS.AST_Symbol || node instanceof UglifyJS.AST_PropAccess) {
+                var name = node.print_to_string();
+                options[name] = true;
+                return true;
+            }
+            if (!(node instanceof UglifyJS.AST_Sequence)) throw node;
+
+            function to_string(value) {
+                return value instanceof UglifyJS.AST_Constant ? value.value : value.print_to_string({
+                    quote_keys: true
+                });
+            }
+        }));
+    } catch (ex) {
+        if (flag) {
+            fatal("cannot parse arguments for '" + flag + "': " + value);
+        } else {
+            options[value] = null;
         }
-        return options;
     }
+    return options;
 }
 
 function skip_key(key) {

lib/minify.js

@@ -1,19 +1,41 @@
 "use strict";
 
-var to_ascii = typeof atob == "undefined" ? function(b64) {
-    return new Buffer(b64, "base64").toString();
-} : atob;
-var to_base64 = typeof btoa == "undefined" ? function(str) {
-    return new Buffer(str).toString("base64");
-} : btoa;
+var to_ascii, to_base64;
+if (typeof Buffer == "undefined") {
+    to_ascii = atob;
+    to_base64 = btoa;
+} else if (typeof Buffer.alloc == "undefined") {
+    to_ascii = function(b64) {
+        return new Buffer(b64, "base64").toString();
+    };
+    to_base64 = function(str) {
+        return new Buffer(str).toString("base64");
+    };
+} else {
+    to_ascii = function(b64) {
+        return Buffer.from(b64, "base64").toString();
+    };
+    to_base64 = function(str) {
+        return Buffer.from(str).toString("base64");
+    };
+}
 
-function read_source_map(name, code) {
-    var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code);
-    if (!match) {
-        AST_Node.warn("inline source map not found: " + name);
-        return null;
+function read_source_map(name, toplevel) {
+    var comments = toplevel.end.comments_after;
+    for (var i = comments.length; --i >= 0;) {
+        var comment = comments[i];
+        if (comment.type != "comment1") break;
+        var match = /^# ([^\s=]+)=(\S+)\s*$/.exec(comment.value);
+        if (!match) break;
+        if (match[1] == "sourceMappingURL") {
+            match = /^data:application\/json(;.*?)?;base64,(\S+)$/.exec(match[2]);
+            if (!match) break;
+            return to_ascii(match[2]);
+        }
     }
-    return to_ascii(match[2]);
+    AST_Node.warn("inline source map not found: {name}", {
+        name: name,
+    });
 }
 
 function parse_source_map(content) {
@@ -25,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) {
@@ -51,9 +71,9 @@ function to_json(cache) {
 }
 
 function minify(files, options) {
-    var warn_function = AST_Node.warn_function;
     try {
         options = defaults(options, {
+            annotations: undefined,
             compress: {},
             enclose: false,
             ie8: false,
@@ -66,19 +86,21 @@ function minify(files, options) {
             sourceMap: false,
             timings: false,
             toplevel: false,
+            v8: false,
+            validate: false,
             warnings: false,
+            webkit: false,
             wrap: false,
         }, true);
-        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("warnings", options, [ "compress" ]);
+        if (options.validate) AST_Node.enable_validation();
+        var timings = options.timings && { start: Date.now() };
+        if (options.rename === undefined) options.rename = options.compress && options.mangle;
+        if (options.annotations !== undefined) set_shorthand("annotations", options, [ "compress", "output" ]);
+        if (options.ie8) set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
+        if (options.keep_fnames) set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
+        if (options.toplevel) set_shorthand("toplevel", options, [ "compress", "mangle" ]);
+        if (options.v8) set_shorthand("v8", options, [ "mangle", "output" ]);
+        if (options.webkit) set_shorthand("webkit", options, [ "mangle", "output" ]);
         var quoted_props;
         if (options.mangle) {
             options.mangle = defaults(options.mangle, {
@@ -89,6 +111,8 @@ function minify(files, options) {
                 properties: false,
                 reserved: [],
                 toplevel: false,
+                v8: false,
+                webkit: false,
             }, true);
             if (options.mangle.properties) {
                 if (typeof options.mangle.properties != "object") {
@@ -111,18 +135,17 @@ function minify(files, options) {
                 content: null,
                 filename: null,
                 includeSources: false,
+                names: true,
                 root: null,
                 url: null,
             }, true);
         }
         var warnings = [];
-        if (options.warnings && !AST_Node.warn_function) {
-            AST_Node.warn_function = function(warning) {
-                warnings.push(warning);
-            };
-        }
+        if (options.warnings) AST_Node.log_function(function(warning) {
+            warnings.push(warning);
+        }, options.warnings == "verbose");
         if (timings) timings.parse = Date.now();
-        var source_maps, toplevel;
+        var toplevel;
         if (files instanceof AST_Toplevel) {
             toplevel = files;
         } else {
@@ -135,39 +158,41 @@ function minify(files, options) {
             if (typeof source_map_content == "string" && source_map_content != "inline") {
                 source_map_content = parse_source_map(source_map_content);
             }
-            source_maps = source_map_content && Object.create(null);
+            if (source_map_content) options.sourceMap.orig = Object.create(null);
             for (var name in files) if (HOP(files, name)) {
                 options.parse.filename = name;
-                options.parse.toplevel = parse(files[name], options.parse);
-                if (source_maps) {
-                    if (source_map_content == "inline") {
-                        var inlined_content = read_source_map(name, files[name]);
-                        if (inlined_content) {
-                            source_maps[name] = parse_source_map(inlined_content);
-                        }
-                    } else {
-                        source_maps[name] = source_map_content;
+                options.parse.toplevel = toplevel = parse(files[name], options.parse);
+                if (source_map_content == "inline") {
+                    var inlined_content = read_source_map(name, toplevel);
+                    if (inlined_content) {
+                        options.sourceMap.orig[name] = parse_source_map(inlined_content);
                     }
+                } else if (source_map_content) {
+                    options.sourceMap.orig[name] = source_map_content;
                 }
             }
-            toplevel = options.parse.toplevel;
         }
         if (quoted_props) {
             reserve_quoted_keys(toplevel, quoted_props);
         }
-        if (options.wrap) {
-            toplevel = toplevel.wrap_commonjs(options.wrap);
-        }
-        if (options.enclose) {
-            toplevel = toplevel.wrap_enclose(options.enclose);
-        }
+        [ "enclose", "wrap" ].forEach(function(action) {
+            var option = options[action];
+            if (!option) return;
+            var orig = toplevel.print_to_string().slice(0, -1);
+            toplevel = toplevel[action](option);
+            files[toplevel.start.file] = toplevel.print_to_string().replace(orig, "");
+        });
+        if (options.validate) toplevel.validate_ast();
         if (timings) timings.rename = Date.now();
         if (options.rename) {
             toplevel.figure_out_scope(options.mangle);
             toplevel.expand_names(options.mangle);
         }
         if (timings) timings.compress = Date.now();
-        if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+        if (options.compress) {
+            toplevel = new Compressor(options.compress).compress(toplevel);
+            if (options.validate) toplevel.validate_ast();
+        }
         if (timings) timings.scope = Date.now();
         if (options.mangle) toplevel.figure_out_scope(options.mangle);
         if (timings) timings.mangle = Date.now();
@@ -176,9 +201,7 @@ function minify(files, options) {
             toplevel.mangle_names(options.mangle);
         }
         if (timings) timings.properties = Date.now();
-        if (options.mangle && options.mangle.properties) {
-            toplevel = mangle_properties(toplevel, options.mangle.properties);
-        }
+        if (options.mangle && options.mangle.properties) mangle_properties(toplevel, options.mangle.properties);
         if (timings) timings.output = Date.now();
         var result = {};
         if (options.output.ast) {
@@ -186,19 +209,13 @@ function minify(files, options) {
         }
         if (!HOP(options.output, "code") || options.output.code) {
             if (options.sourceMap) {
-                options.output.source_map = SourceMap({
-                    file: options.sourceMap.filename,
-                    orig: source_maps,
-                    root: options.sourceMap.root
-                });
+                options.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.get().setSourceContent(name, files[name]);
+                        options.output.source_map.setSourceContent(name, files[name]);
                     }
-                } else {
-                    options.output.source_map.get()._sourcesContents = null;
                 }
             }
             delete options.output.ast;
@@ -208,10 +225,14 @@ function minify(files, options) {
             result.code = stream.get();
             if (options.sourceMap) {
                 result.map = options.output.source_map.toString();
-                if (options.sourceMap.url == "inline") {
-                    result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(result.map);
-                } else if (options.sourceMap.url) {
-                    result.code += "\n//# sourceMappingURL=" + options.sourceMap.url;
+                var url = options.sourceMap.url;
+                if (url) {
+                    result.code = result.code.replace(/\n\/\/# sourceMappingURL=\S+\s*$/, "");
+                    if (url == "inline") {
+                        result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(result.map);
+                    } else {
+                        result.code += "\n//# sourceMappingURL=" + url;
+                    }
                 }
             }
         }
@@ -232,7 +253,7 @@ function minify(files, options) {
                 properties: 1e-3 * (timings.output - timings.properties),
                 output: 1e-3 * (timings.end - timings.output),
                 total: 1e-3 * (timings.end - timings.start)
-            }
+            };
         }
         if (warnings.length) {
             result.warnings = warnings;
@@ -241,6 +262,7 @@ function minify(files, options) {
     } catch (ex) {
         return { error: ex };
     } finally {
-        AST_Node.warn_function = warn_function;
+        AST_Node.log_function();
+        AST_Node.disable_validation();
     }
 }

lib/mozilla-ast.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS2
+  https://github.com/mishoo/UglifyJS
 
   -------------------------------- (C) ---------------------------------
 
@@ -111,13 +111,10 @@
             var args = {
                 start    : my_start_token(key),
                 end      : my_end_token(M.value),
-                key      : key.type == "Identifier" ? key.name : key.value,
+                key      : "" + key[key.type == "Identifier" ? "name" : "value"],
                 value    : from_moz(M.value)
             };
             if (M.kind == "init") return new AST_ObjectKeyVal(args);
-            args.key = new AST_SymbolAccessor({
-                name: args.key
-            });
             args.value = new AST_Accessor(args.value);
             if (M.kind == "get") return new AST_ObjectGetter(args);
             if (M.kind == "set") return new AST_ObjectSetter(args);
@@ -212,7 +209,14 @@
                             end   : my_end_token(M),
                             name  : M.name
                         });
-        }
+        },
+        ThisExpression: function(M) {
+            return new AST_This({
+                start : my_start_token(M),
+                end   : my_end_token(M),
+                name  : "this",
+            });
+        },
     };
 
     MOZ_TO_ME.UpdateExpression =
@@ -245,7 +249,6 @@
     map("VariableDeclarator", AST_VarDef, "id>name, init>value");
     map("CatchClause", AST_Catch, "param>argname, body%body");
 
-    map("ThisExpression", AST_This);
     map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right");
     map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right");
     map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
@@ -379,7 +382,7 @@
     def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
         var key = {
             type: "Literal",
-            value: M.key instanceof AST_SymbolAccessor ? M.key.name : M.key
+            value: M.key
         };
         var kind;
         if (M instanceof AST_ObjectKeyVal) {
@@ -403,10 +406,14 @@
         var def = M.definition();
         return {
             type: "Identifier",
-            name: def ? def.mangled_name || def.name : M.name
+            name: def && def.mangled_name || M.name
         };
     });
 
+    def_to_moz(AST_This, function To_Moz_ThisExpression() {
+        return { type: "ThisExpression" };
+    });
+
     def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) {
         var flags = M.value.toString().match(/[gimuy]*$/)[0];
         var value = "/" + M.value.raw_source + "/" + flags;

lib/propmangle.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS2
+  https://github.com/mishoo/UglifyJS
 
   -------------------------------- (C) ---------------------------------
 
@@ -43,7 +43,8 @@
 
 "use strict";
 
-function find_builtins(reserved) {
+var builtins = function() {
+    var names = [];
     // NaN will be included due to Number.NaN
     [
         "null",
@@ -53,46 +54,54 @@ function find_builtins(reserved) {
         "-Infinity",
         "undefined",
     ].forEach(add);
-    [ Object, Array, Function, Number,
-      String, Boolean, Error, Math,
-      Date, RegExp
+    [
+        Array,
+        Boolean,
+        Date,
+        Error,
+        Function,
+        Math,
+        Number,
+        Object,
+        RegExp,
+        String,
     ].forEach(function(ctor) {
         Object.getOwnPropertyNames(ctor).map(add);
         if (ctor.prototype) {
+            Object.getOwnPropertyNames(new ctor()).map(add);
             Object.getOwnPropertyNames(ctor.prototype).map(add);
         }
     });
+    return makePredicate(names);
+
     function add(name) {
-        push_uniq(reserved, name);
+        names.push(name);
     }
-}
+}();
 
 function reserve_quoted_keys(ast, reserved) {
-    function add(name) {
-        push_uniq(reserved, name);
-    }
-
     ast.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_ObjectKeyVal && node.quote) {
-            add(node.key);
+        if (node instanceof AST_ObjectProperty) {
+            if (node.start && node.start.quote) add(node.key);
         } else if (node instanceof AST_Sub) {
             addStrings(node.property, add);
         }
     }));
+
+    function add(name) {
+        push_uniq(reserved, name);
+    }
 }
 
 function addStrings(node, add) {
-    node.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_Sequence) {
-            addStrings(node.tail_node(), add);
-        } else if (node instanceof AST_String) {
-            add(node.value);
-        } else if (node instanceof AST_Conditional) {
-            addStrings(node.consequent, add);
-            addStrings(node.alternative, add);
-        }
-        return true;
-    }));
+    if (node instanceof AST_Conditional) {
+        addStrings(node.consequent, add);
+        addStrings(node.alternative, add);
+    } else if (node instanceof AST_Sequence) {
+        addStrings(node.tail_node(), add);
+    } else if (node instanceof AST_String) {
+        add(node.value);
+    }
 }
 
 function mangle_properties(ast, options) {
@@ -101,21 +110,21 @@ function mangle_properties(ast, options) {
         cache: null,
         debug: false,
         keep_quoted: false,
-        only_cache: false,
         regex: null,
         reserved: null,
     }, true);
 
-    var reserved = options.reserved;
-    if (!Array.isArray(reserved)) reserved = [];
-    if (!options.builtins) find_builtins(reserved);
+    var reserved = Object.create(options.builtins ? null : builtins);
+    if (Array.isArray(options.reserved)) options.reserved.forEach(function(name) {
+        reserved[name] = true;
+    });
 
     var cname = -1;
     var cache;
     if (options.cache) {
         cache = options.cache.props;
-        cache.each(function(mangled_name) {
-            push_uniq(reserved, mangled_name);
+        cache.each(function(name) {
+            reserved[name] = true;
         });
     } else {
         cache = new Dictionary();
@@ -127,126 +136,119 @@ function mangle_properties(ast, options) {
     // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
     // the same as passing an empty string.
     var debug = options.debug !== false;
-    var debug_name_suffix;
-    if (debug) {
-        debug_name_suffix = (options.debug === true ? "" : options.debug);
-    }
+    var debug_suffix;
+    if (debug) debug_suffix = options.debug === true ? "" : options.debug;
 
-    var names_to_mangle = [];
-    var unmangleable = [];
+    var names_to_mangle = Object.create(null);
+    var unmangleable = Object.create(reserved);
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_ObjectKeyVal) {
-            add(node.key);
-        }
-        else if (node instanceof AST_ObjectProperty) {
-            // setter or getter, since KeyVal is handled above
-            add(node.key.name);
-        }
-        else if (node instanceof AST_Dot) {
+        if (node instanceof AST_Binary) {
+            if (node.operator == "in") addStrings(node.left, add);
+        } else if (node.TYPE == "Call") {
+            var exp = node.expression;
+            if (exp instanceof AST_Dot) switch (exp.property) {
+              case "defineProperty":
+              case "getOwnPropertyDescriptor":
+                if (node.args.length < 2) break;
+                exp = exp.expression;
+                if (!(exp instanceof AST_SymbolRef)) break;
+                if (exp.name != "Object") break;
+                if (!exp.definition().undeclared) break;
+                addStrings(node.args[1], add);
+                break;
+              case "hasOwnProperty":
+                if (node.args.length < 1) break;
+                addStrings(node.args[0], add);
+                break;
+            }
+        } else if (node instanceof AST_Dot) {
             add(node.property);
-        }
-        else if (node instanceof AST_Sub) {
+        } else if (node instanceof AST_ObjectProperty) {
+            if (typeof node.key == "string") add(node.key);
+        } else if (node instanceof AST_Sub) {
             addStrings(node.property, add);
         }
-        else if (node instanceof AST_Call
-            && node.expression.print_to_string() == "Object.defineProperty") {
-            addStrings(node.args[1], add);
-        }
     }));
 
-    // step 2: transform the tree, renaming properties
-    return ast.transform(new TreeTransformer(function(node) {
-        if (node instanceof AST_ObjectKeyVal) {
-            node.key = mangle(node.key);
-        }
-        else if (node instanceof AST_ObjectProperty) {
-            // setter or getter
-            node.key.name = mangle(node.key.name);
-        }
-        else if (node instanceof AST_Dot) {
+    // step 2: renaming properties
+    ast.walk(new TreeWalker(function(node) {
+        if (node instanceof AST_Binary) {
+            if (node.operator == "in") mangleStrings(node.left);
+        } else if (node.TYPE == "Call") {
+            var exp = node.expression;
+            if (exp instanceof AST_Dot) switch (exp.property) {
+              case "defineProperty":
+              case "getOwnPropertyDescriptor":
+                if (node.args.length < 2) break;
+                exp = exp.expression;
+                if (!(exp instanceof AST_SymbolRef)) break;
+                if (exp.name != "Object") break;
+                if (!exp.definition().undeclared) break;
+                mangleStrings(node.args[1]);
+                break;
+              case "hasOwnProperty":
+                if (node.args.length < 1) break;
+                mangleStrings(node.args[0]);
+                break;
+            }
+        } else if (node instanceof AST_Dot) {
             node.property = mangle(node.property);
-        }
-        else if (!options.keep_quoted && node instanceof AST_Sub) {
-            node.property = mangleStrings(node.property);
-        }
-        else if (node instanceof AST_Call
-            && node.expression.print_to_string() == "Object.defineProperty") {
-            node.args[1] = mangleStrings(node.args[1]);
+        } else if (node instanceof AST_ObjectProperty) {
+            if (typeof node.key == "string") node.key = mangle(node.key);
+        } else if (node instanceof AST_Sub) {
+            if (!options.keep_quoted) mangleStrings(node.property);
         }
     }));
 
     // only function declarations after this line
 
     function can_mangle(name) {
-        if (unmangleable.indexOf(name) >= 0) return false;
-        if (reserved.indexOf(name) >= 0) return false;
-        if (options.only_cache) {
-            return cache.has(name);
-        }
+        if (unmangleable[name]) return false;
         if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false;
         return true;
     }
 
     function should_mangle(name) {
+        if (reserved[name]) return false;
         if (regex && !regex.test(name)) return false;
-        if (reserved.indexOf(name) >= 0) return false;
-        return cache.has(name)
-            || names_to_mangle.indexOf(name) >= 0;
+        return cache.has(name) || names_to_mangle[name];
     }
 
     function add(name) {
-        if (can_mangle(name))
-            push_uniq(names_to_mangle, name);
-
-        if (!should_mangle(name)) {
-            push_uniq(unmangleable, name);
-        }
+        if (can_mangle(name)) names_to_mangle[name] = true;
+        if (!should_mangle(name)) unmangleable[name] = true;
     }
 
     function mangle(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_.
-                var debug_mangled = "_$" + name + "$" + debug_name_suffix + "_";
-
-                if (can_mangle(debug_mangled)) {
-                    mangled = debug_mangled;
-                }
+                // 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;
             }
-
             // either debug mode is off, or it is on and we could not use the mangled name
-            if (!mangled) {
-                do {
-                    mangled = base54(++cname);
-                } while (!can_mangle(mangled));
-            }
-
+            if (!mangled) do {
+                mangled = base54(++cname);
+            } while (!can_mangle(mangled));
             cache.set(name, mangled);
         }
         return mangled;
     }
 
     function mangleStrings(node) {
-        return node.transform(new TreeTransformer(function(node) {
-            if (node instanceof AST_Sequence) {
-                var last = node.expressions.length - 1;
-                node.expressions[last] = mangleStrings(node.expressions[last]);
-            }
-            else if (node instanceof AST_String) {
-                node.value = mangle(node.value);
-            }
-            else if (node instanceof AST_Conditional) {
-                node.consequent = mangleStrings(node.consequent);
-                node.alternative = mangleStrings(node.alternative);
-            }
-            return node;
-        }));
+        if (node instanceof AST_Sequence) {
+            mangleStrings(node.expressions.tail_node());
+        } else if (node instanceof AST_String) {
+            node.value = mangle(node.value);
+        } else if (node instanceof AST_Conditional) {
+            mangleStrings(node.consequent);
+            mangleStrings(node.alternative);
+        }
     }
 }

lib/scope.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS2
+  https://github.com/mishoo/UglifyJS
 
   -------------------------------- (C) ---------------------------------
 
@@ -43,43 +43,36 @@
 
 "use strict";
 
-function SymbolDef(scope, orig, init) {
+function SymbolDef(id, scope, orig, init) {
+    this.eliminated = 0;
+    this.exported = false;
+    this.global = false;
+    this.id = id;
+    this.init = init;
+    this.mangled_name = null;
     this.name = orig.name;
     this.orig = [ orig ];
-    this.init = init;
-    this.eliminated = 0;
-    this.scope = scope;
     this.references = [];
     this.replaced = 0;
-    this.global = false;
-    this.mangled_name = null;
+    this.scope = scope;
     this.undeclared = false;
-    this.id = SymbolDef.next_id++;
 }
 
-SymbolDef.next_id = 1;
-
 SymbolDef.prototype = {
-    unmangleable: function(options) {
-        if (!options) options = {};
-
-        return this.global && !options.toplevel
-            || this.undeclared
-            || !options.eval && this.scope.pinned()
-            || options.keep_fnames
-                && (this.orig[0] instanceof AST_SymbolLambda
-                    || this.orig[0] instanceof AST_SymbolDefun);
+    forEach: function(fn) {
+        this.orig.forEach(fn);
+        this.references.forEach(fn);
     },
     mangle: function(options) {
         var cache = options.cache && options.cache.props;
         if (this.global && cache && cache.has(this.name)) {
             this.mangled_name = cache.get(this.name);
         } else if (!this.mangled_name && !this.unmangleable(options)) {
-            var def;
-            if (def = this.redefined()) {
+            var def = this.redefined();
+            if (def) {
                 this.mangled_name = def.mangled_name || def.name;
             } else {
-                this.mangled_name = next_mangled_name(this.scope, options, this);
+                this.mangled_name = next_mangled_name(this, options);
             }
             if (this.global && cache) {
                 cache.set(this.name, this.mangled_name);
@@ -87,10 +80,40 @@ SymbolDef.prototype = {
         }
     },
     redefined: function() {
-        return this.defun && this.defun.variables.get(this.name);
-    }
+        var scope = this.defun;
+        if (!scope) return;
+        var name = this.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) {
+                return def.name == name;
+            }, scope.enclosed);
+        if (def && def !== this) return def.redefined() || def;
+    },
+    unmangleable: function(options) {
+        return this.global && !options.toplevel
+            || this.exported
+            || this.undeclared
+            || !options.eval && this.scope.pinned()
+            || options.keep_fnames
+                && (this.orig[0] instanceof AST_SymbolClass
+                    || this.orig[0] instanceof AST_SymbolDefClass
+                    || this.orig[0] instanceof AST_SymbolDefun
+                    || this.orig[0] instanceof AST_SymbolLambda);
+    },
 };
 
+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,
@@ -99,31 +122,71 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
 
     // pass 1: setup scope chaining and handle definitions
     var self = this;
-    var scope = self.parent_scope = null;
     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 (node instanceof AST_Catch) {
-            var save_scope = scope;
-            scope = new AST_Scope(node);
-            scope.init_scope_vars(save_scope);
-            descend();
-            scope = save_scope;
+        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_Scope) {
-            node.init_scope_vars(scope);
-            var save_scope = scope;
-            var save_defun = defun;
-            defun = scope = node;
+        if (node instanceof AST_Definitions) {
+            var save_exported = exported;
+            exported = tw.parent() instanceof AST_ExportDeclaration;
             descend();
-            scope = save_scope;
-            defun = save_defun;
-            return true;        // don't descend again in TreeWalker
+            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);
+                });
+                if (node.rest) node.rest.walk(tw);
+                walk_body(node, tw);
+            });
+            return true;
+        }
+        if (node instanceof AST_SwitchBranch) {
+            node.init_vars(scope);
+            descend();
+            return true;
+        }
+        if (node instanceof AST_Try) {
+            walk_scope(function() {
+                walk_body(node, tw);
+            });
+            if (node.bcatch) node.bcatch.walk(tw);
+            if (node.bfinally) node.bfinally.walk(tw);
+            return true;
         }
         if (node instanceof AST_With) {
-            for (var s = scope; s; s = s.parent_scope)
+            var s = scope;
+            do {
+                s = s.resolve();
+                if (s.uses_with) break;
                 s.uses_with = true;
-            return;
+            } while (s = s.parent_scope);
+            walk_scope(descend);
+            return true;
+        }
+        if (node instanceof AST_BlockScope) {
+            walk_scope(descend);
+            return true;
         }
         if (node instanceof AST_Symbol) {
             node.scope = scope;
@@ -132,88 +195,213 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             node.thedef = node;
             node.references = [];
         }
-        if (node instanceof AST_SymbolDefun || options.ie8 && node instanceof AST_SymbolLambda) {
-            // Careful here, the scope where this should be defined is
-            // the parent scope.  The reason is that we enter a new
-            // scope when we encounter the AST_Defun node (which is
-            // instanceof AST_Scope) but we get to the symbol a bit
-            // later.
-            (node.scope = defun.parent_scope).def_function(node, defun);
-        }
-        else if (node instanceof AST_SymbolLambda) {
-            defun.def_function(node, node.name == "arguments" ? undefined : defun);
-        }
-        else if (node instanceof AST_SymbolVar) {
-            defun.def_variable(node, node.TYPE == "SymbolVar" ? null : undefined);
-            if (defun !== scope) {
-                node.mark_enclosed(options);
-                var def = scope.find_variable(node);
-                if (node.thedef !== def) {
-                    node.thedef = def;
-                }
-                node.reference(options);
-            }
-        }
-        else if (node instanceof AST_SymbolCatch) {
+        if (node instanceof AST_SymbolCatch) {
             scope.def_variable(node).defun = defun;
+        } else if (node instanceof AST_SymbolConst) {
+            var def = scope.def_variable(node);
+            def.defun = defun;
+            if (exported) def.exported = true;
+        } else if (node instanceof AST_SymbolDefun) {
+            var def = defun.def_function(node, tw.parent());
+            if (exported) def.exported = true;
+            entangle(defun, scope);
+        } else if (node instanceof AST_SymbolFunarg) {
+            defun.def_variable(node);
+            entangle(defun, scope);
+        } else if (node instanceof AST_SymbolLambda) {
+            var def = defun.def_function(node, node.name == "arguments" ? undefined : defun);
+            if (options.ie8) def.defun = defun.parent_scope.resolve();
+        } else if (node instanceof AST_SymbolLet) {
+            var def = scope.def_variable(node);
+            if (exported) def.exported = true;
+        } else if (node instanceof AST_SymbolVar) {
+            var def = defun.def_variable(node, node instanceof AST_SymbolImport ? undefined : null);
+            if (exported) def.exported = true;
+            entangle(defun, scope);
+        }
+
+        function walk_scope(descend) {
+            node.init_vars(scope);
+            var save_defun = defun;
+            var save_scope = scope;
+            if (node instanceof AST_Scope) defun = node;
+            scope = node;
+            descend();
+            scope = save_scope;
+            defun = save_defun;
+        }
+
+        function entangle(defun, scope) {
+            if (defun === scope) return;
+            node.mark_enclosed(options);
+            var def = scope.find_variable(node.name);
+            if (node.thedef === def) return;
+            node.thedef = def;
+            def.orig.push(node);
+            node.mark_enclosed(options);
         }
     });
+    self.make_def = function(orig, init) {
+        return new SymbolDef(++next_def_id, this, orig, init);
+    };
     self.walk(tw);
 
     // pass 2: find back references and eval
     self.globals = new Dictionary();
-    var tw = new TreeWalker(function(node, descend) {
-        if (node instanceof AST_LoopControl && node.label) {
-            node.label.thedef.references.push(node);
+    var in_arg = [];
+    var tw = new TreeWalker(function(node) {
+        if (node instanceof AST_Catch) {
+            if (!(node.argname instanceof AST_Destructured)) return;
+            in_arg.push(node);
+            node.argname.walk(tw);
+            in_arg.pop();
+            walk_body(node, tw);
+            return true;
+        }
+        if (node instanceof AST_Lambda) {
+            in_arg.push(node);
+            node.argnames.forEach(function(argname) {
+                argname.walk(tw);
+            });
+            if (node.rest) node.rest.walk(tw);
+            in_arg.pop();
+            walk_lambda(node, tw);
+            return true;
+        }
+        if (node instanceof AST_LoopControl) {
+            if (node.label) node.label.thedef.references.push(node);
+            return true;
+        }
+        if (node instanceof AST_SymbolDeclaration) {
+            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;
+                }
+            } else if (node instanceof AST_SymbolConst) {
+                // ensure compression works if `const` reuses a scope variable
+                var redef = node.definition().redefined();
+                if (redef) redef.const_redefs = true;
+            }
+            if (node.name != "arguments") return true;
+            var parent = node instanceof AST_SymbolVar && tw.parent();
+            if (parent instanceof AST_VarDef && !parent.value) return true;
+            var sym = node.scope.resolve().find_variable("arguments");
+            if (sym && is_arguments(sym)) sym.scope.uses_arguments = 3;
             return true;
         }
         if (node instanceof AST_SymbolRef) {
             var name = node.name;
-            if (name == "eval" && tw.parent() instanceof AST_Call) {
-                for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope) {
-                    s.uses_eval = true;
-                }
-            }
             var sym = node.scope.find_variable(name);
+            for (var i = in_arg.length; i > 0 && sym;) {
+                i = in_arg.lastIndexOf(sym.scope, i - 1);
+                if (i < 0) break;
+                var decl = sym.orig[0];
+                if (decl instanceof AST_SymbolCatch
+                    || decl instanceof AST_SymbolFunarg
+                    || decl instanceof AST_SymbolLambda) {
+                    node.in_arg = true;
+                    break;
+                }
+                sym = sym.scope.parent_scope.find_variable(name);
+            }
             if (!sym) {
                 sym = self.def_global(node);
-            } else if (sym.scope instanceof AST_Lambda && name == "arguments") {
-                sym.scope.uses_arguments = true;
+            } else if (name == "arguments" && is_arguments(sym)) {
+                var parent = tw.parent();
+                if (is_lhs(node, parent)) {
+                    sym.scope.uses_arguments = 3;
+                } else if (sym.scope.uses_arguments < 2
+                    && !(parent instanceof AST_PropAccess && parent.expression === node)) {
+                    sym.scope.uses_arguments = 2;
+                } else if (!sym.scope.uses_arguments) {
+                    sym.scope.uses_arguments = true;
+                }
+            }
+            if (name == "eval") {
+                var parent = tw.parent();
+                if (parent.TYPE == "Call" && parent.expression === node) {
+                    var s = node.scope;
+                    do {
+                        s = s.resolve();
+                        if (s.uses_eval) break;
+                        s.uses_eval = true;
+                    } while (s = s.parent_scope);
+                } else if (sym.undeclared) {
+                    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;
         }
-        // ensure mangling works if catch reuses a scope variable
-        var def;
-        if (node instanceof AST_SymbolCatch && (def = node.definition().redefined())) {
-            var s = node.scope;
-            while (s) {
-                push_uniq(s.enclosed, def);
-                if (s === def.scope) break;
-                s = s.parent_scope;
-            }
-        }
     });
     self.walk(tw);
 
     // pass 3: fix up any scoping issue with IE8
-    if (options.ie8) {
-        self.walk(new TreeWalker(function(node, descend) {
-            if (node instanceof AST_SymbolCatch) {
-                var name = node.name;
-                var refs = node.thedef.references;
-                var scope = node.thedef.defun;
-                var def = scope.find_variable(name) || self.globals.get(name) || scope.def_variable(node);
-                refs.forEach(function(ref) {
-                    ref.thedef = def;
-                    ref.reference(options);
-                });
-                node.thedef = def;
-                node.reference(options);
-                return true;
+    if (options.ie8) self.walk(new TreeWalker(function(node) {
+        if (node instanceof AST_SymbolCatch) {
+            var scope = node.thedef.defun;
+            if (scope.name instanceof AST_SymbolLambda && scope.name.name == node.name) {
+                scope = scope.parent_scope.resolve();
             }
-        }));
+            redefine(node, scope);
+            return true;
+        }
+        if (node instanceof AST_SymbolLambda) {
+            var def = node.thedef;
+            if (!redefine(node, node.scope.parent_scope.resolve())) {
+                delete def.defun;
+            } else if (typeof node.thedef.init !== "undefined") {
+                node.thedef.init = false;
+            } else if (def.init) {
+                node.thedef.init = def.init;
+            }
+            return true;
+        }
+    }));
+
+    function is_arguments(sym) {
+        return sym.orig[0] instanceof AST_SymbolFunarg
+            && !(sym.orig[1] instanceof AST_SymbolFunarg || sym.orig[2] instanceof AST_SymbolFunarg)
+            && !is_arrow(sym.scope);
+    }
+
+    function redefine(node, scope) {
+        var name = node.name;
+        var old_def = node.thedef;
+        if (!all(old_def.orig, function(sym) {
+            return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet);
+        })) return false;
+        var new_def = scope.find_variable(name);
+        if (new_def) {
+            var redef = new_def.redefined();
+            if (redef) new_def = redef;
+        } else {
+            new_def = self.globals.get(name);
+        }
+        if (new_def) {
+            new_def.orig.push(node);
+        } else {
+            new_def = scope.def_variable(node);
+        }
+        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;
     }
 });
 
@@ -222,7 +410,7 @@ AST_Toplevel.DEFMETHOD("def_global", function(node) {
     if (globals.has(name)) {
         return globals.get(name);
     } else {
-        var g = new SymbolDef(this, node);
+        var g = this.make_def(node);
         g.undeclared = true;
         g.global = true;
         globals.set(name, g);
@@ -230,38 +418,56 @@ AST_Toplevel.DEFMETHOD("def_global", function(node) {
     }
 });
 
-AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope) {
-    this.variables = new Dictionary();  // map name to AST_SymbolVar (variables defined in this scope; includes functions)
-    this.functions = new Dictionary();  // map name to AST_SymbolDefun (functions defined in this scope)
-    this.uses_with = false;             // will be set to true if this or some nested scope uses the `with` statement
-    this.uses_eval = false;             // will be set to true if this or nested scope uses the global `eval`
-    this.parent_scope = parent_scope;   // the parent scope
-    this.enclosed = [];                 // a list of variables from this or outer scope(s) that are referenced from this or inner scopes
-    this.cname = -1;                    // the current index for mangling functions/variables
-});
+function init_block_vars(scope, parent) {
+    scope.enclosed = [];                            // variables from this or outer scope(s) that are referenced from this or inner scopes
+    scope.parent_scope = parent;                    // the parent scope (null if this is the top level)
+    scope.functions = new Dictionary();             // map name to AST_SymbolDefun (functions defined in this scope)
+    scope.variables = new Dictionary();             // map name to AST_SymbolVar (variables defined in this scope; includes functions)
+    if (parent) scope.make_def = parent.make_def;   // top-level tracking of SymbolDef instances
+}
 
-AST_Lambda.DEFMETHOD("init_scope_vars", function() {
-    AST_Scope.prototype.init_scope_vars.apply(this, arguments);
+function init_scope_vars(scope, parent) {
+    init_block_vars(scope, parent);
+    scope.uses_eval = false;                        // will be set to true if this or nested scope uses the global `eval`
+    scope.uses_with = false;                        // will be set to true if this or some nested scope uses the `with` statement
+}
+
+AST_BlockScope.DEFMETHOD("init_vars", function(parent_scope) {
+    init_block_vars(this, parent_scope);
+});
+AST_Scope.DEFMETHOD("init_vars", function(parent_scope) {
+    init_scope_vars(this, 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);
+});
+AST_Lambda.DEFMETHOD("init_vars", function(parent_scope) {
+    init_scope_vars(this, parent_scope);
     this.uses_arguments = false;
     this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
         start: this.start,
-        end: this.end
+        end: this.end,
     }));
+    return this;
 });
 
 AST_Symbol.DEFMETHOD("mark_enclosed", function(options) {
     var def = this.definition();
-    var s = this.scope;
-    while (s) {
+    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);
             });
         }
         if (s === def.scope) break;
-        s = s.parent_scope;
     }
 });
 
@@ -270,28 +476,25 @@ AST_Symbol.DEFMETHOD("reference", function(options) {
     this.mark_enclosed(options);
 });
 
-AST_Scope.DEFMETHOD("find_variable", function(name) {
-    if (name instanceof AST_Symbol) name = name.name;
+AST_BlockScope.DEFMETHOD("find_variable", function(name) {
     return this.variables.get(name)
-        || (this.parent_scope && this.parent_scope.find_variable(name));
+        || this.parent_scope && this.parent_scope.find_variable(name);
 });
 
-AST_Scope.DEFMETHOD("def_function", function(symbol, init) {
+AST_BlockScope.DEFMETHOD("def_function", function(symbol, init) {
     var def = this.def_variable(symbol, init);
-    if (!def.init || def.init instanceof AST_Defun) def.init = init;
+    if (!def.init || def.init instanceof AST_LambdaDefinition) def.init = init;
     this.functions.set(symbol.name, def);
     return def;
 });
 
-AST_Scope.DEFMETHOD("def_variable", function(symbol, init) {
+AST_BlockScope.DEFMETHOD("def_variable", function(symbol, init) {
     var def = this.variables.get(symbol.name);
     if (def) {
         def.orig.push(symbol);
-        if (def.init && (def.scope !== symbol.scope || def.init instanceof AST_Function)) {
-            def.init = init;
-        }
+        if (def.init instanceof AST_LambdaExpression) def.init = init;
     } else {
-        def = new SymbolDef(this, symbol, init);
+        def = this.make_def(symbol, init);
         this.variables.set(symbol.name, def);
         def.global = !this.parent_scope;
     }
@@ -301,29 +504,27 @@ AST_Scope.DEFMETHOD("def_variable", function(symbol, init) {
 function names_in_use(scope, options) {
     var names = scope.names_in_use;
     if (!names) {
-        scope.names_in_use = names = Object.create(scope.mangled_names || null);
+        scope.cname = -1;
         scope.cname_holes = [];
+        scope.names_in_use = names = Object.create(null);
+        var cache = options.cache && options.cache.props;
         scope.enclosed.forEach(function(def) {
             if (def.unmangleable(options)) names[def.name] = true;
+            if (def.global && cache && cache.has(def.name)) {
+                names[cache.get(def.name)] = true;
+            }
         });
     }
     return names;
 }
 
-function next_mangled_name(scope, options, def) {
+function next_mangled_name(def, options) {
+    var scope = def.scope;
     var in_use = names_in_use(scope, options);
     var holes = scope.cname_holes;
     var names = Object.create(null);
-    // #179, #326
-    // in Safari strict mode, something like (function x(x){...}) is a syntax error;
-    // a function expression's argument cannot shadow the function expression's name
-    if (scope instanceof AST_Function && scope.name && def.orig[0] instanceof AST_SymbolFunarg) {
-        var tricky_def = scope.name.definition();
-        // the function's mangled_name is null when keep_fnames is true
-        names[tricky_def.mangled_name || tricky_def.name] = true;
-    }
     var scopes = [ scope ];
-    def.references.forEach(function(sym) {
+    def.forEach(function(sym) {
         var scope = sym.scope;
         do {
             if (scopes.indexOf(scope) < 0) {
@@ -335,20 +536,20 @@ function next_mangled_name(scope, options, def) {
         } while (scope = scope.parent_scope);
     });
     var name;
-    for (var i = 0, len = holes.length; i < len; i++) {
+    for (var i = 0; i < holes.length; i++) {
         name = base54(holes[i]);
         if (names[name]) continue;
         holes.splice(i, 1);
-        scope.names_in_use[name] = true;
+        in_use[name] = true;
         return name;
     }
     while (true) {
         name = base54(++scope.cname);
-        if (in_use[name] || !is_identifier(name) || options.reserved.has[name]) continue;
+        if (in_use[name] || RESERVED_WORDS[name] || options.reserved.has[name]) continue;
         if (!names[name]) break;
         holes.push(scope.cname);
     }
-    scope.names_in_use[name] = true;
+    in_use[name] = true;
     return name;
 }
 
@@ -360,18 +561,10 @@ AST_Symbol.DEFMETHOD("unmangleable", function(options) {
 // labels are always mangleable
 AST_Label.DEFMETHOD("unmangleable", return_false);
 
-AST_Symbol.DEFMETHOD("unreferenced", function() {
-    return !this.definition().references.length && !this.scope.pinned();
-});
-
 AST_Symbol.DEFMETHOD("definition", function() {
     return this.thedef;
 });
 
-AST_Symbol.DEFMETHOD("global", function() {
-    return this.definition().global;
-});
-
 function _default_mangler_options(options) {
     options = defaults(options, {
         eval        : false,
@@ -379,6 +572,8 @@ function _default_mangler_options(options) {
         keep_fnames : false,
         reserved    : [],
         toplevel    : false,
+        v8          : false,
+        webkit      : false,
     });
     if (!Array.isArray(options.reserved)) options.reserved = [];
     // Never mangle arguments
@@ -397,7 +592,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
     var lname = -1;
 
     if (options.cache && options.cache.props) {
-        var mangled_names = this.mangled_names = Object.create(null);
+        var mangled_names = names_in_use(this, options);
         options.cache.props.each(function(mangled_name) {
             mangled_names[mangled_name] = true;
         });
@@ -409,41 +604,49 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             // lname is incremented when we get to the AST_Label
             var save_nesting = lname;
             descend();
-            lname = save_nesting;
-            return true;        // don't descend again in TreeWalker
+            if (!options.v8 || !in_label(tw)) lname = save_nesting;
+            return true;
         }
-        if (node instanceof AST_Scope) {
+        if (node instanceof AST_BlockScope) {
+            if (options.webkit && node instanceof AST_IterationStatement && node.init instanceof AST_Let) {
+                node.init.definitions.forEach(function(defn) {
+                    defn.name.match_symbol(function(sym) {
+                        if (!(sym instanceof AST_SymbolLet)) return;
+                        var def = sym.definition();
+                        var scope = sym.scope.parent_scope;
+                        var redef = scope.def_variable(sym);
+                        sym.thedef = def;
+                        scope.to_mangle.push(redef);
+                        def.redefined = function() {
+                            return redef;
+                        };
+                    });
+                }, true);
+            }
+            node.to_mangle = [];
+            node.variables.each(function(def) {
+                if (!defer_redef(def)) node.to_mangle.push(def);
+            });
             descend();
             if (options.cache && node instanceof AST_Toplevel) {
                 node.globals.each(mangle);
             }
-            node.variables.each(mangle);
+            if (node instanceof AST_Defun && tw.has_directive("use asm")) {
+                var sym = new AST_SymbolRef(node.name);
+                sym.scope = node;
+                sym.reference(options);
+            }
+            node.to_mangle.forEach(mangle);
             return true;
         }
         if (node instanceof AST_Label) {
             var name;
-            do name = base54(++lname); while (!is_identifier(name));
+            do {
+                name = base54(++lname);
+            } while (RESERVED_WORDS[name]);
             node.mangled_name = name;
             return true;
         }
-        if (!options.ie8 && node instanceof AST_Catch) {
-            var def = node.argname.definition();
-            var redef = def.redefined();
-            if (redef) {
-                redefined.push(def);
-                reference(node.argname);
-                def.references.forEach(reference);
-            }
-            descend();
-            if (!redef) mangle(def);
-            return true;
-        }
-
-        function reference(sym) {
-            sym.thedef = redef;
-            sym.reference(options);
-            sym.thedef = def;
-        }
     });
     this.walk(tw);
     redefined.forEach(mangle);
@@ -452,16 +655,46 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
         if (options.reserved.has[def.name]) return;
         def.mangle(options);
     }
+
+    function defer_redef(def) {
+        var sym = def.orig[0];
+        var redef = def.redefined();
+        if (!redef) {
+            if (!(sym instanceof AST_SymbolConst)) return false;
+            var scope = def.scope.resolve();
+            if (def.scope === scope) return false;
+            if (def.scope.parent_scope.find_variable(sym.name)) return false;
+            redef = scope.def_variable(sym);
+            scope.to_mangle.push(redef);
+        }
+        redefined.push(def);
+        def.references.forEach(reference);
+        if (sym instanceof AST_SymbolCatch || sym instanceof AST_SymbolConst) reference(sym);
+        return true;
+
+        function reference(sym) {
+            sym.thedef = redef;
+            sym.reference(options);
+            sym.thedef = def;
+        }
+    }
+
+    function in_label(tw) {
+        var level = 0, parent;
+        while (parent = tw.parent(level++)) {
+            if (parent instanceof AST_Block) return parent instanceof AST_Toplevel && !options.toplevel;
+            if (parent instanceof AST_LabeledStatement) return true;
+        }
+    }
 });
 
 AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) {
     var cache = options.cache && options.cache.props;
-    var avoid = Object.create(null);
+    var avoid = Object.create(RESERVED_WORDS);
     options.reserved.forEach(to_avoid);
     this.globals.each(add_def);
     this.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_Scope) node.variables.each(add_def);
-        if (node instanceof AST_SymbolCatch) add_def(node.definition());
+        if (node instanceof AST_BlockScope) node.variables.each(add_def);
     }));
     return avoid;
 
@@ -485,15 +718,14 @@ AST_Toplevel.DEFMETHOD("expand_names", function(options) {
     var cname = 0;
     this.globals.each(rename);
     this.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_Scope) node.variables.each(rename);
-        if (node instanceof AST_SymbolCatch) rename(node.definition());
+        if (node instanceof AST_BlockScope) node.variables.each(rename);
     }));
 
     function next_name() {
         var name;
         do {
             name = base54(cname++);
-        } while (avoid[name] || !is_identifier(name));
+        } while (avoid[name]);
         return name;
     }
 
@@ -501,13 +733,11 @@ AST_Toplevel.DEFMETHOD("expand_names", function(options) {
         if (def.global && options.cache) return;
         if (def.unmangleable(options)) return;
         if (options.reserved.has[def.name]) return;
-        var d = def.redefined();
-        def.name = d ? d.name : next_name();
-        def.orig.forEach(function(sym) {
-            sym.name = def.name;
-        });
-        def.references.forEach(function(sym) {
-            sym.name = def.name;
+        var redef = def.redefined();
+        var name = redef ? redef.rename || redef.name : next_name();
+        def.rename = name;
+        def.forEach(function(sym) {
+            if (sym.definition() === def) sym.name = name;
         });
     }
 });
@@ -520,22 +750,24 @@ AST_Sequence.DEFMETHOD("tail_node", function() {
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) {
     options = _default_mangler_options(options);
     base54.reset();
+    var fn = AST_Symbol.prototype.add_source_map;
     try {
-        AST_Node.prototype.print = function(stream, force_parens) {
-            this._print(stream, force_parens);
-            if (this instanceof AST_Symbol && !this.unmangleable(options)) {
-                base54.consider(this.name, -1);
-            } else if (options.properties) {
-                if (this instanceof AST_Dot) {
-                    base54.consider(this.property, -1);
-                } else if (this instanceof AST_Sub) {
-                    skip_string(this.property);
-                }
-            }
+        AST_Symbol.prototype.add_source_map = function() {
+            if (!this.unmangleable(options)) base54.consider(this.name, -1);
         };
+        if (options.properties) {
+            AST_Dot.prototype.add_source_map = function() {
+                base54.consider(this.property, -1);
+            };
+            AST_Sub.prototype.add_source_map = function() {
+                skip_string(this.property);
+            };
+        }
         base54.consider(this.print_to_string(), 1);
     } finally {
-        AST_Node.prototype.print = AST_Node.prototype._print;
+        AST_Symbol.prototype.add_source_map = fn;
+        delete AST_Dot.prototype.add_source_map;
+        delete AST_Sub.prototype.add_source_map;
     }
     base54.sort();
 
@@ -555,7 +787,7 @@ var base54 = (function() {
     var freq = Object.create(null);
     function init(chars) {
         var array = [];
-        for (var i = 0, len = chars.length; i < len; i++) {
+        for (var i = 0; i < chars.length; i++) {
             var ch = chars[i];
             array.push(ch);
             freq[ch] = -1e-2 * i;

lib/sourcemap.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS2
+  https://github.com/mishoo/UglifyJS
 
   -------------------------------- (C) ---------------------------------
 
@@ -43,62 +43,151 @@
 
 "use strict";
 
-// a small wrapper around fitzgen's source-map library
-function SourceMap(options) {
-    options = defaults(options, {
-        file: null,
-        root: null,
-        orig: null,
-        orig_line_diff: 0,
-        dest_line_diff: 0,
-    }, true);
-    var generator = new MOZ_SourceMap.SourceMapGenerator({
-        file: options.file,
-        sourceRoot: options.root
-    });
-    var maps = options.orig && Object.create(null);
-    if (maps) for (var source in options.orig) {
-        var map = new MOZ_SourceMap.SourceMapConsumer(options.orig[source]);
-        if (Array.isArray(options.orig[source].sources)) {
-            map._sources.toArray().forEach(function(source) {
-                var sourceContent = map.sourceContentFor(source, true);
-                if (sourceContent) generator.setSourceContent(source, sourceContent);
-            });
+var vlq_char = characters("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
+var vlq_bits = vlq_char.reduce(function(map, ch, bits) {
+    map[ch] = bits;
+    return map;
+}, Object.create(null));
+
+function vlq_decode(indices, str) {
+    var value = 0;
+    var shift = 0;
+    for (var i = 0, j = 0; i < str.length; i++) {
+        var bits = vlq_bits[str[i]];
+        value += (bits & 31) << shift;
+        if (bits & 32) {
+            shift += 5;
+        } else {
+            indices[j++] += value & 1 ? 0x80000000 | -(value >> 1) : value >> 1;
+            value = shift = 0;
         }
-        maps[source] = map;
     }
-    return {
-        add: function(source, gen_line, gen_col, orig_line, orig_col, name) {
-            var map = maps && maps[source];
-            if (map) {
-                var info = map.originalPositionFor({
-                    line: orig_line,
-                    column: orig_col
+    return j;
+}
+
+function vlq_encode(num) {
+    var result = "";
+    num = Math.abs(num) << 1 | num >>> 31;
+    do {
+        var bits = num & 31;
+        if (num >>>= 5) bits |= 32;
+        result += vlq_char[bits];
+    } while (num);
+    return result;
+}
+
+function create_array_map() {
+    var map = Object.create(null);
+    var array = [];
+    array.index = function(name) {
+        if (!HOP(map, name)) {
+            map[name] = array.length;
+            array.push(name);
+        }
+        return map[name];
+    };
+    return array;
+}
+
+function SourceMap(options) {
+    var sources = create_array_map();
+    var sources_content = options.includeSources && Object.create(null);
+    var names = create_array_map();
+    var mappings = "";
+    if (options.orig) Object.keys(options.orig).forEach(function(name) {
+        var map = options.orig[name];
+        var indices = [ 0, 0, 1, 0, 0 ];
+        options.orig[name] = {
+            names: map.names,
+            mappings: map.mappings.split(/;/).map(function(line) {
+                indices[0] = 0;
+                return line.split(/,/).map(function(segment) {
+                    return indices.slice(0, vlq_decode(indices, segment));
                 });
-                if (info.source === null) return;
-                source = info.source;
-                orig_line = info.line;
-                orig_col = info.column;
-                name = info.name || name;
-            }
-            generator.addMapping({
-                name: name,
-                source: source,
-                generated: {
-                    line: gen_line + options.dest_line_diff,
-                    column: gen_col
-                },
-                original: {
-                    line: orig_line + options.orig_line_diff,
-                    column: orig_col
+            }),
+            sources: map.sources,
+        };
+        if (!sources_content || !map.sourcesContent) return;
+        for (var i = 0; i < map.sources.length; i++) {
+            var content = map.sourcesContent[i];
+            if (content) sources_content[map.sources[i]] = content;
+        }
+    });
+    var prev_source;
+    var generated_line = 1;
+    var generated_column = 0;
+    var source_index = 0;
+    var original_line = 1;
+    var original_column = 0;
+    var name_index = 0;
+    return {
+        add: options.orig ? function(source, gen_line, gen_col, orig_line, orig_col, name) {
+            var map = options.orig[source];
+            if (map) {
+                var segments = map.mappings[orig_line - 1];
+                if (!segments) return;
+                var indices;
+                for (var i = 0; i < segments.length; i++) {
+                    var col = segments[i][0];
+                    if (orig_col >= col) indices = segments[i];
+                    if (orig_col <= col) break;
                 }
-            });
-        },
-        get: function() {
-            return generator;
-        },
+                if (!indices || indices.length < 4) {
+                    source = null;
+                } else {
+                    source = map.sources[indices[1]];
+                    orig_line = indices[2];
+                    orig_col = indices[3];
+                    if (indices.length > 4) name = map.names[indices[4]];
+                }
+            }
+            add(source, gen_line, gen_col, orig_line, orig_col, name);
+        } : add,
+        setSourceContent: sources_content ? function(source, content) {
+            if (!(source in sources_content)) {
+                sources_content[source] = content;
+            }
+        } : noop,
         toString: function() {
-            return JSON.stringify(generator.toJSON());
+            return JSON.stringify({
+                version: 3,
+                file: options.filename || undefined,
+                sourceRoot: options.root || undefined,
+                sources: sources,
+                sourcesContent: sources_content ? sources.map(function(source) {
+                    return sources_content[source] || null;
+                }) : undefined,
+                names: names,
+                mappings: mappings,
+            });
         }
     };
+
+    function add(source, gen_line, gen_col, orig_line, orig_col, name) {
+        if (prev_source == null && source == null) return;
+        prev_source = source;
+        if (generated_line < gen_line) {
+            generated_column = 0;
+            do {
+                mappings += ";";
+            } while (++generated_line < gen_line);
+        } else if (mappings) {
+            mappings += ",";
+        }
+        mappings += vlq_encode(gen_col - generated_column);
+        generated_column = gen_col;
+        if (source == null) return;
+        var src_idx = sources.index(source);
+        mappings += vlq_encode(src_idx - source_index);
+        source_index = src_idx;
+        mappings += vlq_encode(orig_line - original_line);
+        original_line = orig_line;
+        mappings += vlq_encode(orig_col - original_column);
+        original_column = orig_col;
+        if (options.names && name != null) {
+            var name_idx = names.index(name);
+            mappings += vlq_encode(name_idx - name_index);
+            name_index = name_idx;
+        }
+    }
 }

lib/transform.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS2
+  https://github.com/mishoo/UglifyJS
 
   -------------------------------- (C) ---------------------------------
 
@@ -52,7 +52,7 @@ TreeTransformer.prototype = new TreeWalker;
 
 (function(DEF) {
     function do_list(list, tw) {
-        return MAP(list, function(node) {
+        return List(list, function(node) {
             return node.transform(tw, true);
         });
     }
@@ -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);
@@ -116,7 +116,7 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.bfinally) self.bfinally = self.bfinally.transform(tw);
     });
     DEF(AST_Catch, function(self, tw) {
-        self.argname = self.argname.transform(tw);
+        if (self.argname) self.argname = self.argname.transform(tw);
         self.body = do_list(self.body, tw);
     });
     DEF(AST_Definitions, function(self, tw) {
@@ -126,11 +126,36 @@ TreeTransformer.prototype = new TreeWalker;
         self.name = self.name.transform(tw);
         if (self.value) self.value = self.value.transform(tw);
     });
+    DEF(AST_DefaultValue, function(self, tw) {
+        self.name = self.name.transform(tw);
+        self.value = self.value.transform(tw);
+    });
     DEF(AST_Lambda, function(self, tw) {
         if (self.name) self.name = self.name.transform(tw);
         self.argnames = do_list(self.argnames, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
         self.body = do_list(self.body, tw);
     });
+    function transform_arrow(self, tw) {
+        self.argnames = do_list(self.argnames, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
+        if (self.value) {
+            self.value = self.value.transform(tw);
+        } else {
+            self.body = do_list(self.body, tw);
+        }
+    }
+    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);
@@ -138,6 +163,12 @@ TreeTransformer.prototype = new TreeWalker;
     DEF(AST_Sequence, function(self, tw) {
         self.expressions = do_list(self.expressions, tw);
     });
+    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);
     });
@@ -145,6 +176,9 @@ TreeTransformer.prototype = new TreeWalker;
         self.expression = self.expression.transform(tw);
         self.property = self.property.transform(tw);
     });
+    DEF(AST_Spread, function(self, tw) {
+        self.expression = self.expression.transform(tw);
+    });
     DEF(AST_Unary, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
@@ -160,12 +194,43 @@ TreeTransformer.prototype = new TreeWalker;
     DEF(AST_Array, function(self, tw) {
         self.elements = do_list(self.elements, tw);
     });
+    DEF(AST_DestructuredArray, function(self, tw) {
+        self.elements = do_list(self.elements, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
+    });
+    DEF(AST_DestructuredKeyVal, function(self, tw) {
+        if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
+        self.value = self.value.transform(tw);
+    });
+    DEF(AST_DestructuredObject, function(self, tw) {
+        self.properties = do_list(self.properties, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
+    });
     DEF(AST_Object, function(self, tw) {
         self.properties = do_list(self.properties, tw);
     });
     DEF(AST_ObjectProperty, function(self, tw) {
+        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

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS2
+  https://github.com/mishoo/UglifyJS
 
   -------------------------------- (C) ---------------------------------
 
@@ -70,7 +70,7 @@ function configure_error_stack(fn) {
             err.name = this.name;
             try {
                 throw err;
-            } catch(e) {
+            } catch (e) {
                 return e.stack;
             }
         }
@@ -87,15 +87,13 @@ DefaultsError.prototype.name = "DefaultsError";
 configure_error_stack(DefaultsError);
 
 function defaults(args, defs, croak) {
-    if (args === true) args = {};
-    var ret = args || {};
-    if (croak) for (var i in ret) if (HOP(ret, i) && !HOP(defs, i)) {
-        throw new DefaultsError("`" + i + "` is not a supported option", defs);
+    if (croak) for (var i in args) {
+        if (HOP(args, i) && !HOP(defs, i)) throw new DefaultsError("`" + i + "` is not a supported option", defs);
     }
-    for (var i in defs) if (HOP(defs, i)) {
-        ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];
+    for (var i in args) {
+        if (HOP(args, i)) defs[i] = args[i];
     }
-    return ret;
+    return defs;
 }
 
 function merge(obj, ext) {
@@ -113,52 +111,31 @@ function return_true() { return true; }
 function return_this() { return this; }
 function return_null() { return null; }
 
-var MAP = (function() {
-    function MAP(a, f, backwards) {
-        var ret = [], top = [], i;
-        function doit() {
+var List = (function() {
+    function List(a, f) {
+        var ret = [];
+        for (var i = 0; i < a.length; i++) {
             var val = f(a[i], i);
-            var is_last = val instanceof Last;
-            if (is_last) val = val.v;
-            if (val instanceof AtTop) {
-                val = val.v;
-                if (val instanceof Splice) {
-                    top.push.apply(top, backwards ? val.v.slice().reverse() : val.v);
-                } else {
-                    top.push(val);
-                }
-            }
-            else if (val !== skip) {
-                if (val instanceof Splice) {
-                    ret.push.apply(ret, backwards ? val.v.slice().reverse() : val.v);
-                } else {
-                    ret.push(val);
-                }
-            }
-            return is_last;
-        }
-        if (Array.isArray(a)) {
-            if (backwards) {
-                for (i = a.length; --i >= 0;) if (doit()) break;
-                ret.reverse();
-                top.reverse();
+            if (val === skip) continue;
+            if (val instanceof Splice) {
+                ret.push.apply(ret, val.v);
             } else {
-                for (i = 0; i < a.length; ++i) if (doit()) break;
+                ret.push(val);
             }
         }
-        else {
-            for (i in a) if (HOP(a, i)) if (doit()) break;
-        }
-        return top.concat(ret);
+        return ret;
     }
-    MAP.at_top = function(val) { return new AtTop(val) };
-    MAP.splice = function(val) { return new Splice(val) };
-    MAP.last = function(val) { return new Last(val) };
-    var skip = MAP.skip = {};
-    function AtTop(val) { this.v = val }
-    function Splice(val) { this.v = val }
-    function Last(val) { this.v = val }
-    return MAP;
+    List.is_op = function(val) {
+        return val === skip || val instanceof Splice;
+    };
+    List.splice = function(val) {
+        return new Splice(val);
+    };
+    var skip = List.skip = {};
+    function Splice(val) {
+        this.v = val;
+    }
+    return List;
 })();
 
 function push_uniq(array, el) {
@@ -166,15 +143,15 @@ function push_uniq(array, el) {
 }
 
 function string_template(text, props) {
-    return text.replace(/\{(.+?)\}/g, function(str, p) {
-        return props && props[p];
+    return text.replace(/\{([^}]+)\}/g, function(str, p) {
+        var value = props[p];
+        return value instanceof AST_Node ? value.print_to_string() : value;
     });
 }
 
 function remove(array, el) {
-    for (var i = array.length; --i >= 0;) {
-        if (array[i] === el) array.splice(i, 1);
-    }
+    var index = array.indexOf(el);
+    if (index >= 0) array.splice(index, 1);
 }
 
 function makePredicate(words) {
@@ -188,7 +165,7 @@ function makePredicate(words) {
 
 function all(array, predicate) {
     for (var i = array.length; --i >= 0;)
-        if (!predicate(array[i]))
+        if (!predicate(array[i], i))
             return false;
     return true;
 }
@@ -220,6 +197,12 @@ Dictionary.prototype = {
         return this;
     },
     has: function(key) { return ("$" + key) in this._values },
+    all: function(predicate) {
+        for (var i in this._values)
+            if (!predicate(this._values[i], i.substr(1)))
+                return false;
+        return true;
+    },
     each: function(f) {
         for (var i in this._values)
             f(this._values[i], i.substr(1));
@@ -255,21 +238,27 @@ 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) {
+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 (p.TYPE == "Call") {
-            if (p.expression === node) continue;
+        if (is_arrow(p)) {
+            return arrow && p.value === node;
         } else if (p instanceof AST_Binary) {
             if (p.left === node) continue;
+        } else if (p.TYPE == "Call") {
+            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.4.5",
+  "version": "3.13.2",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -11,7 +11,7 @@
     "Alex Lam <alexlamsl@gmail.com>",
     "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)"
   ],
-  "repository": "mishoo/UglifyJS2",
+  "repository": "mishoo/UglifyJS",
   "main": "tools/node.js",
   "bin": {
     "uglifyjs": "bin/uglifyjs"
@@ -22,16 +22,12 @@
     "tools",
     "LICENSE"
   ],
-  "dependencies": {
-    "commander": "~2.16.0",
-    "source-map": "~0.6.1"
-  },
   "devDependencies": {
-    "acorn": "~5.7.1",
-    "semver": "~5.5.0"
+    "acorn": "~7.1.0",
+    "semver": "~6.3.0"
   },
   "scripts": {
-    "test": "node test/run-tests.js"
+    "test": "node test/compress.js && node test/mocha.js"
   },
   "keywords": [
     "cli",

test/benchmark.js

@@ -5,23 +5,22 @@
 
 var createHash = require("crypto").createHash;
 var fetch = require("./fetch");
-var fork = require("child_process").fork;
+var spawn = require("child_process").spawn;
 var zlib = require("zlib");
 var args = process.argv.slice(2);
-if (!args.length) {
-    args.push("-mc");
-}
+if (!args.length) args.push("-mc");
+args.unshift("bin/uglifyjs");
 args.push("--timings");
 var urls = [
-    "https://code.jquery.com/jquery-3.2.1.js",
-    "https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.4/angular.js",
-    "https://cdnjs.cloudflare.com/ajax/libs/mathjs/3.9.0/math.js",
-    "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.js",
+    "https://code.jquery.com/jquery-3.4.1.js",
+    "https://code.angularjs.org/1.7.8/angular.js",
+    "https://unpkg.com/mathjs@6.2.3/dist/math.js",
     "https://unpkg.com/react@15.3.2/dist/react.js",
-    "http://builds.emberjs.com/tags/v2.11.0/ember.prod.js",
-    "https://cdn.jsdelivr.net/lodash/4.17.4/lodash.js",
-    "https://cdnjs.cloudflare.com/ajax/libs/d3/4.5.0/d3.js",
-    "https://raw.githubusercontent.com/kangax/html-minifier/v3.5.7/dist/htmlminifier.js",
+    "https://cdnjs.cloudflare.com/ajax/libs/d3/5.12.0/d3.js",
+    "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.js",
+    "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.js",
+    "https://cdnjs.cloudflare.com/ajax/libs/ember.js/2.12.2/ember.prod.js",
+    "https://raw.githubusercontent.com/kangax/html-minifier/v4.0.0/dist/htmlminifier.js",
 ];
 var results = {};
 var remaining = 2 * urls.length;
@@ -70,18 +69,20 @@ urls.forEach(function(url) {
     };
     fetch(url, function(err, res) {
         if (err) throw err;
-        var uglifyjs = fork("bin/uglifyjs", args, { silent: true });
+        var uglifyjs = spawn(process.argv[0], args, { silent: true });
         res.on("data", function(data) {
             results[url].input += data.length;
         }).pipe(uglifyjs.stdin);
+        var sha1 = createHash("sha1");
         uglifyjs.stdout.on("data", function(data) {
             results[url].output += data.length;
         }).pipe(zlib.createGzip({
             level: zlib.Z_BEST_COMPRESSION
         })).on("data", function(data) {
             results[url].gzip += data.length;
-        }).pipe(createHash("sha1")).on("data", function(data) {
-            results[url].sha1 = data.toString("hex");
+            sha1.update(data);
+        }).on("end", function() {
+            results[url].sha1 = sha1.digest("hex");
             done();
         });
         uglifyjs.stderr.setEncoding("utf8");

test/compress.js

@@ -0,0 +1,461 @@
+"use strict";
+
+require("../tools/tty");
+
+var assert = require("assert");
+var child_process = require("child_process");
+var fs = require("fs");
+var path = require("path");
+var sandbox = require("./sandbox");
+var semver = require("semver");
+var U = require("./node");
+
+var batch = 50;
+var dir = path.resolve(path.dirname(module.filename), "compress");
+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);
+    var tests = parse_test(path.resolve(dir, file));
+    process.exit(Object.keys(tests).slice(start, start + batch).filter(function(name) {
+        return !test_case(tests[name]);
+    }).length);
+} else {
+    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(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] = true;
+                }
+                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).");
+            console.error("!!! " + Object.keys(failed_files).join(", "));
+            process.exit(1);
+        }
+    })();
+}
+
+function evaluate(code) {
+    if (code instanceof U.AST_Node) code = make_code(code, { beautify: true });
+    return new Function("return(" + code + ")")();
+}
+
+function log() {
+    console.log("%s", tmpl.apply(null, arguments));
+}
+
+function make_code(ast, options) {
+    var stream = U.OutputStream(options);
+    ast.print(stream);
+    return stream.get();
+}
+
+function parse_test(file) {
+    var script = fs.readFileSync(file, "utf8");
+    try {
+        var ast = U.parse(script, {
+            filename: file
+        });
+    } catch (e) {
+        console.error("Caught error while parsing tests in " + file);
+        console.error(e);
+        process.exit(1);
+    }
+    var tests = Object.create(null);
+    var tw = new U.TreeWalker(function(node, descend) {
+        if (node instanceof U.AST_LabeledStatement
+            && tw.parent() instanceof U.AST_Toplevel) {
+            var name = node.label.name;
+            if (name in tests) {
+                throw new Error('Duplicated test name "' + name + '" in ' + file);
+            }
+            tests[name] = get_one_test(name, node.body);
+            return true;
+        }
+        if (!(node instanceof U.AST_Toplevel)) croak(node);
+    });
+    ast.walk(tw);
+    return tests;
+
+    function croak(node) {
+        throw new Error(tmpl("Can't understand test file {file} [{line},{col}]\n{code}", {
+            file: file,
+            line: node.start.line,
+            col: node.start.col,
+            code: make_code(node, { beautify: false })
+        }));
+    }
+
+    function read_string(stat) {
+        if (stat.TYPE == "SimpleStatement") {
+            var body = stat.body;
+            switch(body.TYPE) {
+              case "String":
+                return body.value;
+              case "Array":
+                return body.elements.map(function(element) {
+                    if (element.TYPE !== "String")
+                        throw new Error("Should be array of strings");
+                    return element.value;
+                }).join("\n");
+            }
+        }
+        throw new Error("Should be string or array of strings");
+    }
+
+    function get_one_test(name, block) {
+        var test = { name: name, options: {} };
+        var tw = new U.TreeWalker(function(node, descend) {
+            if (node instanceof U.AST_Assign) {
+                if (!(node.left instanceof U.AST_SymbolRef)) {
+                    croak(node);
+                }
+                var name = node.left.name;
+                test[name] = evaluate(node.right);
+                return true;
+            }
+            if (node instanceof U.AST_LabeledStatement) {
+                var label = node.label;
+                assert.ok([
+                    "input",
+                    "expect",
+                    "expect_exact",
+                    "expect_warnings",
+                    "expect_stdout",
+                    "node_version",
+                ].indexOf(label.name) >= 0, tmpl("Unsupported label {name} [{line},{col}]", {
+                    name: label.name,
+                    line: label.start.line,
+                    col: label.start.col
+                }));
+                var stat = node.body;
+                if (label.name == "expect_exact" || label.name == "node_version") {
+                    test[label.name] = read_string(stat);
+                } else if (label.name == "expect_stdout") {
+                    var body = stat.body;
+                    if (body instanceof U.AST_Boolean) {
+                        test[label.name] = body.value;
+                    } else if (body instanceof U.AST_Call) {
+                        var ctor = global[body.expression.name];
+                        assert.ok(ctor === Error || ctor.prototype instanceof Error, tmpl("Unsupported expect_stdout format [{line},{col}]", {
+                            line: label.start.line,
+                            col: label.start.col
+                        }));
+                        test[label.name] = ctor.apply(null, body.args.map(function(node) {
+                            assert.ok(node instanceof U.AST_Constant, tmpl("Unsupported expect_stdout format [{line},{col}]", {
+                                line: label.start.line,
+                                col: label.start.col
+                            }));
+                            return node.value;
+                        }));
+                    } else {
+                        test[label.name] = read_string(stat) + "\n";
+                    }
+                } else {
+                    test[label.name] = stat;
+                }
+                return true;
+            }
+        });
+        block.walk(tw);
+        return test;
+    }
+}
+
+// Try to reminify original input with standard options
+// to see if it matches expect_stdout.
+function reminify(orig_options, input_code, input_formatted, stdout) {
+    for (var i = 0; i < minify_options.length; i++) {
+        var options = JSON.parse(minify_options[i]);
+        if (options.compress) [
+            "keep_fargs",
+            "keep_fnames",
+        ].forEach(function(name) {
+            if (name in orig_options) {
+                options.compress[name] = orig_options[name];
+            }
+        });
+        var options_formatted = JSON.stringify(options, null, 4);
+        options.validate = true;
+        var result = U.minify(input_code, options);
+        if (result.error) {
+            log([
+                "!!! failed input reminify",
+                "---INPUT---",
+                "{input}",
+                "---OPTIONS---",
+                "{options}",
+                "--ERROR---",
+                "{error}",
+                "",
+                "",
+            ].join("\n"), {
+                input: input_formatted,
+                options: options_formatted,
+                error: result.error,
+            });
+            return false;
+        } else {
+            var toplevel = sandbox.has_toplevel(options);
+            var expected = stdout[toplevel ? 1 : 0];
+            var actual = sandbox.run_code(result.code, toplevel);
+            if (typeof expected != "string" && typeof actual != "string" && expected.name == actual.name) {
+                actual = expected;
+            }
+            if (!sandbox.same_stdout(expected, actual)) {
+                log([
+                    "!!! failed running reminified input",
+                    "---INPUT---",
+                    "{input}",
+                    "---OPTIONS---",
+                    "{options}",
+                    "---OUTPUT---",
+                    "{output}",
+                    "---EXPECTED {expected_type}---",
+                    "{expected}",
+                    "---ACTUAL {actual_type}---",
+                    "{actual}",
+                    "",
+                    "",
+                ].join("\n"), {
+                    input: input_formatted,
+                    options: options_formatted,
+                    output: result.code,
+                    expected_type: typeof expected == "string" ? "STDOUT" : "ERROR",
+                    expected: expected,
+                    actual_type: typeof actual == "string" ? "STDOUT" : "ERROR",
+                    actual: actual,
+                });
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+function test_case(test) {
+    log("    Running test [{name}]", { name: test.name });
+    U.AST_Node.enable_validation();
+    var output_options = test.beautify || {};
+    var expect;
+    if (test.expect) {
+        expect = make_code(to_toplevel(test.expect, test.mangle), output_options);
+    } else {
+        expect = test.expect_exact;
+    }
+    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,
+        quote_style: 3,
+    });
+    try {
+        input.validate_ast();
+        U.parse(input_code);
+    } catch (ex) {
+        log([
+            "!!! Cannot parse input",
+            "---INPUT---",
+            "{input}",
+            "--PARSE ERROR--",
+            "{error}",
+            "",
+            "",
+        ].join("\n"), {
+            input: input_formatted,
+            error: ex,
+        });
+        return false;
+    }
+    var warnings_emitted = [];
+    if (test.expect_warnings) {
+        var expected_warnings = make_code(test.expect_warnings, {
+            beautify: false,
+            quote_style: 2, // force double quote to match JSON
+        });
+        U.AST_Node.log_function(function(text) {
+            warnings_emitted.push(text);
+        }, /"INFO: /.test(expected_warnings));
+    }
+    if (test.mangle && test.mangle.properties && test.mangle.properties.keep_quoted) {
+        var quoted_props = test.mangle.properties.reserved;
+        if (!Array.isArray(quoted_props)) quoted_props = [];
+        test.mangle.properties.reserved = quoted_props;
+        U.reserve_quoted_keys(input, quoted_props);
+    }
+    if (test.rename) {
+        input.figure_out_scope(test.mangle);
+        input.expand_names(test.mangle);
+    }
+    var cmp = new U.Compressor(test.options, true);
+    var output = cmp.compress(input);
+    output.figure_out_scope(test.mangle);
+    if (test.mangle) {
+        output.compute_char_frequency(test.mangle);
+        output.mangle_names(test.mangle);
+        if (test.mangle.properties) U.mangle_properties(output, test.mangle.properties);
+    }
+    var output_code = make_code(output, output_options);
+    U.AST_Node.log_function();
+    if (expect != output_code) {
+        log([
+            "!!! failed",
+            "---INPUT---",
+            "{input}",
+            "---OUTPUT---",
+            "{output}",
+            "---EXPECTED---",
+            "{expected}",
+            "",
+            "",
+        ].join("\n"), {
+            input: input_formatted,
+            output: output_code,
+            expected: expect
+        });
+        return false;
+    }
+    // expect == output
+    try {
+        output.validate_ast();
+        U.parse(output_code);
+    } catch (ex) {
+        log([
+            "!!! Test matched expected result but cannot parse output",
+            "---INPUT---",
+            "{input}",
+            "---OUTPUT---",
+            "{output}",
+            "--REPARSE ERROR--",
+            "{error}",
+            "",
+            "",
+        ].join("\n"), {
+            input: input_formatted,
+            output: output_code,
+            error: ex,
+        });
+        return false;
+    }
+    if (test.expect_warnings) {
+        warnings_emitted = warnings_emitted.map(function(input) {
+            return input.split(process.cwd() + path.sep).join("").split(path.sep).join("/");
+        });
+        var actual_warnings = JSON.stringify(warnings_emitted);
+        if (expected_warnings != actual_warnings) {
+            log([
+                "!!! failed",
+                "---INPUT---",
+                "{input}",
+                "---EXPECTED WARNINGS---",
+                "{expected_warnings}",
+                "---ACTUAL WARNINGS---",
+                "{actual_warnings}",
+                "",
+                "",
+            ].join("\n"), {
+                input: input_formatted,
+                expected_warnings: expected_warnings,
+                actual_warnings: actual_warnings,
+            });
+            return false;
+        }
+    }
+    if (test.expect_stdout && (!test.node_version || semver.satisfies(process.version, test.node_version))) {
+        var stdout = [ sandbox.run_code(input_code), sandbox.run_code(input_code, true) ];
+        var toplevel = sandbox.has_toplevel({
+            compress: test.options,
+            mangle: test.mangle
+        });
+        var actual = stdout[toplevel ? 1 : 0];
+        if (test.expect_stdout === true || test.expect_stdout instanceof Error && test.expect_stdout.name === actual.name) {
+            test.expect_stdout = actual;
+        }
+        if (!sandbox.same_stdout(test.expect_stdout, actual)) {
+            log([
+                "!!! Invalid input or expected stdout",
+                "---INPUT---",
+                "{input}",
+                "---EXPECTED {expected_type}---",
+                "{expected}",
+                "---ACTUAL {actual_type}---",
+                "{actual}",
+                "",
+                "",
+            ].join("\n"), {
+                input: input_formatted,
+                expected_type: typeof test.expect_stdout == "string" ? "STDOUT" : "ERROR",
+                expected: test.expect_stdout,
+                actual_type: typeof actual == "string" ? "STDOUT" : "ERROR",
+                actual: actual,
+            });
+            return false;
+        }
+        actual = sandbox.run_code(output_code, toplevel);
+        if (!sandbox.same_stdout(test.expect_stdout, actual)) {
+            log([
+                "!!! failed",
+                "---INPUT---",
+                "{input}",
+                "---EXPECTED {expected_type}---",
+                "{expected}",
+                "---ACTUAL {actual_type}---",
+                "{actual}",
+                "",
+                "",
+            ].join("\n"), {
+                input: input_formatted,
+                expected_type: typeof test.expect_stdout == "string" ? "STDOUT" : "ERROR",
+                expected: test.expect_stdout,
+                actual_type: typeof actual == "string" ? "STDOUT" : "ERROR",
+                actual: actual,
+            });
+            return false;
+        }
+        if (!reminify(test.options, input_code, input_formatted, stdout)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function tmpl() {
+    return U.string_template.apply(null, arguments);
+}
+
+function to_toplevel(input, mangle_options) {
+    if (!(input instanceof U.AST_BlockStatement)) throw new Error("Unsupported input syntax");
+    var directive = true;
+    var offset = input.start.line;
+    var tokens = [];
+    var toplevel = new U.AST_Toplevel(input.transform(new U.TreeTransformer(function(node) {
+        if (U.push_uniq(tokens, node.start)) node.start.line -= offset;
+        if (!directive || node === input) return;
+        if (node instanceof U.AST_SimpleStatement && node.body instanceof U.AST_String) {
+            return new U.AST_Directive(node.body);
+        } else {
+            directive = false;
+        }
+    })));
+    toplevel.figure_out_scope(mangle_options);
+    return toplevel;
+}

test/compress/annotations.js

@@ -0,0 +1,473 @@
+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,
+        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

@@ -78,12 +78,13 @@ replace_index_strict: {
     ]
 }
 
-replace_index_keep_fargs: {
+replace_index_drop_fargs_1: {
     options = {
         arguments: true,
         evaluate: true,
         keep_fargs: false,
         properties: true,
+        reduce_vars: true,
     }
     input: {
         var arguments = [];
@@ -101,6 +102,13 @@ replace_index_keep_fargs: {
             var arguments;
             console.log(arguments[1], arguments["1"], arguments["foo"]);
         })("bar", 42);
+        (function() {
+            var arguments = {
+                1: "foo",
+                foo: "bar",
+            };
+            console.log(arguments[1], arguments["1"], arguments["foo"]);
+        })("bar", 42);
     }
     expect: {
         var arguments = [];
@@ -112,10 +120,17 @@ replace_index_keep_fargs: {
             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;
+            console.log(argument_1, argument_1, arguments.foo);
         })("bar", 42);
         (function() {
-            var arguments;
+            var arguments = {
+                1: "foo",
+                foo: "bar",
+            };
             console.log(arguments[1], arguments[1], arguments.foo);
         })("bar", 42);
     }
@@ -125,10 +140,11 @@ replace_index_keep_fargs: {
         "42 42 undefined",
         "a a undefined",
         "42 42 undefined",
+        "foo foo bar",
     ]
 }
 
-replace_index_keep_fargs_strict: {
+replace_index_drop_fargs_2: {
     options = {
         arguments: true,
         evaluate: true,
@@ -237,3 +253,783 @@ duplicate_argname: {
     }
     expect_stdout: "bar 42 foo 42 bar"
 }
+
+issue_3273: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        (function(a) {
+            console.log(arguments[0], a);
+            arguments[0]++;
+            console.log(arguments[0], a);
+        })(0);
+    }
+    expect: {
+        (function(a) {
+            console.log(a, a);
+            a++;
+            console.log(a, a);
+        })(0);
+    }
+    expect_stdout: [
+        "0 0",
+        "1 1",
+    ]
+}
+
+issue_3273_no_call_arg: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        (function(a) {
+            arguments[0] = "FAIL";
+            console.log(a);
+        })();
+    }
+    expect: {
+        (function(a) {
+            arguments[0] = "FAIL";
+            console.log(a);
+        })();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_3273_reduce_vars: {
+    options = {
+        arguments: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function(a) {
+            console.log(arguments[0], a);
+            arguments[0]++;
+            console.log(arguments[0], a);
+        })(0);
+    }
+    expect: {
+        (function(a) {
+            console.log(a, a);
+            a++;
+            console.log(a, a);
+        })(0);
+    }
+    expect_stdout: [
+        "0 0",
+        "1 1",
+    ]
+}
+
+issue_3273_local_strict: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        (function(a) {
+            "use strict";
+            console.log(arguments[0], a);
+            arguments[0]++;
+            console.log(arguments[0], a);
+        })(0);
+    }
+    expect: {
+        (function(a) {
+            "use strict";
+            console.log(arguments[0], a);
+            arguments[0]++;
+            console.log(arguments[0], a);
+        })(0);
+    }
+    expect_stdout: [
+        "0 0",
+        "1 0",
+    ]
+}
+
+issue_3273_local_strict_reduce_vars: {
+    options = {
+        arguments: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function(a) {
+            "use strict";
+            console.log(arguments[0], a);
+            arguments[0]++;
+            console.log(arguments[0], a);
+        })(0);
+    }
+    expect: {
+        (function(a) {
+            "use strict";
+            console.log(arguments[0], a);
+            arguments[0]++;
+            console.log(arguments[0], a);
+        })(0);
+    }
+    expect_stdout: [
+        "0 0",
+        "1 0",
+    ]
+}
+
+issue_3273_global_strict: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        "use strict";
+        (function(a) {
+            console.log(arguments[0], a);
+            arguments[0]++;
+            console.log(arguments[0], a);
+        })(0);
+    }
+    expect: {
+        "use strict";
+        (function(a) {
+            console.log(arguments[0], a);
+            arguments[0]++;
+            console.log(arguments[0], a);
+        })(0);
+    }
+    expect_stdout: [
+        "0 0",
+        "1 0",
+    ]
+}
+
+issue_3273_global_strict_reduce_vars: {
+    options = {
+        arguments: true,
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        (function(a) {
+            console.log(arguments[0], a);
+            arguments[0]++;
+            console.log(arguments[0], a);
+        })(0);
+    }
+    expect: {
+        "use strict";
+        (function(a) {
+            console.log(arguments[0], a);
+            arguments[0]++;
+            console.log(arguments[0], a);
+        })(0);
+    }
+    expect_stdout: [
+        "0 0",
+        "1 0",
+    ]
+}
+
+issue_3273_drop_fargs_1: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        (function() {
+            "use strict";
+            arguments[0]++;
+            console.log(arguments[0]);
+        })(0);
+    }
+    expect: {
+        (function(argument_0) {
+            "use strict";
+            argument_0++;
+            console.log(argument_0);
+        })(0);
+    }
+    expect_stdout: "1"
+}
+
+issue_3273_drop_fargs_2: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        (function() {
+            "use strict";
+            arguments[0]++;
+            console.log(arguments[0]);
+        })(0);
+    }
+    expect: {
+        (function(argument_0) {
+            "use strict";
+            argument_0++;
+            console.log(argument_0);
+        })(0);
+    }
+    expect_stdout: "1"
+}
+
+issue_3282_1: {
+    options = {
+        arguments: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        (function(t) {
+            return function() {
+                t();
+            };
+        })(function() {
+            'use strict';
+            function e() {
+                return arguments[0];
+            }
+            e();
+            e();
+        })();
+    }
+    expect: {
+        (function() {
+            return function() {
+                (function() {
+                    "use strict";
+                    function e() {
+                        return arguments[0];
+                    }
+                    e();
+                    e();
+                })();
+            };
+        })()();
+    }
+    expect_stdout: true
+}
+
+issue_3282_1_passes: {
+    options = {
+        arguments: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        (function(t) {
+            return function() {
+                t();
+            };
+        })(function() {
+            'use strict';
+            function e() {
+                return arguments[0];
+            }
+            e();
+            e();
+        })();
+    }
+    expect: {
+        (function() {
+            return function() {
+                (function() {
+                    "use strict";
+                    function e(argument_0) {
+                        return argument_0;
+                    }
+                    e();
+                    e();
+                })();
+            };
+        })()();
+    }
+    expect_stdout: true
+}
+
+issue_3282_2: {
+    options = {
+        arguments: true,
+        reduce_vars: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        (function(f) {
+            f();
+        })(function() {
+            return (function(t) {
+                return function() {
+                    t();
+                };
+            })(function() {
+                'use strict';
+                function e() {
+                    return arguments[0];
+                }
+                e();
+                e();
+            })();
+        });
+    }
+    expect: {
+        (function() {
+            (function() {
+                return function(t) {
+                    return function() {
+                        t();
+                    };
+                }(function() {
+                    "use strict";
+                    function e() {
+                        return arguments[0];
+                    }
+                    e();
+                    e();
+                })();
+            })();
+        })();
+    }
+    expect_stdout: true
+}
+
+issue_3282_2_passes: {
+    options = {
+        arguments: true,
+        passes: 2,
+        reduce_vars: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        (function(f) {
+            f();
+        })(function() {
+            return (function(t) {
+                return function() {
+                    t();
+                };
+            })(function() {
+                'use strict';
+                function e() {
+                    return arguments[0];
+                }
+                e();
+                e();
+            })();
+        });
+    }
+    expect: {
+        (function() {
+            (function() {
+                return function(t) {
+                    return function() {
+                        t();
+                    };
+                }(function() {
+                    "use strict";
+                    function e(argument_0) {
+                        return argument_0;
+                    }
+                    e();
+                    e();
+                })();
+            })();
+        })();
+    }
+    expect_stdout: true
+}
+
+issue_3420_1: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            return function() {
+                return arguments[0];
+            };
+        }().length);
+    }
+    expect: {
+        console.log(function() {
+            return function() {
+                return arguments[0];
+            };
+        }().length);
+    }
+    expect_stdout: "0"
+}
+
+issue_3420_2: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        var foo = function() {
+            delete arguments[0];
+        };
+        foo();
+    }
+    expect: {
+        var foo = function() {
+            delete arguments[0];
+        };
+        foo();
+    }
+    expect_stdout: true
+}
+
+issue_3420_3: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        var foo = function() {
+            delete arguments[0];
+        };
+        foo();
+    }
+    expect: {
+        "use strict";
+        var foo = function() {
+            delete arguments[0];
+        };
+        foo();
+    }
+    expect_stdout: true
+}
+
+issue_3420_4: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        !function() {
+            console.log(arguments[0]);
+            delete arguments[0];
+            console.log(arguments[0]);
+        }(42);
+    }
+    expect: {
+        !function(argument_0) {
+            console.log(argument_0);
+            delete arguments[0];
+            console.log(arguments[0]);
+        }(42);
+    }
+    expect_stdout: [
+        "42",
+        "undefined",
+    ]
+}
+
+issue_3420_5: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        !function() {
+            console.log(arguments[0]);
+            delete arguments[0];
+            console.log(arguments[0]);
+        }(42);
+    }
+    expect: {
+        "use strict";
+        !function(argument_0) {
+            console.log(argument_0);
+            delete arguments[0];
+            console.log(arguments[0]);
+        }(42);
+    }
+    expect_stdout: [
+        "42",
+        "undefined",
+    ]
+}
+
+issue_3420_6: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            return delete arguments[0];
+        }());
+    }
+    expect: {
+        console.log(function() {
+            return delete arguments[0];
+        }());
+    }
+    expect_stdout: "true"
+}
+
+issue_3420_7: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        console.log(function() {
+            return delete arguments[0];
+        }());
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            return delete arguments[0];
+        }());
+    }
+    expect_stdout: "true"
+}
+
+issue_4200: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        var o = {
+            get p() {
+                return arguments[0];
+            },
+        };
+        console.log(o.p);
+    }
+    expect: {
+        var o = {
+            get p() {
+                return arguments[0];
+            },
+        };
+        console.log(o.p);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4291_1: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            arguments[0] = "PASS";
+            return arguments;
+        }()[0]);
+    }
+    expect: {
+        console.log(function() {
+            arguments[0] = "PASS";
+            return arguments;
+        }()[0]);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4291_2: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        var a = function() {
+            if (arguments[0])
+                arguments[1] = "PASS";
+            return arguments;
+        }(42);
+        console.log(a[1], a[0], a.length);
+    }
+    expect: {
+        var a = function() {
+            if (arguments[0])
+                arguments[1] = "PASS";
+            return arguments;
+        }(42);
+        console.log(a[1], a[0], a.length);
+    }
+    expect_stdout: "PASS 42 1"
+}
+
+issue_4397: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(typeof function() {
+            arguments += 0;
+            return arguments[0];
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            arguments += 0;
+            return arguments[0];
+        }());
+    }
+    expect_stdout: "string"
+}
+
+issue_4410_1: {
+    options = {
+        arguments: true,
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function(a) {
+            console.log(arguments[0] === (a = 0) ? "FAIL" : "PASS");
+        })(1);
+    }
+    expect: {
+        (function(a) {
+            console.log(a === (a = 0) ? "FAIL" : "PASS");
+        })(1);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4410_2: {
+    options = {
+        arguments: true,
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function f(a) {
+            console.log(arguments[0] === (a = 0) ? "FAIL" : "PASS");
+        })(1);
+    }
+    expect: {
+        (function f(a) {
+            console.log(arguments[0] === (a = 0) ? "FAIL" : "PASS");
+        })(1);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4410_3: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        var a = 1;
+        (function f(b) {
+            a-- && f();
+            for (var c = 2; c--;)
+                switch (arguments[0]) {
+                  case b = 42:
+                  case 42:
+                    console.log("PASS");
+                }
+        })(null);
+    }
+    expect: {
+        var a = 1;
+        (function f(b) {
+            a-- && f();
+            for (var c = 2; c--;)
+                switch (arguments[0]) {
+                  case b = 42:
+                  case 42:
+                    console.log("PASS");
+                }
+        })(null);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4432: {
+    options = {
+        arguments: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            for (a in { FAIL: 42 });
+            return arguments[0];
+        }() || "PASS");
+    }
+    expect: {
+        console.log(function(a) {
+            for (a in { FAIL: 42 });
+            return arguments[0];
+        }() || "PASS");
+    }
+    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,11 @@ holes_and_undefined: {
     }
 }
 
-constant_join: {
+constant_join_1: {
     options = {
         evaluate: true,
+        side_effects: true,
+        strings: true,
         unsafe: true,
     }
     input: {
@@ -56,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 = "";
     }
@@ -65,6 +67,7 @@ constant_join: {
 constant_join_2: {
     options = {
         evaluate: true,
+        strings: true,
         unsafe: true,
     }
     input: {
@@ -94,9 +97,11 @@ constant_join_2: {
 constant_join_3: {
     options = {
         evaluate: true,
+        strings: true,
         unsafe: true,
     }
     input: {
+        var foo, bar, baz;
         var a = [ null ].join();
         var b = [ , ].join();
         var c = [ , 1, , 3 ].join();
@@ -111,6 +116,7 @@ constant_join_3: {
         var l = [ foo, bar + "baz" ].join("");
     }
     expect: {
+        var foo, bar, baz;
         var a = "";
         var b = "";
         var c = ",1,,3";
@@ -239,3 +245,182 @@ index_length: {
     }
     expect_stdout: "1 2"
 }
+
+constructor_bad: {
+    options = {
+        unsafe: true
+    }
+    input: {
+        try {
+            Array(NaN);
+            console.log("FAIL1");
+        } catch (ex) {
+            try {
+                new Array(NaN);
+                console.log("FAIL2");
+            } catch (ex) {
+                console.log("PASS");
+            }
+        }
+        try {
+            Array(3.14);
+            console.log("FAIL1");
+        } catch (ex) {
+            try {
+                new Array(3.14);
+                console.log("FAIL2");
+            } catch (ex) {
+                console.log("PASS");
+            }
+        }
+    }
+    expect: {
+        try {
+            Array(NaN);
+            console.log("FAIL1");
+        } catch (ex) {
+            try {
+                Array(NaN);
+                console.log("FAIL2");
+            } catch (ex) {
+                console.log("PASS");
+            }
+        }
+        try {
+            Array(3.14);
+            console.log("FAIL1");
+        } catch (ex) {
+            try {
+                Array(3.14);
+                console.log("FAIL2");
+            } catch (ex) {
+                console.log("PASS");
+            }
+        }
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+    ]
+    expect_warnings: [
+        "WARN: Invalid array length: 3.14 [test/compress/arrays.js:13,12]",
+        "WARN: Invalid array length: 3.14 [test/compress/arrays.js:17,16]",
+    ]
+}
+
+constructor_good: {
+    options = {
+        unsafe: true
+    }
+    input: {
+        console.log(Array());
+        console.log(Array(0));
+        console.log(Array(1));
+        console.log(Array(6));
+        console.log(Array(7));
+        console.log(Array(1, 2));
+        console.log(Array(false));
+        console.log(Array("foo"));
+        console.log(Array(Array));
+        console.log(new Array());
+        console.log(new Array(0));
+        console.log(new Array(1));
+        console.log(new Array(6));
+        console.log(new Array(7));
+        console.log(new Array(1, 2));
+        console.log(new Array(false));
+        console.log(new Array("foo"));
+        console.log(new Array(Array));
+    }
+    expect: {
+        console.log([]);
+        console.log([]);
+        console.log([,]);
+        console.log([,,,,,,]);
+        console.log(Array(7));
+        console.log([ 1, 2 ]);
+        console.log([ false ]);
+        console.log([ "foo" ]);
+        console.log(Array(Array));
+        console.log([]);
+        console.log([]);
+        console.log([,]);
+        console.log([,,,,,,]);
+        console.log(Array(7));
+        console.log([ 1, 2 ]);
+        console.log([ false ]);
+        console.log([ "foo" ]);
+        console.log(Array(Array));
+    }
+    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

@@ -0,0 +1,816 @@
+no_funarg: {
+    input: {
+        (() => console.log(42))();
+    }
+    expect_exact: "(()=>console.log(42))();"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+single_funarg: {
+    input: {
+        (a => console.log(a))(42);
+    }
+    expect_exact: "(a=>console.log(a))(42);"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+multiple_funargs: {
+    input: {
+        ((a, b) => console.log(a, b))("foo", "bar");
+    }
+    expect_exact: '((a,b)=>console.log(a,b))("foo","bar");'
+    expect_stdout: "foo bar"
+    node_version: ">=4"
+}
+
+destructured_funarg: {
+    input: {
+        (([ a, b, c ]) => console.log(a, b, c))("foo");
+    }
+    expect_exact: '(([a,b,c])=>console.log(a,b,c))("foo");'
+    expect_stdout: "f o o"
+    node_version: ">=6"
+}
+
+await_parentheses: {
+    input: {
+        async function f() {
+            await (a => a);
+        }
+    }
+    expect_exact: "async function f(){await(a=>a)}"
+}
+
+for_parentheses_init: {
+    input: {
+        for (a => (a in a); console.log(42););
+    }
+    expect_exact: "for((a=>a in a);console.log(42););"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_parentheses_condition: {
+    input: {
+        for (console.log(42); a => (a in a);)
+            break;
+    }
+    expect_exact: "for(console.log(42);a=>a in a;)break;"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_parentheses_step: {
+    input: {
+        for (; console.log(42); a => (a in a));
+    }
+    expect_exact: "for(;console.log(42);a=>a in a);"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_assign_parentheses_init: {
+    input: {
+        for (f = a => (a in a); console.log(42););
+    }
+    expect_exact: "for((f=a=>a in a);console.log(42););"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_assign_parentheses_condition: {
+    input: {
+        for (console.log(42); f = a => (a in a);)
+            break;
+    }
+    expect_exact: "for(console.log(42);f=a=>a in a;)break;"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_assign_parentheses_step: {
+    input: {
+        for (; console.log(42); f = a => (a in a));
+    }
+    expect_exact: "for(;console.log(42);f=a=>a in a);"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_declaration_parentheses_init: {
+    input: {
+        for (var f = a => (a in a); console.log(42););
+    }
+    expect_exact: "for(var f=(a=>a in a);console.log(42););"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_statement_parentheses_init: {
+    input: {
+        for (a => {
+            a in a;
+        }; console.log(42););
+    }
+    expect_exact: "for(a=>{a in a};console.log(42););"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+body_call: {
+    input: {
+        (() => {
+            console.log("foo");
+            console.log("bar");
+        })();
+    }
+    expect_exact: '(()=>{console.log("foo");console.log("bar")})();'
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+body_conditional: {
+    input: {
+        console.log((a => {}) ? "PASS" : "FAIL");
+    }
+    expect_exact: 'console.log((a=>{})?"PASS":"FAIL");'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+destructured_object_value: {
+    input: {
+        console.log((a => ({} = a))(42));
+    }
+    expect_exact: "console.log((a=>({}=a))(42));"
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+function_value: {
+    input: {
+        console.log((a => function() {
+            return a;
+        })(42)());
+    }
+    expect_exact: "console.log((a=>function(){return a})(42)());"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+in_value: {
+    input: {
+        console.log((a => a in {
+            foo: 42,
+        })("foo"));
+    }
+    expect_exact: 'console.log((a=>a in{foo:42})("foo"));'
+    expect_stdout: "true"
+    node_version: ">=4"
+}
+
+object_value: {
+    input: {
+        console.log((() => ({
+            4: 2,
+        }))()[4]);
+    }
+    expect_exact: "console.log((()=>({4:2}))()[4]);"
+    expect_stdout: "2"
+    node_version: ">=4"
+}
+
+object_first_in_value: {
+    input: {
+        console.log((a => ({
+            p: a,
+        }.p ? "FAIL" : "PASS"))());
+    }
+    expect_exact: 'console.log((a=>({p:a}).p?"FAIL":"PASS")());'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+sequence_value: {
+    input: {
+        console.log((a => (console.log("foo"), a))("bar"));
+    }
+    expect_exact: 'console.log((a=>(console.log("foo"),a))("bar"));'
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+side_effects_value: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        console.log((a => function() {
+            return a;
+        })(42)());
+    }
+    expect: {
+        console.log((a => function() {
+            return a;
+        })(42)());
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+arrow_property: {
+    input: {
+        console.log((a => 42).prototype);
+    }
+    expect_exact: "console.log((a=>42).prototype);"
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+assign_arrow: {
+    input: {
+        var f = a => a;
+        console.log(f(42));
+    }
+    expect_exact: "var f=a=>a;console.log(f(42));"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+binary_arrow: {
+    input: {
+        console.log(4 || (() => 2));
+    }
+    expect_exact: "console.log(4||(()=>2));"
+    expect_stdout: "4"
+    node_version: ">=4"
+}
+
+unary_arrow: {
+    input: {
+        console.log(+(() => 42));
+    }
+    expect_exact: "console.log(+(()=>42));"
+    expect_stdout: "NaN"
+    node_version: ">=4"
+}
+
+trailing_comma: {
+    input: {
+        ((a,) => console.log(a))(42);
+    }
+    expect_exact: "(a=>console.log(a))(42);"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+drop_arguments: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            return () => arguments[0];
+        }("PASS")("FAIL"));
+    }
+    expect: {
+        console.log(function(argument_0) {
+            return () => argument_0;
+        }("PASS")("FAIL"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+funarg_arguments: {
+    options = {
+        inline: true,
+    }
+    input: {
+        console.log((arguments => arguments)(42));
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+inline_arguments: {
+    options = {
+        inline: true,
+    }
+    input: {
+        console.log(function() {
+            return () => arguments[0];
+        }("PASS")("FAIL"));
+    }
+    expect: {
+        console.log(function() {
+            return () => arguments[0];
+        }("PASS")("FAIL"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+var_arguments: {
+    options = {
+        inline: true,
+        properties: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            return () => {
+                var arguments = [ "PASS" ];
+                return arguments;
+            };
+        }("FAIL 1")("FAIL 2")[0]);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+negate: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        if (!console ? 0 : () => 1)
+            console.log("PASS");
+    }
+    expect: {
+        (console ? () => 1 : 0) && console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+inline_this: {
+    options = {
+        inline: true,
+    }
+    input: {
+        var o = {
+            p: function() {
+                return function() {
+                    return () => this.q;
+                }();
+            },
+            q: "FAIL",
+        };
+        q = "PASS";
+        console.log(o.p()());
+    }
+    expect: {
+        var o = {
+            p: function() {
+                return function() {
+                    return () => this.q;
+                }();
+            },
+            q: "FAIL",
+        };
+        q = "PASS";
+        console.log(o.p()());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+trim_body: {
+    options = {
+        arrows: true,
+        if_return: true,
+        side_effects: true,
+    }
+    input: {
+        var f = a => {
+            return a;
+        };
+        var g = b => void b;
+        console.log(f("PASS"), g("FAIL"));
+    }
+    expect: {
+        var f = a => a;
+        var g = b => {};
+        console.log(f("PASS"), g("FAIL"));
+    }
+    expect_stdout: "PASS undefined"
+    node_version: ">=4"
+}
+
+collapse_value: {
+    options = {
+        arrows: true,
+        collapse_vars: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        var a = 42;
+        console.log((b => Math.floor(b))(a));
+    }
+    expect: {
+        var a = 42;
+        console.log((() => Math.floor(a))());
+    }
+    expect_stdout: "42"
+    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,
+        keep_fargs: false,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (a => console.log(a + a))(21);
+    }
+    expect: {
+        (() => console.log(42))();
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+reduce_iife_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 21;
+        (() => console.log(a + a))();
+    }
+    expect: {
+        (() => console.log(42))();
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+reduce_iife_3: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "foo";
+        (() => {
+            console.log(a);
+            console.log(a);
+        })();
+        a = "bar";
+    }
+    expect: {
+        (() => {
+            console.log("foo");
+            console.log("foo");
+        })();
+    }
+    expect_stdout: [
+        "foo",
+        "foo",
+    ]
+    node_version: ">=4"
+}
+
+single_use_recursive: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return (() => f)();
+        }
+        console.log(typeof f());
+    }
+    expect: {
+        console.log(typeof function f() {
+            return (() => f)();
+        }());
+    }
+    expect_stdout: "function"
+    node_version: ">=4"
+}
+
+issue_4388: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        (arguments => console.log(arguments && arguments))();
+    }
+    expect: {
+        (arguments => console.log(arguments && arguments))();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4390: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        function log() {
+            console.log.apply(console, arguments);
+        }
+        var a = 42, b = "FAIL";
+        b = "PASS";
+        (c => log(b, c))(a);
+        log(b);
+    }
+    expect: {
+        function log() {
+            console.log.apply(console, arguments);
+        }
+        var a = 42, b = "FAIL";
+        b = "PASS";
+        (c => log(b, c))(a);
+        log(b);
+    }
+    expect_stdout: [
+        "PASS 42",
+        "PASS",
+    ]
+    node_version: ">=4"
+}
+
+issue_4401: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function() {
+            var a = (b => b(a))(console.log || a);
+            var c = console.log;
+            c && c(typeof b);
+        })();
+    }
+    expect: {
+        (function() {
+            var a = (b => b(a))(console.log || a);
+            var c = console.log;
+            c && c(typeof b);
+        })();
+    }
+    expect_stdout: [
+        "undefined",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_4448: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var A;
+        try {
+            (arguments => {
+                arguments[0];
+            })(A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        var A;
+        try {
+            (arguments => {
+                arguments[0];
+            })(A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4476: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        (function(a, b) {
+            (a => {
+                console.log(arguments[0], a);
+            })(b);
+        })("foo", "bar");
+    }
+    expect: {
+        (function(a, b) {
+            (a => {
+                console.log(arguments[0], a);
+            })(b);
+        })("foo", "bar");
+    }
+    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/ascii.js

@@ -1,35 +0,0 @@
-ascii_only_true: {
-    options = {}
-    beautify = {
-        ascii_only : true,
-        ie8        : false,
-        beautify   : false,
-    }
-    input: {
-        function f() {
-            return "\x000\x001\x007\x008\x00" +
-                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
-                   "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
-                   "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
-        }
-    }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\0"+"\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\b\\t\\n\\v\\f\\r\\x0e\\x0f"+"\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f"+\' !"# ... }~\\x7f\\x80\\x81 ... \\xfe\\xff\\u0fff\\uffff\'}'
-}
-
-ascii_only_false: {
-    options = {}
-    beautify = {
-        ascii_only : false,
-        ie8        : false,
-        beautify   : false,
-    }
-    input: {
-        function f() {
-            return "\x000\x001\x007\x008\x00" +
-                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
-                   "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
-                   "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
-        }
-    }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\0"+"\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f"+"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"+\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\'}'
-}

test/compress/asm.js

@@ -1,5 +1,6 @@
 asm_mixed: {
     options = {
+        assignments: true,
         booleans: true,
         comparisons: true,
         conditionals: true,
@@ -75,9 +76,8 @@ asm_mixed: {
                 start = start | 0;
                 end = end | 0;
                 var sum = 0.0, p = 0, q = 0;
-                for (p = start << 3, q = end << 3; (p | 0) < (q | 0); p = p + 8 | 0) {
+                for (p = start << 3, q = end << 3; (p | 0) < (q | 0); p = p + 8 | 0)
                     sum = sum + +log(values[p >> 3]);
-                }
                 return +sum;
             }
             function geometricMean(start, end) {
@@ -90,12 +90,12 @@ asm_mixed: {
         function no_asm_GeometricMean(stdlib, foreign, buffer) {
             function logSum(start, end) {
                 start |= 0, end |= 0;
-                var sum = 0, p = 0, q = 0;
-                for (p = start << 3, q = end << 3; (0 | p) < (0 | q); p = p + 8 | 0) sum += +log(values[p >> 3]);
+                for (var sum = 0, p = 0, q = 0, p = start << 3, q = end << 3; (0 | p) < (0 | q); p = p + 8 | 0)
+                    sum += +log(values[p >> 3]);
                 return +sum;
             }
             function geometricMean(start, end) {
-                return start |= 0, end |= 0, +exp(+logSum(start, end) / +(end - start | 0));
+                return start |= 0, end |= 0, +exp(+logSum(start, end) / (end - start | 0));
             }
             var exp = stdlib.Math.exp, log = stdlib.Math.log, values = new stdlib.Float64Array(buffer);
             return { geometricMean: geometricMean };
@@ -165,3 +165,69 @@ asm_nested_functions: {
     }
     expect_exact: '0;function a(){"use asm";0.0}0;function b(){0;function c(){"use asm";0.0}0;function d(){0}0}0;'
 }
+
+issue_3636_1: {
+    mangle = {}
+    input: {
+        function n(stdlib, foreign, buffer) {
+            "use asm";
+            function add(x, y) {
+                x = x | 0;
+                y = y | 0;
+                return x + y | 0;
+            }
+            return {
+                add: add
+            };
+        }
+        console.log(new n().add("foo", 42));
+    }
+    expect: {
+        function n(o, e, u) {
+            "use asm";
+            function d(n, o) {
+                n = n | 0;
+                o = o | 0;
+                return n + o | 0;
+            }
+            return {
+                add: d
+            };
+        }
+        console.log(new n().add("foo", 42));
+    }
+    expect_stdout: "42"
+}
+
+issue_3636_2: {
+    mangle = {}
+    input: {
+        var n = function(stdlib, foreign, buffer) {
+            "use asm";
+            function add(x, y) {
+                x = x | 0;
+                y = y | 0;
+                return x + y | 0;
+            }
+            return {
+                add: add
+            };
+        };
+        console.log(new n().add("foo", 42));
+    }
+    expect: {
+        var n = function(n, o, e) {
+            "use asm";
+            function r(n, o) {
+                n = n | 0;
+                o = o | 0;
+                return n + o | 0;
+            }
+            return {
+                add: r
+            };
+        };
+        console.log(new n().add("foo", 42));
+    }
+    expect_stdout: "42"
+}

test/compress/assignment.js

@@ -1,238 +0,0 @@
-op_equals_left_local_var: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        var x;
-
-        x = x +   3;
-        x = x -   3;
-        x = x /   3;
-        x = x *   3;
-        x = x >>  3;
-        x = x <<  3;
-        x = x >>> 3;
-        x = x |   3;
-        x = x ^   3;
-        x = x %   3;
-        x = x &   3;
-
-        x = x +   g();
-        x = x -   g();
-        x = x /   g();
-        x = x *   g();
-        x = x >>  g();
-        x = x <<  g();
-        x = x >>> g();
-        x = x |   g();
-        x = x ^   g();
-        x = x %   g();
-        x = x &   g();
-    }
-    expect: {
-        var x;
-
-        x   += 3;
-        x   -= 3;
-        x   /= 3;
-        x   *= 3;
-        x  >>= 3;
-        x  <<= 3;
-        x >>>= 3;
-        x   |= 3;
-        x   ^= 3;
-        x   %= 3;
-        x   &= 3;
-
-        x   += g();
-        x   -= g();
-        x   /= g();
-        x   *= g();
-        x  >>= g();
-        x  <<= g();
-        x >>>= g();
-        x   |= g();
-        x   ^= g();
-        x   %= g();
-        x   &= g();
-    }
-}
-
-op_equals_right_local_var: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        var x;
-
-        x = (x -= 2) ^ x;
-
-        x = 3 +   x;
-        x = 3 -   x;
-        x = 3 /   x;
-        x = 3 *   x;
-        x = 3 >>  x;
-        x = 3 <<  x;
-        x = 3 >>> x;
-        x = 3 |   x;
-        x = 3 ^   x;
-        x = 3 %   x;
-        x = 3 &   x;
-
-        x = g() +   x;
-        x = g() -   x;
-        x = g() /   x;
-        x = g() *   x;
-        x = g() >>  x;
-        x = g() <<  x;
-        x = g() >>> x;
-        x = g() |   x;
-        x = g() ^   x;
-        x = g() %   x;
-        x = g() &   x;
-    }
-    expect: {
-        var x;
-
-        x = (x -= 2) ^ x;
-
-        x = 3 + x;
-        x = 3 - x;
-        x = 3 / x;
-        x *= 3;
-        x = 3 >> x;
-        x = 3 << x;
-        x = 3 >>> x;
-        x |= 3;
-        x ^= 3;
-        x = 3 % x;
-        x &= 3;
-
-        x = g() +   x;
-        x = g() -   x;
-        x = g() /   x;
-        x = g() *   x;
-        x = g() >>  x;
-        x = g() <<  x;
-        x = g() >>> x;
-        x = g() |   x;
-        x = g() ^   x;
-        x = g() %   x;
-        x = g() &   x;
-    }
-}
-op_equals_left_global_var: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        x = x +   3;
-        x = x -   3;
-        x = x /   3;
-        x = x *   3;
-        x = x >>  3;
-        x = x <<  3;
-        x = x >>> 3;
-        x = x |   3;
-        x = x ^   3;
-        x = x %   3;
-        x = x &   3;
-
-        x = x +   g();
-        x = x -   g();
-        x = x /   g();
-        x = x *   g();
-        x = x >>  g();
-        x = x <<  g();
-        x = x >>> g();
-        x = x |   g();
-        x = x ^   g();
-        x = x %   g();
-        x = x &   g();
-    }
-    expect: {
-        x   += 3;
-        x   -= 3;
-        x   /= 3;
-        x   *= 3;
-        x  >>= 3;
-        x  <<= 3;
-        x >>>= 3;
-        x   |= 3;
-        x   ^= 3;
-        x   %= 3;
-        x   &= 3;
-
-        x   += g();
-        x   -= g();
-        x   /= g();
-        x   *= g();
-        x  >>= g();
-        x  <<= g();
-        x >>>= g();
-        x   |= g();
-        x   ^= g();
-        x   %= g();
-        x   &= g();
-    }
-}
-
-op_equals_right_global_var: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        x = (x -= 2) ^ x;
-
-        x = 3 +   x;
-        x = 3 -   x;
-        x = 3 /   x;
-        x = 3 *   x;
-        x = 3 >>  x;
-        x = 3 <<  x;
-        x = 3 >>> x;
-        x = 3 |   x;
-        x = 3 ^   x;
-        x = 3 %   x;
-        x = 3 &   x;
-
-        x = g() +   x;
-        x = g() -   x;
-        x = g() /   x;
-        x = g() *   x;
-        x = g() >>  x;
-        x = g() <<  x;
-        x = g() >>> x;
-        x = g() |   x;
-        x = g() ^   x;
-        x = g() %   x;
-        x = g() &   x;
-    }
-    expect: {
-        x = (x -= 2) ^ x;
-
-        x = 3 +   x;
-        x = 3 -   x;
-        x = 3 /   x;
-        x *= 3;
-        x = 3 >>  x;
-        x = 3 <<  x;
-        x = 3 >>> x;
-        x |= 3;
-        x ^= 3;
-        x = 3 %   x;
-        x &= 3;
-
-        x = g() +   x;
-        x = g() -   x;
-        x = g() /   x;
-        x = g() *   x;
-        x = g() >>  x;
-        x = g() <<  x;
-        x = g() >>> x;
-        x = g() |   x;
-        x = g() ^   x;
-        x = g() %   x;
-        x = g() &   x;
-    }
-}

test/compress/assignments.js

@@ -0,0 +1,477 @@
+op_equals_left_local_var: {
+    options = {
+        assignments: true,
+        evaluate: true,
+    }
+    input: {
+        var x;
+
+        x = x +   3;
+        x = x -   3;
+        x = x /   3;
+        x = x *   3;
+        x = x >>  3;
+        x = x <<  3;
+        x = x >>> 3;
+        x = x |   3;
+        x = x ^   3;
+        x = x %   3;
+        x = x &   3;
+
+        x = x +   g();
+        x = x -   g();
+        x = x /   g();
+        x = x *   g();
+        x = x >>  g();
+        x = x <<  g();
+        x = x >>> g();
+        x = x |   g();
+        x = x ^   g();
+        x = x %   g();
+        x = x &   g();
+    }
+    expect: {
+        var x;
+
+        x   += 3;
+        x   -= 3;
+        x   /= 3;
+        x   *= 3;
+        x  >>= 3;
+        x  <<= 3;
+        x >>>= 3;
+        x   |= 3;
+        x   ^= 3;
+        x   %= 3;
+        x   &= 3;
+
+        x   += g();
+        x   -= g();
+        x   /= g();
+        x   *= g();
+        x  >>= g();
+        x  <<= g();
+        x >>>= g();
+        x   |= g();
+        x   ^= g();
+        x   %= g();
+        x   &= g();
+    }
+}
+
+op_equals_right_local_var: {
+    options = {
+        assignments: true,
+        evaluate: true,
+    }
+    input: {
+        var x;
+
+        x = (x -= 2) ^ x;
+
+        x = 3 +   x;
+        x = 3 -   x;
+        x = 3 /   x;
+        x = 3 *   x;
+        x = 3 >>  x;
+        x = 3 <<  x;
+        x = 3 >>> x;
+        x = 3 |   x;
+        x = 3 ^   x;
+        x = 3 %   x;
+        x = 3 &   x;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+    expect: {
+        var x;
+
+        x = (x -= 2) ^ x;
+
+        x = 3 + x;
+        x = 3 - x;
+        x = 3 / x;
+        x *= 3;
+        x = 3 >> x;
+        x = 3 << x;
+        x = 3 >>> x;
+        x |= 3;
+        x ^= 3;
+        x = 3 % x;
+        x &= 3;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+}
+op_equals_left_global_var: {
+    options = {
+        assignments: true,
+        evaluate: true,
+    }
+    input: {
+        x = x +   3;
+        x = x -   3;
+        x = x /   3;
+        x = x *   3;
+        x = x >>  3;
+        x = x <<  3;
+        x = x >>> 3;
+        x = x |   3;
+        x = x ^   3;
+        x = x %   3;
+        x = x &   3;
+
+        x = x +   g();
+        x = x -   g();
+        x = x /   g();
+        x = x *   g();
+        x = x >>  g();
+        x = x <<  g();
+        x = x >>> g();
+        x = x |   g();
+        x = x ^   g();
+        x = x %   g();
+        x = x &   g();
+    }
+    expect: {
+        x   += 3;
+        x   -= 3;
+        x   /= 3;
+        x   *= 3;
+        x  >>= 3;
+        x  <<= 3;
+        x >>>= 3;
+        x   |= 3;
+        x   ^= 3;
+        x   %= 3;
+        x   &= 3;
+
+        x   += g();
+        x   -= g();
+        x   /= g();
+        x   *= g();
+        x  >>= g();
+        x  <<= g();
+        x >>>= g();
+        x   |= g();
+        x   ^= g();
+        x   %= g();
+        x   &= g();
+    }
+}
+
+op_equals_right_global_var: {
+    options = {
+        assignments: true,
+        evaluate: true,
+    }
+    input: {
+        x = (x -= 2) ^ x;
+
+        x = 3 +   x;
+        x = 3 -   x;
+        x = 3 /   x;
+        x = 3 *   x;
+        x = 3 >>  x;
+        x = 3 <<  x;
+        x = 3 >>> x;
+        x = 3 |   x;
+        x = 3 ^   x;
+        x = 3 %   x;
+        x = 3 &   x;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+    expect: {
+        x = (x -= 2) ^ x;
+
+        x = 3 +   x;
+        x = 3 -   x;
+        x = 3 /   x;
+        x *= 3;
+        x = 3 >>  x;
+        x = 3 <<  x;
+        x = 3 >>> x;
+        x |= 3;
+        x ^= 3;
+        x = 3 %   x;
+        x &= 3;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+}
+
+increment_decrement_1: {
+    options = {
+        assignments: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            a += 1;
+            a -= 1;
+            return a;
+        }(42));
+    }
+    expect: {
+        console.log(function(a){
+            ++a;
+            --a;
+            return a;
+        }(42));
+    }
+    expect_stdout: "42"
+}
+
+increment_decrement_2: {
+    options = {
+        assignments: true,
+        passes: 2,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            a = a + 1;
+            a = a - 1;
+            a += 1;
+            a -= 1;
+            return a;
+        }(42));
+    }
+    expect: {
+        console.log(function(a){
+            ++a;
+            --a;
+            ++a;
+            --a;
+            return a;
+        }(42));
+    }
+    expect_stdout: "42"
+}
+
+issue_3375_1: {
+    options = {
+        assignments: true,
+        reduce_vars: true,
+    }
+    input: {
+        function p(o) {
+            console.log(typeof o, o);
+        }
+        p(function(b) {
+            var a = b += 1;
+            --b;
+            return a;
+        }("object"));
+    }
+    expect: {
+        function p(o) {
+            console.log(typeof o, o);
+        }
+        p(function(b) {
+            var a = b += 1;
+            --b;
+            return a;
+        }("object"));
+    }
+    expect_stdout: "string object1"
+}
+
+issue_3375_2: {
+    options = {
+        assignments: true,
+        reduce_vars: true,
+    }
+    input: {
+        function p(o) {
+            console.log(typeof o, o);
+        }
+        p(function(b) {
+            var a = b -= 1;
+            --b;
+            return a;
+        }("object"));
+    }
+    expect: {
+        function p(o) {
+            console.log(typeof o, o);
+        }
+        p(function(b) {
+            var a = --b;
+            --b;
+            return a;
+        }("object"));
+    }
+    expect_stdout: "number NaN"
+}
+
+issue_3427: {
+    options = {
+        assignments: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a;
+            a || (a = {});
+        })();
+    }
+    expect: {}
+}
+
+issue_3429_1: {
+    options = {
+        assignments: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        (function(b) {
+            b && (b = a = "FAIL");
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (function(b) {
+            b = b && (a = "FAIL");
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3429_2: {
+    options = {
+        assignments: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        (function(b) {
+            b || (b = a = "FAIL");
+        })(42);
+        console.log(a);
+    }
+    expect: {
+        var a;
+        (function(b) {
+            b = b || (a = "FAIL");
+        })(42);
+        console.log(a);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_3949_1: {
+    options = {
+        assignments: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        var a = 42;
+        function f() {
+            var b = a;
+            b = b >> 2;
+            return 100 + b;
+        }
+        console.log(f());
+    }
+    expect: {
+        var a = 42;
+        function f() {
+            var b = a;
+            b >>= 2;
+            return 100 + b;
+        }
+        console.log(f());
+    }
+    expect_stdout: "110"
+}
+
+issue_3949_2: {
+    options = {
+        assignments: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        var a = 42;
+        function f() {
+            var b = a;
+            b = 5 & b;
+            return 100 + b;
+        }
+        console.log(f());
+    }
+    expect: {
+        var a = 42;
+        function f() {
+            var b = a;
+            b &= 5;
+            return 100 + b;
+        }
+        console.log(f());
+    }
+    expect_stdout: "100"
+}
+
+issue_4521: {
+    options = {
+        assignments: true,
+        dead_code: true,
+    }
+    input: {
+        var a = (a = 42 | a) ? console.log(a) : 0;
+    }
+    expect: {
+        var a = (a |= 42) ? console.log(a) : 0;
+    }
+    expect_stdout: "42"
+}

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/booleans.js

@@ -0,0 +1,183 @@
+iife_boolean_context: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        console.log(function() {
+            return Object(1) || false;
+        }() ? "PASS" : "FAIL");
+        console.log(function() {
+            return [].length || true;
+        }() ? "PASS" : "FAIL");
+    }
+    expect: {
+        console.log(function() {
+            return Object(1);
+        }() ? "PASS" : "FAIL");
+        console.log(function() {
+            return [].length, 1;
+        }() ? "PASS" : "FAIL");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+    ]
+    expect_warnings: [
+        "WARN: Dropping side-effect-free || [test/compress/booleans.js:2,19]",
+        "WARN: Boolean || always true [test/compress/booleans.js:5,19]",
+    ]
+}
+
+issue_3465_1: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        console.log(function(a) {
+            return typeof a;
+        }() ? "PASS" : "FAIL");
+    }
+    expect: {
+        console.log(function(a) {
+            return 1;
+        }() ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3465_2: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        console.log(function f(a) {
+            if (!a) console.log(f(42));
+            return typeof a;
+        }() ? "PASS" : "FAIL");
+    }
+    expect: {
+        console.log(function f(a) {
+            if (!a) console.log(f(42));
+            return typeof a;
+        }() ? "PASS" : "FAIL");
+    }
+    expect_stdout: [
+        "number",
+        "PASS",
+    ]
+}
+
+issue_3465_3: {
+    options = {
+        booleans: true,
+        passes: 2,
+        unused: true,
+    }
+    input: {
+        console.log(function f(a) {
+            return typeof a;
+        }() ? "PASS" : "FAIL");
+    }
+    expect: {
+        console.log(function(a) {
+            return 1;
+        }() ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2737_2: {
+    options = {
+        booleans: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(bar) {
+            for (;bar();) break;
+        })(function qux() {
+            return console.log("PASS"), qux;
+        });
+    }
+    expect: {
+        (function(bar) {
+            for (;bar();) break;
+        })(function() {
+            return console.log("PASS"), 1;
+        });
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3658: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function f() {
+            console || f();
+            return "PASS";
+        }());
+    }
+    expect: {
+        console.log(function f() {
+            console || f();
+            return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3690: {
+    options = {
+        booleans: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            return function() {
+                return a = [ this ];
+            }() ? "PASS" : "FAIL";
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            return function() {
+                return 1;
+            }() ? "PASS" : "FAIL";
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4374: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        if_return: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            console.log(f());
+            function f(a) {
+                if (null) return 0;
+                if (a) return 1;
+                return 0;
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            console.log(function(a) {
+                return !null && a ? 1 : 0;
+            }());
+        })();
+    }
+    expect_stdout: "0"
+}

test/compress/comparisons.js

@@ -33,10 +33,10 @@ unsafe_comps: {
     }
     expect: {
         var obj1, obj2;
-        obj2 <  obj1 ? g1() : f1();
-        obj1 <  obj2 ? f2() : g2();
-        obj1 <  obj2 ? g3() : f3();
-        obj2 <  obj1 ? f4() : g4();
+        (obj2 <  obj1 ? g1 : f1)();
+        (obj1 <  obj2 ? f2 : g2)();
+        (obj1 <  obj2 ? g3 : f3)();
+        (obj2 <  obj1 ? f4 : g4)();
     }
 }
 
@@ -93,6 +93,59 @@ self_comparison_2: {
     expect_stdout: "false true"
 }
 
+self_comparison_3: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        var a;
+        function f() {
+            var b = a;
+            a = null;
+            return b;
+        }
+        for (var i = 0; i < 2; i++)
+            console.log(f() === f());
+    }
+    expect: {
+        var a;
+        function f() {
+            var b = a;
+            a = null;
+            return b;
+        }
+        for (var i = 0; i < 2; i++)
+            console.log(f() === f());
+    }
+    expect_stdout: [
+        "false",
+        "true",
+    ]
+}
+
+self_comparison_4: {
+    options = {
+        booleans: true,
+        comparisons: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {};
+        console.log(o == o, o != o);
+        console.log(o === o, o !== o);
+    }
+    expect: {
+        console.log(!0, !1);
+        console.log(!0, !1);
+    }
+    expect_stdout: [
+        "true false",
+        "true false",
+    ]
+}
+
 issue_2857_1: {
     options = {
         comparisons: true,
@@ -323,3 +376,120 @@ is_number_unsafe: {
     }
     expect_stdout: "true"
 }
+
+is_boolean_var: {
+    options = {
+        comparisons: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a, b) {
+            for (var i = 0, c = !b; i < a.length; i++)
+                if (!a[i] === c)
+                    return i;
+        }([ false, true ], 42));
+    }
+    expect: {
+        console.log(function(a, b) {
+            for (var i = 0, c = !b; i < a.length; i++)
+                if (!a[i] == c)
+                    return i;
+        }([ false, true ], 42));
+    }
+    expect_stdout: "1"
+}
+
+is_defined: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        console.log(function a() {
+            return void 0 === a;
+        }());
+    }
+    expect: {
+        console.log(function a() {
+            return a, false;
+        }());
+    }
+    expect_stdout: "false"
+    expect_warnings: [
+        "WARN: Expression always defined [test/compress/comparisons.js:2,19]",
+    ]
+}
+
+unsafe_indexOf: {
+    options = {
+        booleans: true,
+        comparisons: true,
+        unsafe: true,
+    }
+    input: {
+        var a = Object.keys({ foo: 42 });
+        if (a.indexOf("bar") < 0) console.log("PASS");
+        if (0 > a.indexOf("bar")) console.log("PASS");
+        if (a.indexOf("foo") >= 0) console.log("PASS");
+        if (0 <= a.indexOf("foo")) console.log("PASS");
+        if (a.indexOf("foo") > -1) console.log("PASS");
+        if (-1 < a.indexOf("foo")) console.log("PASS");
+        if (a.indexOf("bar") == -1) console.log("PASS");
+        if (-1 == a.indexOf("bar")) console.log("PASS");
+        if (a.indexOf("bar") === -1) console.log("PASS");
+        if (-1 === a.indexOf("bar")) console.log("PASS");
+        if (a.indexOf("foo") != -1) console.log("PASS");
+        if (-1 != a.indexOf("foo")) console.log("PASS");
+        if (a.indexOf("foo") !== -1) console.log("PASS");
+        if (-1 !== a.indexOf("foo")) console.log("PASS");
+    }
+    expect: {
+        var a = Object.keys({ foo: 42 });
+        if (!~a.indexOf("bar")) console.log("PASS");
+        if (!~a.indexOf("bar")) console.log("PASS");
+        if (~a.indexOf("foo")) console.log("PASS");
+        if (~a.indexOf("foo")) console.log("PASS");
+        if (~a.indexOf("foo")) console.log("PASS");
+        if (~a.indexOf("foo")) console.log("PASS");
+        if (!~a.indexOf("bar")) console.log("PASS");
+        if (!~a.indexOf("bar")) console.log("PASS");
+        if (!~a.indexOf("bar")) console.log("PASS");
+        if (!~a.indexOf("bar")) console.log("PASS");
+        if (~a.indexOf("foo")) console.log("PASS");
+        if (~a.indexOf("foo")) console.log("PASS");
+        if (~a.indexOf("foo")) console.log("PASS");
+        if (~a.indexOf("foo")) console.log("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+}
+
+issue_3413: {
+    options = {
+        comparisons: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        var b;
+        void 0 !== ("" < b || void 0) || console.log("PASS");
+    }
+    expect: {
+        var b;
+        void 0 !== ("" < b || void 0) || console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}

test/compress/concat-strings.js

@@ -26,7 +26,9 @@ concat_1: {
 }
 
 concat_2: {
-    options = {}
+    options = {
+        strings: true,
+    }
     input: {
         console.log(
             1 + (2 + 3),
@@ -55,7 +57,9 @@ concat_2: {
 }
 
 concat_3: {
-    options = {}
+    options = {
+        strings: true,
+    }
     input: {
         console.log(
             1 + 2 + (3 + 4 + 5),
@@ -84,7 +88,9 @@ concat_3: {
 }
 
 concat_4: {
-    options = {}
+    options = {
+        strings: true,
+    }
     input: {
         console.log(
             1 + "2" + (3 + 4 + 5),
@@ -113,7 +119,9 @@ concat_4: {
 }
 
 concat_5: {
-    options = {}
+    options = {
+        strings: true,
+    }
     input: {
         console.log(
             "1" + 2 + (3 + 4 + 5),
@@ -142,7 +150,9 @@ concat_5: {
 }
 
 concat_6: {
-    options = {}
+    options = {
+        strings: true,
+    }
     input: {
         console.log(
             "1" + "2" + (3 + 4 + 5),
@@ -171,6 +181,9 @@ concat_6: {
 }
 
 concat_7: {
+    options = {
+        strings: true,
+    }
     input: {
         console.log(
             "" + 1,
@@ -197,6 +210,9 @@ concat_7: {
 }
 
 concat_8: {
+    options = {
+        strings: true,
+    }
     input: {
         console.log(
             1 + "",
@@ -221,3 +237,55 @@ concat_8: {
     }
     expect_stdout: true
 }
+
+concat_9: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        reduce_vars: true,
+        strings: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "foo";
+        console.log(
+            12 + (34 + a),
+            null + (34 + a),
+            12 + (null + a),
+            false + (34 + a),
+            12 + (false + a),
+            "bar" + (34 + a),
+            12 + ("bar" + a)
+        );
+    }
+    expect: {
+        var a = "foo";
+        console.log(
+            "1234" + a,
+            "null34" + a,
+            "12null" + a,
+            !1 + (34 + a),
+            12 + (!1 + a),
+            "bar34" + a,
+            "12bar" + a
+        );
+    }
+    expect_stdout: true
+}
+
+issue_3689: {
+    options = {
+        strings: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a + ("" + (a[0] = 0));
+        }([]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a + ("" + (a[0] = 0));
+        }([]));
+    }
+    expect_stdout: "00"
+}

test/compress/conditionals.js

@@ -41,7 +41,7 @@ ifs_2: {
     }
     expect: {
         foo ? x() : bar ? y() : baz && z();
-        foo ? x() : bar ? y() : baz ? z() : t();
+        (foo ? x : bar ? y : baz ? z : t)();
     }
 }
 
@@ -55,14 +55,15 @@ ifs_3_should_warn: {
     }
     input: {
         var x, y;
-        if (x && !(x + "1") && y) { // 1
+        // 1
+        if (x && !(x + "1") && y) {
             var qq;
             foo();
         } else {
             bar();
         }
-
-        if (x || !!(x + "1") || y) { // 2
+        // 2
+        if (x || !!(x + "1") || y) {
             foo();
         } else {
             var jj;
@@ -71,9 +72,25 @@ ifs_3_should_warn: {
     }
     expect: {
         var x, y;
-        var qq; bar();          // 1
-        var jj; foo();          // 2
+        // 1
+        var qq; bar();
+        // 2
+        foo(); var jj;
     }
+    expect_warnings: [
+        "WARN: + in boolean context always true [test/compress/conditionals.js:3,18]",
+        "WARN: Boolean && always false [test/compress/conditionals.js:3,12]",
+        "WARN: Condition left of && always false [test/compress/conditionals.js:3,12]",
+        "WARN: Condition always false [test/compress/conditionals.js:3,12]",
+        "WARN: Dropping unreachable code [test/compress/conditionals.js:3,34]",
+        "WARN: + in boolean context always true [test/compress/conditionals.js:10,19]",
+        "WARN: Boolean || always true [test/compress/conditionals.js:10,12]",
+        "WARN: Condition left of || always true [test/compress/conditionals.js:10,12]",
+        "WARN: Condition always true [test/compress/conditionals.js:10,12]",
+        "WARN: Dropping unreachable code [test/compress/conditionals.js:12,15]",
+        "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:3,12]",
+        "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:10,12]",
+    ]
 }
 
 ifs_4: {
@@ -161,6 +178,24 @@ ifs_6: {
     }
 }
 
+ifs_7: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        if (A); else;
+        if (A) while (B); else;
+        if (A); else while (C);
+        if (A) while (B); else while (C);
+    }
+    expect: {
+        A;
+        if (A) while (B);
+        if (!A) while (C);
+        if (A) while (B); else while (C);
+    }
+}
+
 cond_1: {
     options = {
         conditionals: true,
@@ -271,11 +306,50 @@ cond_5: {
         }
     }
     expect: {
-        some_condition() && some_other_condition() ? do_something() : alternate();
+        (some_condition() && some_other_condition() ? do_something : alternate)();
         some_condition() && some_other_condition() && do_something();
     }
 }
 
+cond_6: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        x ? a : b;
+        x ? a : a;
+
+        x ? y ? a : b : c;
+        x ? y ? a : a : b;
+        x ? y ? a : b : b;
+        x ? y ? a : b : a;
+        x ? y ? a : a : a;
+
+        x ? a : y ? b : c;
+        x ? a : y ? a : b;
+        x ? a : y ? b : b;
+        x ? a : y ? b : a;
+        x ? a : y ? a : a;
+    }
+    expect: {
+        x ? a : b;
+        x, a;
+
+        x ? y ? a : b : c;
+        x ? (y, a) : b;
+        x && y ? a : b;
+        !x || y ? a : b;
+        x && y, a;
+
+        x ? a : y ? b : c;
+        x || y ? a : b;
+        x ? a : (y, b);
+        !x && y ? b : a;
+        !x && y, a;
+    }
+}
+
 cond_7: {
     options = {
         conditionals: true,
@@ -645,6 +719,109 @@ cond_9: {
     }
 }
 
+cond_10: {
+    options = {
+        conditionals: true,
+        if_return: true,
+    }
+    input: {
+        function f(a) {
+            if (1 == a) return "foo";
+            if (2 == a) return "foo";
+            if (3 == a) return "foo";
+            if (4 == a) return 42;
+            if (5 == a) return "foo";
+            if (6 == a) return "foo";
+            return "bar";
+        }
+        console.log(f(1), f(2), f(3), f(4), f(5), f(6), f(7));
+    }
+    expect: {
+        function f(a) {
+            return 1 == a || 2 == a || 3 == a ? "foo" : 4 == a ? 42 : 5 == a || 6 == a ? "foo" : "bar";
+        }
+        console.log(f(1), f(2), f(3), f(4), f(5), f(6), f(7));
+    }
+    expect_stdout: "foo foo foo 42 foo foo bar"
+}
+
+cond_11: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var o = {
+            p: "foo",
+            q: function() {
+                return this.p;
+            }
+        };
+        function f() {
+            return "bar";
+        }
+        function g(a) {
+            return a ? f() : o.q();
+        }
+        console.log(g(0), g(1));
+    }
+    expect: {
+        var o = {
+            p: "foo",
+            q: function() {
+                return this.p;
+            }
+        };
+        function f() {
+            return "bar";
+        }
+        function g(a) {
+            return a ? f() : o.q();
+        }
+        console.log(g(0), g(1));
+    }
+    expect_stdout: "foo bar"
+}
+
+cond_12: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        x ? y && a : a;
+        x ? y || a : a;
+        x ? a : y && a;
+        x ? a : y || a;
+    }
+    expect: {
+        (!x || y) && a;
+        x && y || a;
+        (x || y) && a;
+        !x && y || a;
+    }
+}
+
+cond_13: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        x ? y(a) : z(a);
+        x ? y.f(a) : z.f(a);
+        x ? y.f(a) : z.g(a);
+        x ? y.f()(a) : z.g()(a);
+        x ? y.f.u(a) : z.g.u(a);
+        x ? y.f().u(a) : z.g().u(a);
+    }
+    expect: {
+        (x ? y : z)(a);
+        (x ? y : z).f(a);
+        x ? y.f(a) : z.g(a);
+        (x ? y.f() : z.g())(a);
+        (x ? y.f : z.g).u(a);
+        (x ? y.f() : z.g()).u(a);
+    }
+}
+
 ternary_boolean_consequent: {
     options = {
         booleans: true,
@@ -999,7 +1176,7 @@ issue_1645_2: {
     expect_stdout: true
 }
 
-condition_symbol_matches_consequent: {
+condition_matches_consequent: {
     options = {
         conditionals: true,
     }
@@ -1028,6 +1205,35 @@ condition_symbol_matches_consequent: {
     expect_stdout: "3 7 true 4"
 }
 
+condition_matches_alternative: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function foo(x, y) {
+            return x.p ? y[0] : x.p;
+        }
+        function bar() {
+            return g ? h : g;
+        }
+        var g = 4;
+        var h = 5;
+        console.log(foo({ p: 3 }, [ null ]), foo({ p: 0 }, [ 7 ]), foo({ p: true } , [ false ]), bar());
+    }
+    expect: {
+        function foo(x, y) {
+            return x.p && y[0];
+        }
+        function bar() {
+            return g && h;
+        }
+        var g = 4;
+        var h = 5;
+        console.log(foo({ p: 3 }, [ null ]), foo({ p: 0 }, [ 7 ]), foo({ p: true } , [ false ]), bar());
+    }
+    expect_stdout: "null 0 false 5"
+}
+
 delete_conditional_1: {
     options = {
         booleans: true,
@@ -1102,11 +1308,11 @@ issue_2535_1: {
     expect: {
         y();
         x() && y();
-        (x(), 1) && y();
+        x(), y();
         x() && y();
         x() && y();
         x() && y();
-        (x(), 0) && y();
+        x();
     }
 }
 
@@ -1246,7 +1452,7 @@ hoist_decl: {
     }
     expect: {
         var a, b;
-        x() ? y() : z();
+        (x() ? y : z)();
     }
 }
 
@@ -1292,3 +1498,402 @@ to_and_or: {
     }
     expect_stdout: true
 }
+
+cond_seq_assign_1: {
+    options = {
+        conditionals: true,
+        sequences: true,
+    }
+    input: {
+        function f(a) {
+            var t;
+            if (a) {
+                t = "foo";
+                t = "bar";
+            } else {
+                console.log(t);
+                t = 42;
+            }
+            console.log(t);
+        }
+        f(f);
+        f();
+    }
+    expect: {
+        function f(a) {
+            var t;
+            t = a ? (t = "foo", "bar") : (console.log(t), 42),
+            console.log(t);
+        }
+        f(f),
+        f();
+    }
+    expect_stdout: [
+        "bar",
+        "undefined",
+        "42",
+    ]
+}
+
+cond_seq_assign_2: {
+    options = {
+        conditionals: true,
+        sequences: true,
+    }
+    input: {
+        function f(a) {
+            var t;
+            if (a) {
+                t = "foo";
+                a = "bar";
+            } else {
+                console.log(t);
+                t = 42;
+            }
+            console.log(t);
+        }
+        f(f);
+        f();
+    }
+    expect: {
+        function f(a) {
+            var t;
+            a ? (t = "foo", a = "bar") : (console.log(t), t = 42),
+            console.log(t);
+        }
+        f(f),
+        f();
+    }
+    expect_stdout: [
+        "foo",
+        "undefined",
+        "42",
+    ]
+}
+
+cond_seq_assign_3: {
+    options = {
+        assignments: true,
+        conditionals: true,
+    }
+    input: {
+        var c = 0;
+        if (this)
+            c = 1 + c, c = c + 1;
+        else
+            c = 1 + c, c = c + 1;
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        this, c = 1 + c, c += 1;
+        console.log(c);
+    }
+    expect_stdout: "2"
+}
+
+issue_3271: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var i = 0, b = [];
+            if (a) {
+                b[i++] = 4,
+                b[i++] = 1;
+            } else {
+                b[i++] = 3,
+                b[i++] = 2,
+                b[i++] = 1;
+            }
+            return b;
+        }
+        console.log(f(0).pop(), f(1).pop());
+    }
+    expect: {
+        function f(a) {
+            var i = 0, b = [];
+            a ? b[i++] = 4 : (b[i++] = 3, b[i++] = 2),
+            b[i++] = 1;
+            return b;
+        }
+        console.log(f(0).pop(), f(1).pop());
+    }
+    expect_stdout: "1 1"
+}
+
+iife_condition: {
+    options = {
+        conditionals: true,
+        side_effects: true,
+    }
+    input: {
+        if (function() {
+            return console;
+        }())
+            console.log("PASS");
+    }
+    expect: {
+        !function() {
+            return console;
+        }() || console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+angularjs_chain: {
+    options = {
+        conditionals: true,
+        passes: 2,
+        side_effects: true,
+    }
+    input: {
+        function nonComputedMember(left, right, context, create) {
+            var lhs = left();
+            if (create && create !== 1) {
+                if (lhs && lhs[right] == null) {
+                    lhs[right] = {};
+                }
+            }
+            var value = lhs != null ? lhs[right] : undefined;
+            if (context) {
+                return { context: lhs, name: right, value: value };
+            } else {
+                return value;
+            }
+        }
+    }
+    expect: {
+        function nonComputedMember(left, right, context, create) {
+            var lhs = left();
+            create && 1 !== create && lhs && null == lhs[right] && (lhs[right] = {});
+            var value = null != lhs ? lhs[right] : void 0;
+            return context ? {
+                context: lhs,
+                name: right,
+                value: value
+            } : value;
+        }
+    }
+}
+
+issue_3576: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+    }
+    input: {
+        var c = "FAIL";
+        (function(a) {
+            (a = -1) ? (a && (a.a = 0)) : (a && (a.a = 0));
+            a && a[c = "PASS"]++;
+        })();
+        console.log(c);
+    }
+    expect: {
+        var c = "FAIL";
+        (function(a) {
+            a = -1, a, a.a = 0;
+            a, a[c = "PASS"]++;
+        })();
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3668: {
+    options = {
+        conditionals: true,
+        if_return: true,
+    }
+    input: {
+        function f() {
+            try {
+                var undefined = typeof f;
+                if (!f) return undefined;
+                return;
+            } catch (e) {
+                return "FAIL";
+            }
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            try {
+                var undefined = typeof f;
+                return f ? void 0 : undefined;
+            } catch (e) {
+                return "FAIL";
+            }
+        }
+        console.log(f());
+    }
+    expect_stdout: "undefined"
+}
+
+conditional_assignments_1: {
+    options = {
+        conditionals: true,
+        sequences: true,
+    }
+    input: {
+        function f(a, b, c, d) {
+            a = b;
+            if (c) a = d;
+            return a;
+        }
+        function g(a, b, c, d) {
+            a = b;
+            if (c); else a = d;
+            return a;
+        }
+        console.log(f(0, "FAIL", 1, "PASS"), g(0, "PASS", 1, "FAIL"));
+    }
+    expect: {
+        function f(a, b, c, d) {
+            return a = c ? d : b, a;
+        }
+        function g(a, b, c, d) {
+            return a = c ? b : d, a;
+        }
+        console.log(f(0, "FAIL", 1, "PASS"), g(0, "PASS", 1, "FAIL"));
+    }
+    expect_stdout: "PASS PASS"
+}
+
+conditional_assignments_2: {
+    options = {
+        conditionals: true,
+        sequences: true,
+    }
+    input: {
+        function f1(b, c, d) {
+            a = b;
+            if (c) a = d;
+            return a;
+        }
+        function f2(a, c, d) {
+            a = b;
+            if (c) a = d;
+            return a;
+        }
+        function f3(a, b, d) {
+            a = b;
+            if (c) a = d;
+            return a;
+        }
+        function f4(a, b, c) {
+            a = b;
+            if (c) a = d;
+            return a;
+        }
+    }
+    expect: {
+        function f1(b, c, d) {
+            return a = c ? d : b, a;
+        }
+        function f2(a, c, d) {
+            return a = b, c && (a = d), a;
+        }
+        function f3(a, b, d) {
+            return a = b, c && (a = d), a;
+        }
+        function f4(a, b, c) {
+            return a = b, c && (a = d), a;
+        }
+    }
+}
+
+conditional_assignments_3: {
+    options = {
+        conditionals: true,
+        sequences: true,
+    }
+    input: {
+        console.log(function(a, b) {
+            a = "PASS";
+            if (b) a = a;
+            return a;
+        }(0, 1));
+    }
+    expect: {
+        console.log(function(a, b) {
+            return a = "PASS", b && (a = a), a;
+        }(0, 1));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3808_1: {
+    options = {
+        conditionals: true,
+        side_effects: true,
+    }
+    input: {
+        var a;
+        a = "PASS", [] + "" && (a = "FAIL");
+        console.log(a);
+    }
+    expect: {
+        var a;
+        a = [] + "" ? "FAIL" : "PASS";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3808_2: {
+    options = {
+        conditionals: true,
+        side_effects: true,
+    }
+    input: {
+        var a;
+        console.log((a = "PASS", [] + "" && (a = "FAIL")), a);
+    }
+    expect: {
+        var a;
+        console.log((a = "PASS", [] + "" && (a = "FAIL")), a);
+    }
+    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/directives.js

@@ -0,0 +1,131 @@
+simple_statement_is_not_a_directive: {
+    input: {
+        "use strict"
+            .split(" ")
+            .forEach(function(s) {
+                console.log(s);
+            });
+        console.log(!this); // is strict mode?
+        (function() {
+            "directive"
+            ""
+            "use strict"
+            "hello world"
+                .split(" ")
+                .forEach(function(s) {
+                    console.log(s);
+                });
+            console.log(!this); // is strict mode?
+        })();
+    }
+    expect: {
+        "use strict".split(" ").forEach(function(s) {
+            console.log(s);
+        });
+        console.log(!this);
+        (function() {
+            "directive";
+            "";
+            "use strict";
+            "hello world".split(" ").forEach(function(s) {
+                console.log(s);
+            });
+            console.log(!this);
+        })();
+    }
+    expect_stdout: [
+        "use",
+        "strict",
+        "false",
+        "hello",
+        "world",
+        "true",
+    ]
+}
+
+drop_lone_use_strict: {
+    options = {
+        directives: true,
+        unused: true,
+    }
+    input: {
+        function f1() {
+            "use strict";
+        }
+        function f2() {
+            "use strict";
+            function f3() {
+                "use strict";
+            }
+        }
+        (function f4() {
+            "use strict";
+        })();
+    }
+    expect: {
+        function f1() {
+        }
+        function f2() {
+        }
+        (function() {})();
+    }
+}
+
+issue_3166: {
+    options = {
+        directives: true,
+    }
+    input: {
+        "foo";
+        "use strict";
+        function f() {
+            "use strict";
+            "bar";
+            "use asm";
+        }
+    }
+    expect: {
+        "use strict";
+        function f() {
+            "use asm";
+        }
+    }
+}
+
+valid_after_invalid_1: {
+    input: {
+        console.log(typeof function() {
+            "use\x20strict";
+            "use strict";
+            return this;
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            "use\x20strict";
+            "use strict";
+            return this;
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+valid_after_invalid_2: {
+    options = {
+        directives: true,
+    }
+    input: {
+        console.log(typeof function() {
+            "use\x20strict";
+            "use strict";
+            return this;
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            "use strict";
+            return this;
+        }());
+    }
+    expect_stdout: "undefined"
+}

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, 2 ** 30, typeof this);
+            }(0, 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,491 @@
+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";'
+}
+
+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/global_defs.js

@@ -12,6 +12,20 @@ must_replace: {
     }
 }
 
+repeated_nodes: {
+    options = {
+        global_defs: {
+            "@N": "rand()",
+        },
+    }
+    input: {
+        console.log(N, N);
+    }
+    expect: {
+        console.log(rand(), rand());
+    }
+}
+
 keyword: {
     options = {
         global_defs: {
@@ -142,7 +156,6 @@ mixed: {
     }
     expect_warnings: [
         "WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:4,22]",
-        "WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:5,22]",
         "WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:7,8]",
     ]
 }
@@ -197,3 +210,23 @@ issue_2167: {
         doWork();
     }
 }
+
+issue_3217: {
+    options = {
+        collapse_vars: true,
+        global_defs: {
+            "@o": "{fn:function(){var a=42;console.log(a)}}",
+        },
+        inline: true,
+        properties: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        o.fn();
+    }
+    expect: {
+        console.log(42);
+    }
+}

test/compress/hoist_props.js

@@ -297,6 +297,33 @@ name_collision_3: {
     expect_stdout: "true 4 6"
 }
 
+name_collision_4: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var o = {
+                p: 0,
+                q: "PASS",
+            };
+            return function(o_p) {
+                if (!o.p) return o_p;
+            }(o.q);
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var o_p$0 = 0, o_q = "PASS";
+            return function(o_p) {
+                if (!o_p$0) return o_p;
+            }(o_q);
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
 contains_this_1: {
     options = {
         evaluate: true,
@@ -664,7 +691,7 @@ issue_2519: {
     }
     expect: {
         function testFunc() {
-            return 1 * ((6 + 5) / 2);
+            return +((6 + 5) / 2);
         }
         console.log(testFunc());
     }
@@ -767,18 +794,17 @@ issue_3071_1: {
             var obj = {};
             obj.one = 1;
             obj.two = 2;
-            console.log(obj.one);
+            console.log(obj.one, obj.two);
         })();
     }
     expect: {
-        console.log(1);
+        console.log(1, 2);
     }
-    expect_stdout: "1"
+    expect_stdout: "1 2"
 }
 
 issue_3071_2: {
     options = {
-        evaluate: true,
         hoist_props: true,
         inline: true,
         join_vars: true,
@@ -793,19 +819,18 @@ issue_3071_2: {
             obj = {};
             obj.one = 1;
             obj.two = 2;
-            console.log(obj.one);
+            console.log(obj.one, obj.two);
             var obj;
         })();
     }
     expect: {
-        console.log(1);
+        console.log(1, 2);
     }
-    expect_stdout: "1"
+    expect_stdout: "1 2"
 }
 
 issue_3071_2_toplevel: {
     options = {
-        evaluate: true,
         hoist_props: true,
         inline: true,
         join_vars: true,
@@ -821,14 +846,14 @@ issue_3071_2_toplevel: {
             obj = {};
             obj.one = 1;
             obj.two = 2;
-            console.log(obj.one);
+            console.log(obj.one, obj.two);
             var obj;
         })();
     }
     expect: {
-        console.log(1);
+        console.log(1, 2);
     }
-    expect_stdout: "1"
+    expect_stdout: "1 2"
 }
 
 issue_3071_3: {
@@ -862,3 +887,210 @@ issue_3071_3: {
     }
     expect_stdout: "2"
 }
+
+issue_3411: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+    }
+    input: {
+        var c = 1;
+        !function f() {
+            var o = {
+                p: --c && f()
+            };
+            +o || console.log("PASS");
+        }();
+    }
+    expect: {
+        var c = 1;
+        !function f() {
+            var o_p = --c && f();
+            +{} || console.log("PASS");
+        }();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3440: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            function f() {
+                console.log(o.p);
+            }
+            var o = {
+                p: "PASS",
+            };
+            return f;
+        })()();
+    }
+    expect: {
+        (function() {
+            var o_p = "PASS";
+            return function() {
+                console.log(o_p);
+            };
+        })()();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3868: {
+    options = {
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        (function(t) {
+            t = {};
+            ({
+                get p() {},
+                q: (console.log("PASS"), +t),
+            }).r;
+        })();
+    }
+    expect: {
+        (function(t) {
+            t = {};
+            ({
+                get p() {},
+                q: (console.log("PASS"), +t),
+            }).r;
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3871: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            do {
+                var b = {
+                    get null() {
+                        c;
+                    }
+                };
+            } while (!b);
+            return "PASS";
+        }());
+    }
+    expect: {
+        console.log(function() {
+            do {
+                var b = {
+                    get null() {
+                        c;
+                    }
+                };
+            } while (!b);
+            return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3945_1: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            o.p;
+            var o = {
+                q: 0,
+            };
+        }
+    }
+    expect: {
+        function f() {
+            o.p;
+            var o = {
+                q: 0,
+            };
+        }
+    }
+}
+
+issue_3945_2: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        console.log(typeof o);
+        var o = {
+            p: 0,
+        };
+    }
+    expect: {
+        console.log(typeof o);
+        var o = {
+            p: 0,
+        };
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4023: {
+    options = {
+        comparisons: true,
+        hoist_props: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var a = function() {
+                return { p: 0 };
+            }();
+            return console.log("undefined" != typeof a);
+        }
+        f();
+    }
+    expect: {
+        console.log(void 0 !== {});
+    }
+    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

@@ -89,6 +89,31 @@ sequences_funs: {
     }
 }
 
+catch_var: {
+    options = {
+        dead_code: true,
+        hoist_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            a;
+        } catch (a) {
+            var a = 0;
+            a;
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
 issue_2295: {
     options = {
         collapse_vars: true,
@@ -109,3 +134,109 @@ issue_2295: {
         }
     }
 }
+
+issue_4487: {
+    options = {
+        functions: true,
+        hoist_vars: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f() {
+            var f = console.log(typeof f);
+        };
+        var b = a();
+    }
+    expect: {
+        function a() {
+            var f = console.log(typeof f);
+        }
+        a();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4489: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        A = 0;
+        var o = !0 || null;
+        for (var k in o);
+        console.log(k);
+    }
+    expect: {
+        !(A = 0);
+        for (var k in true);
+        console.log(k);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4517: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        join_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = 2;
+            A = a;
+            var b = typeof !1;
+            return A + b;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a = 2;
+            A = a;
+            return A + typeof !1;
+        }());
+    }
+    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"
+}

test/compress/html_comments.js

@@ -1,55 +1,107 @@
 html_comment_in_expression: {
     input: {
-        function f(a, b, x, y) { return a < !--b && x-- > y; }
+        (function(a, b) {
+            console.log(a < !--b && a-- > b, a, b);
+        })(1, 2);
     }
-    expect_exact: "function f(a,b,x,y){return a< !--b&&x-- >y}";
+    expect_exact: "(function(a,b){console.log(a<! --b&&a-- >b,a,b)})(1,2);"
+    expect_stdout: "false 1 1"
 }
 
 html_comment_in_less_than: {
     input: {
-        function f(a, b) { return a < !--b; }
+        (function(a, b, c) {
+            console.log(
+                a < !--b,
+                a < !--b + c,
+                a + b < !--c,
+                a, b, c
+            );
+        })(1, 2, 3);
     }
-    expect_exact: "function f(a,b){return a< !--b}";
+    expect_exact: "(function(a,b,c){console.log(a<! --b,a<! --b+c,a+b<! --c,a,b,c)})(1,2,3);"
+    expect_stdout: "false true false 1 0 2"
 }
 
 html_comment_in_left_shift: {
     input: {
-        function f(a, b) { return a << !--b; }
+        (function(a, b, c) {
+            console.log(
+                a << !--b,
+                a << !--b + c,
+                a + b << !--c,
+                a, b, c
+            );
+        })(1, 2, 3);
     }
-    expect_exact: "function f(a,b){return a<< !--b}";
-}
-
-html_comment_in_right_shift: {
-    input: {
-        function f(a, b) { return a-- >> b; }
-    }
-    expect_exact: "function f(a,b){return a-- >>b}";
-}
-
-html_comment_in_zero_fill_right_shift: {
-    input: {
-        function f(a, b) { return a-- >>> b; }
-    }
-    expect_exact: "function f(a,b){return a-- >>>b}";
+    expect_exact: "(function(a,b,c){console.log(a<<! --b,a<<! --b+c,a+b<<! --c,a,b,c)})(1,2,3);"
+    expect_stdout: "1 16 1 1 0 2"
 }
 
 html_comment_in_greater_than: {
     input: {
-        function f(a, b) { return a-- > b; }
+        (function(a, b, c) {
+            console.log(
+                a-- > b,
+                a-- > b + c,
+                a + b-- > c,
+                a, b, c
+            );
+        })(1, 2, 3);
     }
-    expect_exact: "function f(a,b){return a-- >b}";
+    expect_exact: "(function(a,b,c){console.log(a-- >b,a-- >b+c,a+b-- >c,a,b,c)})(1,2,3);"
+    expect_stdout: "false false false -1 1 3"
 }
 
 html_comment_in_greater_than_or_equal: {
     input: {
-        function f(a, b) { return a-- >= b; }
+        (function(a, b, c) {
+            console.log(
+                a-- >= b,
+                a-- >= b + c,
+                a + b-- >= c,
+                a, b, c
+            );
+        })(1, 2, 3);
     }
-    expect_exact: "function f(a,b){return a-- >=b}";
+    expect_exact: "(function(a,b,c){console.log(a-- >=b,a-- >=b+c,a+b-- >=c,a,b,c)})(1,2,3);"
+    expect_stdout: "false false false -1 1 3"
+}
+
+html_comment_in_right_shift: {
+    input: {
+        (function(a, b, c) {
+            console.log(
+                a-- >> b,
+                a-- >> b + c,
+                a + b-- >> c,
+                a, b, c
+            );
+        })(1, 2, 3);
+    }
+    expect_exact: "(function(a,b,c){console.log(a-- >>b,a-- >>b+c,a+b-- >>c,a,b,c)})(1,2,3);"
+    expect_stdout: "0 0 0 -1 1 3"
+}
+
+html_comment_in_zero_fill_right_shift: {
+    input: {
+        (function(a, b, c) {
+            console.log(
+                a-- >>> b,
+                a-- >>> b + c,
+                a + b-- >>> c,
+                a, b, c
+            );
+        })(1, 2, 3);
+    }
+    expect_exact: "(function(a,b,c){console.log(a-- >>>b,a-- >>>b+c,a+b-- >>>c,a,b,c)})(1,2,3);"
+    expect_stdout: "0 0 0 -1 1 3"
 }
 
 html_comment_in_string_literal: {
     input: {
-        function f() { return "<!--HTML-->comment in<!--string literal-->"; }
+        console.log("<!--HTML-->comment in<!--string literal-->".length);
     }
-    expect_exact: 'function f(){return"\\x3c!--HTML--\\x3ecomment in\\x3c!--string literal--\\x3e"}';
+    expect_exact: 'console.log("\\x3c!--HTML--\\x3ecomment in\\x3c!--string literal--\\x3e".length);'
+    expect_stdout: "42"
 }

test/compress/if_return.js

@@ -396,3 +396,355 @@ if_if_return_return: {
         }
     }
 }
+
+if_body_return_1: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        var c = "PASS";
+        function f(a, b) {
+            if (a) {
+                if (b) throw new Error(c);
+                return 42;
+            }
+            return true;
+        }
+        console.log(f(0, 0));
+        console.log(f(0, 1));
+        console.log(f(1, 0));
+        try {
+            f(1, 1);
+            console.log("FAIL");
+        } catch (e) {
+            console.log(e.message);
+        }
+    }
+    expect: {
+        var c = "PASS";
+        function f(a, b) {
+            if (a) {
+                if (b) throw new Error(c);
+                return 42;
+            }
+            return true;
+        }
+        console.log(f(0, 0));
+        console.log(f(0, 1));
+        console.log(f(1, 0));
+        try {
+            f(1, 1);
+            console.log("FAIL");
+        } catch (e) {
+            console.log(e.message);
+        }
+    }
+    expect_stdout: [
+        "true",
+        "true",
+        "42",
+        "PASS",
+    ]
+}
+
+if_body_return_2: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        var c = "PASS";
+        function f(a, b) {
+            if (0 + a) {
+                if (b) throw new Error(c);
+                return 42;
+            }
+            return true;
+        }
+        console.log(f(0, 0));
+        console.log(f(0, 1));
+        console.log(f(1, 0));
+        try {
+            f(1, 1);
+            console.log("FAIL");
+        } catch (e) {
+            console.log(e.message);
+        }
+    }
+    expect: {
+        var c = "PASS";
+        function f(a, b) {
+            if (0 + a) {
+                if (b) throw new Error(c);
+                return 42;
+            }
+            return true;
+        }
+        console.log(f(0, 0));
+        console.log(f(0, 1));
+        console.log(f(1, 0));
+        try {
+            f(1, 1);
+            console.log("FAIL");
+        } catch (e) {
+            console.log(e.message);
+        }
+    }
+    expect_stdout: [
+        "true",
+        "true",
+        "42",
+        "PASS",
+    ]
+}
+
+if_body_return_3: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        var c = "PASS";
+        function f(a, b) {
+            if (1 == a) {
+                if (b) throw new Error(c);
+                return 42;
+            }
+            return true;
+        }
+        console.log(f(0, 0));
+        console.log(f(0, 1));
+        console.log(f(1, 0));
+        try {
+            f(1, 1);
+            console.log("FAIL");
+        } catch (e) {
+            console.log(e.message);
+        }
+    }
+    expect: {
+        var c = "PASS";
+        function f(a, b) {
+            if (1 != a) return true;
+            if (b) throw new Error(c);
+            return 42;
+        }
+        console.log(f(0, 0));
+        console.log(f(0, 1));
+        console.log(f(1, 0));
+        try {
+            f(1, 1);
+            console.log("FAIL");
+        } catch (e) {
+            console.log(e.message);
+        }
+    }
+    expect_stdout: [
+        "true",
+        "true",
+        "42",
+        "PASS",
+    ]
+}
+
+issue_3600: {
+    options = {
+        if_return: true,
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        (function() {
+            if ([ ][c++]); else return;
+            return void function() {
+                var b = --b, a = c = 42;
+                return c;
+            }();
+        })();
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        (function() {
+            if ([][c++]) b = --b, c = 42;
+            var b;
+        })();
+        console.log(c);
+    }
+    expect_stdout: "1"
+}
+
+iife_if_return_simple: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        inline: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        (function() {
+            if (console)
+                return console.log("PASS");
+            console.log("FAIL");
+        })();
+    }
+    expect: {
+        console ? console.log("PASS") : console.log("FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+nested_if_break: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        for (var i = 0; i < 3; i++)
+            L1: if ("number" == typeof i) {
+                if (0 === i) break L1;
+                console.log(i);
+            }
+    }
+    expect: {
+        for (var i = 0; i < 3; i++)
+            L1: if ("number" == typeof i)
+                if (0 !== i) console.log(i);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+    ]
+}
+
+nested_if_continue: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        join_vars: true,
+        loops: true,
+    }
+    input: {
+        function f(n) {
+            var i = 0;
+            do {
+                if ("number" == typeof n) {
+                    if (0 === n) {
+                        console.log("even", i);
+                        continue;
+                    }
+                    if (1 === n) {
+                        console.log("odd", i);
+                        continue;
+                    }
+                    i++;
+                }
+            } while (0 <= (n -= 2));
+        }
+        f(37);
+        f(42);
+    }
+    expect: {
+        function f(n) {
+            for (var i = 0;
+                "number" == typeof n
+                    && (0 !== n
+                        ? 1 !== n
+                            ? i++
+                            : console.log("odd", i)
+                        : console.log("even", i)),
+                0 <= (n -= 2););
+        }
+        f(37);
+        f(42);
+    }
+    expect_stdout: [
+        "odd 18",
+        "even 21",
+    ]
+}
+
+nested_if_return: {
+    options = {
+        conditionals: true,
+        if_return: true,
+    }
+    input: {
+        function f() {
+            if (A) {
+                if (B)
+                    return B;
+                if (C)
+                    return D;
+                if (E)
+                    return F;
+                if (G)
+                    return H;
+                if (I) {
+                    if (J)
+                        return K;
+                    return;
+                }
+                if (L) {
+                    if (M)
+                        return;
+                    return N;
+                }
+            }
+        }
+    }
+    expect: {
+        function f() {
+            if (A)
+                return B || (C ? D : E ? F : G ? H : I ? J ? K : void 0 : L && !M ? N : void 0);
+        }
+    }
+}
+
+issue_866_1: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: false,
+    };
+    input: {
+        function f(a) {
+            if (a)
+                return "";
+            console.log(a);
+        }
+    }
+    expect: {
+        function f(a) {
+            if (a)
+                return "";
+            console.log(a);
+        }
+    }
+}
+
+issue_866_2: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+    }
+    input: {
+        (function() {
+            if (a)
+                if (b)
+                    c;
+                else
+                    return d;
+        })();
+    }
+    expect: {
+        (function() {
+            if (a) {
+                if (!b)
+                    return d;
+                c;
+            }
+        })();
+    }
+}

test/compress/imports.js

@@ -0,0 +1,202 @@
+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: {
+    input: {
+        console.log(import.meta, import.meta.url);
+    }
+    expect_exact: "console.log(import.meta,import.meta.url);"
+}
+
+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-1034.js

@@ -30,7 +30,7 @@ non_hoisted_function_after_return: {
     }
     expect: {
         function foo(x) {
-            return x ? bar() : baz();
+            return (x ? bar : baz)();
             function bar() { return 7 }
             function baz() { return 8 }
         }
@@ -39,7 +39,7 @@ non_hoisted_function_after_return: {
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:4,16]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:10,12]",
-        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:11,21]"
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:11,21]",
     ]
 }
 
@@ -59,7 +59,6 @@ non_hoisted_function_after_return_2a: {
         passes: 2,
         side_effects: true,
         unused: true,
-        warnings: "verbose",
     }
     input: {
         function foo(x) {
@@ -85,19 +84,16 @@ non_hoisted_function_after_return_2a: {
         }
     }
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:4,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:4,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:7,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:4,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:7,16]",
         "WARN: Dropping unused variable a [test/compress/issue-1034.js:4,20]",
         "WARN: Dropping unused function nope [test/compress/issue-1034.js:11,21]",
-        "WARN: pass 0: last_count: Infinity, count: 37",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:9,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:9,12]",
+        "INFO: pass 0: last_count: Infinity, count: 35",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:9,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:12,12]",
-        "WARN: Dropping unused variable b [test/compress/issue-1034.js:7,20]",
-        "WARN: Dropping unused variable c [test/compress/issue-1034.js:9,16]",
-        "WARN: pass 1: last_count: 37, count: 18",
+        "INFO: Dropping unused variable b [test/compress/issue-1034.js:7,20]",
+        "INFO: Dropping unused variable c [test/compress/issue-1034.js:9,16]",
+        "INFO: pass 1: last_count: 35, count: 18",
     ]
 }
 
@@ -139,10 +135,7 @@ non_hoisted_function_after_return_2b: {
         }
     }
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:6,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:6,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:8,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:8,12]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:8,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:12,12]",
     ]
 }
@@ -182,7 +175,7 @@ non_hoisted_function_after_return_strict: {
     expect: {
         "use strict";
         function foo(x) {
-            return x ? bar() : baz();
+            return (x ? bar : baz)();
             function bar() { return 7 }
             function baz() { return 8 }
         }
@@ -213,7 +206,6 @@ non_hoisted_function_after_return_2a_strict: {
         passes: 2,
         side_effects: true,
         unused: true,
-        warnings: "verbose",
     }
     input: {
         "use strict";
@@ -244,19 +236,16 @@ non_hoisted_function_after_return_2a_strict: {
     }
     expect_stdout: "5 6"
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:5,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:5,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:8,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:8,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:5,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:8,16]",
         "WARN: Dropping unused variable a [test/compress/issue-1034.js:5,20]",
         "WARN: Dropping unused function nope [test/compress/issue-1034.js:12,21]",
-        "WARN: pass 0: last_count: Infinity, count: 48",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:10,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:10,12]",
+        "INFO: pass 0: last_count: Infinity, count: 46",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:10,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:13,12]",
-        "WARN: Dropping unused variable b [test/compress/issue-1034.js:8,20]",
-        "WARN: Dropping unused variable c [test/compress/issue-1034.js:10,16]",
-        "WARN: pass 1: last_count: 48, count: 29",
+        "INFO: Dropping unused variable b [test/compress/issue-1034.js:8,20]",
+        "INFO: Dropping unused variable c [test/compress/issue-1034.js:10,16]",
+        "INFO: pass 1: last_count: 46, count: 29",
     ]
 }
 
@@ -303,10 +292,7 @@ non_hoisted_function_after_return_2b_strict: {
     }
     expect_stdout: "5 6"
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:7,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:9,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:9,12]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:9,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:13,12]",
     ]
 }

test/compress/issue-1052.js

@@ -16,7 +16,7 @@ multiple_functions: {
         ( function() {
             // NOTE: other compression steps will reduce this
             // down to just `window`.
-            if ( window );
+            if ( !window );
             function f() {}
             function g() {}
         } )();
@@ -38,7 +38,7 @@ single_function: {
     }
     expect: {
         ( function() {
-            if ( window );
+            if ( !window );
             function f() {}
         } )();
     }
@@ -67,7 +67,7 @@ deeply_nested: {
             // NOTE: other compression steps will reduce this
             // down to just `window`.
             if ( window )
-                if (document);
+                if ( !document );
             function f() {}
             function g() {}
             function h() {}

test/compress/issue-1105.js

@@ -151,15 +151,18 @@ Infinity_not_in_with_scope: {
         unused: true,
     }
     input: {
-        var o = { Infinity: 'oInfinity' };
+        var o = { Infinity: "FAIL" };
         var vInfinity = "Infinity";
         vInfinity = Infinity;
+        console.log(vInfinity);
     }
     expect: {
-        var o = { Infinity: 'oInfinity' }
-        var vInfinity = "Infinity"
-        vInfinity = 1/0
+        var o = { Infinity: "FAIL" };
+        var vInfinity = "Infinity";
+        vInfinity = 1/0;
+        console.log(vInfinity);
     }
+    expect_stdout: "Infinity"
 }
 
 Infinity_in_with_scope: {
@@ -167,15 +170,18 @@ Infinity_in_with_scope: {
         unused: true,
     }
     input: {
-        var o = { Infinity: 'oInfinity' };
+        var o = { Infinity: "PASS" };
         var vInfinity = "Infinity";
         with (o) { vInfinity = Infinity; }
+        console.log(vInfinity);
     }
     expect: {
-        var o = { Infinity: 'oInfinity' }
-        var vInfinity = "Infinity"
-        with (o) vInfinity = Infinity
+        var o = { Infinity: "PASS" };
+        var vInfinity = "Infinity";
+        with (o) vInfinity = Infinity;
+        console.log(vInfinity);
     }
+    expect_stdout: "PASS"
 }
 
 assorted_Infinity_NaN_undefined_in_with_scope: {

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

@@ -52,3 +52,30 @@ chained_evaluation_2: {
         })();
     }
 }
+
+chained_evaluation_3: {
+    options = {
+        collapse_vars: true,
+        evaluate: 10,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = "long piece of string";
+            (function() {
+                var b = a, c;
+                c = f(b);
+                c.bar = b;
+            })();
+        })();
+    }
+    expect: {
+        (function() {
+            (function() {
+                f("long piece of string").bar = "long piece of string";
+            })();
+        })();
+    }
+}

test/compress/issue-1639.js

@@ -1,4 +1,3 @@
-
 issue_1639_1: {
     options = {
         booleans: true,
@@ -12,7 +11,6 @@ issue_1639_1: {
     }
     input: {
         var a = 100, b = 10;
-
         var L1 = 5;
         while (--L1 > 0) {
             if ((--b), false) {
@@ -21,15 +19,15 @@ issue_1639_1: {
                 }
             }
         }
-
         console.log(a, b);
     }
     expect: {
-        for (var a = 100, b = 10, L1 = 5; --L1 > 0;)
-            if (--b, 0) var ignore = 0;
+        for (var a = 100, b = 10, L1 = 5, ignore; --L1 > 0;) {
+            --b;
+        }
         console.log(a, b);
     }
-    expect_stdout: true
+    expect_stdout: "100 6"
 }
 
 issue_1639_2: {
@@ -44,25 +42,23 @@ issue_1639_2: {
     }
     input: {
         var a = 100, b = 10;
-
         function f19() {
             if (++a, false)
                 if (a)
                     if (++a);
         }
         f19();
-
         console.log(a, b);
     }
     expect: {
         var a = 100, b = 10;
         function f19() {
-            ++a, 0;
+            ++a, 1;
         }
         f19(),
         console.log(a, b);
     }
-    expect_stdout: true
+    expect_stdout: "101 10"
 }
 
 issue_1639_3: {
@@ -84,5 +80,5 @@ issue_1639_3: {
         a++,
         console.log(a, b);
     }
-    expect_stdout: true
+    expect_stdout: "101 10"
 }

test/compress/issue-1656.js

@@ -35,11 +35,7 @@ f7: {
         console.log(a, b);
     }
     expect_exact: [
-        "var b = 10;",
-        "",
-        "!function() {",
-        "    b = 100;",
-        "}(), console.log(100, b);",
+        "console.log(100, 100);",
     ]
-    expect_stdout: true
+    expect_stdout: "100 100"
 }

test/compress/issue-1704.js

@@ -366,7 +366,7 @@ mangle_catch_redef_3: {
         console.log(o);
     }
     expect_exact: 'var o="PASS";try{throw 0}catch(o){(function(){function c(){o="FAIL"}c(),c()})()}console.log(o);'
-    expect_stdout: "PASS"
+    expect_stdout: true
 }
 
 mangle_catch_redef_3_toplevel: {
@@ -389,10 +389,10 @@ mangle_catch_redef_3_toplevel: {
         console.log(o);
     }
     expect_exact: 'var c="PASS";try{throw 0}catch(c){(function(){function o(){c="FAIL"}o(),o()})()}console.log(c);'
-    expect_stdout: "PASS"
+    expect_stdout: true
 }
 
-mangle_catch_redef_ie8_3: {
+mangle_catch_redef_3_ie8: {
     mangle = {
         ie8: true,
         toplevel: false,
@@ -412,7 +412,7 @@ mangle_catch_redef_ie8_3: {
         console.log(o);
     }
     expect_exact: 'var o="PASS";try{throw 0}catch(o){(function(){function c(){o="FAIL"}c(),c()})()}console.log(o);'
-    expect_stdout: "PASS"
+    expect_stdout: true
 }
 
 mangle_catch_redef_3_ie8_toplevel: {
@@ -435,5 +435,5 @@ mangle_catch_redef_3_ie8_toplevel: {
         console.log(o);
     }
     expect_exact: 'var c="PASS";try{throw 0}catch(c){(function(){function o(){c="FAIL"}o(),o()})()}console.log(c);'
-    expect_stdout: "PASS"
+    expect_stdout: true
 }

test/compress/issue-1770.js

@@ -46,7 +46,7 @@ mangle_props: {
             obj[1/0],
             obj["Infinity"],
             obj[-1/0],
-            obj[-1/0],
+            obj[-(1/0)],
             obj["-Infinity"],
             obj[null],
             obj["null"]

test/compress/issue-269.js

@@ -1,98 +1,111 @@
 issue_269_1: {
-	options = {
+    options = {
         unsafe: true,
     }
-	input: {
-		f(
-			String(x),
-			Number(x),
-			Boolean(x),
+    input: {
+        var x = {};
+        console.log(
+            String(x),
+            Number(x),
+            Boolean(x),
 
-			String(),
-			Number(),
-			Boolean()
-		);
-	}
-	expect: {
-		f(
-			x + '', +x, !!x,
-			'', 0, false
-		);
-	}
+            String(),
+            Number(),
+            Boolean()
+        );
+    }
+    expect: {
+        var x = {};
+        console.log(
+            "" + x, +("" + x), !!x,
+            "", 0, false
+        );
+    }
+    expect_stdout: true
 }
 
 issue_269_dangers: {
-	options = {
+    options = {
         unsafe: true,
     }
-	input: {
-		f(
-			String(x, x),
-			Number(x, x),
-			Boolean(x, x)
-		);
-	}
-	expect: {
-		f(String(x, x), Number(x, x), Boolean(x, x));
-	}
+    input: {
+        var x = {};
+        console.log(
+            String(x, x),
+            Number(x, x),
+            Boolean(x, x)
+        );
+    }
+    expect: {
+        var x = {};
+        console.log(String(x, x), Number(x, x), Boolean(x, x));
+    }
+    expect_stdout: true
 }
 
 issue_269_in_scope: {
-	options = {
+    options = {
         unsafe: true,
     }
-	input: {
-		var String, Number, Boolean;
-		f(
-			String(x),
-			Number(x, x),
-			Boolean(x)
-		);
-	}
-	expect: {
-		var String, Number, Boolean;
-		f(String(x), Number(x, x), Boolean(x));
-	}
+    input: {
+        var String, Number, Boolean;
+        var x = {};
+        console.log(
+            String(x),
+            Number(x, x),
+            Boolean(x)
+        );
+    }
+    expect: {
+        var String, Number, Boolean;
+        var x = {};
+        console.log(String(x), Number(x, x), Boolean(x));
+    }
+    expect_stdout: true
 }
 
 strings_concat: {
-	options = {
+    options = {
+        strings: true,
         unsafe: true,
     }
-	input: {
-		f(
-			String(x + 'str'),
-			String('str' + x)
-		);
-	}
-	expect: {
-		f(
-			x + 'str',
-			'str' + x
-		);
-	}
+    input: {
+        var x = {};
+        console.log(
+            String(x + "str"),
+            String("str" + x)
+        );
+    }
+    expect: {
+        var x = {};
+        console.log(
+            x + "str",
+            "str" + x
+        );
+    }
+    expect_stdout: true
 }
 
 regexp: {
-	options = {
+    options = {
         evaluate: true,
         unsafe: true,
     }
-	input: {
-		RegExp("foo");
-		RegExp("bar", "ig");
-		RegExp(foo);
-		RegExp("bar", ig);
-		RegExp("should", "fail");
-	}
-	expect: {
-		/foo/;
-		/bar/ig;
-		RegExp(foo);
-		RegExp("bar", ig);
-		RegExp("should", "fail");
-	}
-	expect_warnings: [
-		'WARN: Error converting RegExp("should","fail") [test/compress/issue-269.js:5,2]',
-	]
+    input: {
+        RegExp("foo");
+        RegExp("bar", "ig");
+        RegExp(foo);
+        RegExp("bar", ig);
+        RegExp("should", "fail");
+    }
+    expect: {
+        /foo/;
+        /bar/ig;
+        RegExp(foo);
+        RegExp("bar", ig);
+        RegExp("should", "fail");
+    }
+    expect_warnings: [
+        'WARN: Error converting RegExp("should","fail") [test/compress/issue-269.js:5,8]',
+    ]
 }

test/compress/issue-2719.js

@@ -26,7 +26,7 @@ warn: {
         }().length);
     }
     expect_warnings: [
-        "WARN: Function.protoype.caller not supported [test/compress/issue-2719.js:5,19]",
-        "WARN: Function.protoype.arguments not supported [test/compress/issue-2719.js:5,19]",
+        "WARN: Function.prototype.arguments not supported [test/compress/issue-2719.js:5,19]",
+        "WARN: Function.prototype.caller not supported [test/compress/issue-2719.js:5,19]",
     ]
 }

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/issue-3768.js

@@ -0,0 +1,128 @@
+mangle: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var e = eval, x = 42;
+        (function() {
+            console.log(e("typeof x"));
+        })();
+    }
+    expect: {
+        var e = eval, x = 42;
+        (function() {
+            console.log(e("typeof x"));
+        })();
+    }
+    expect_stdout: true
+}
+
+compress: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = 42;
+            return eval("typeof a");
+        }(), function(e) {
+            var a = null;
+            return e("typeof a");
+        }(eval), function(eval) {
+            var a = false;
+            return eval("typeof a");
+        }(eval), function(f) {
+            var a = "STRING";
+            var eval = f;
+            return eval("typeof a");
+        }(eval), function(g) {
+            var a = eval;
+            function eval() {
+                return g;
+            }
+            return eval()("typeof a");
+        }(eval));
+    }
+    expect: {
+        console.log(function() {
+            var a = 42;
+            return eval("typeof a");
+        }(), (0, eval)("typeof a"), function(eval) {
+            var a = false;
+            return eval("typeof a");
+        }(eval), function(f) {
+            var a = "STRING";
+            var eval = f;
+            return eval("typeof a");
+        }(eval), function(g) {
+            var a = eval;
+            function eval() {
+                return g;
+            }
+            return eval()("typeof a");
+        }(eval));
+    }
+    expect_stdout: "number undefined boolean string undefined"
+}
+
+call_arg_1: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var z = "foo";
+        (function() {
+            var z = false;
+            (function(e) {
+                var z = 42;
+                e("console.log(typeof z)");
+            })(eval);
+        })();
+    }
+    expect: {
+        var z = "foo";
+        (function() {
+            var o = false;
+            (function(o) {
+                var a = 42;
+                o("console.log(typeof z)");
+            })(eval);
+        })();
+    }
+    expect_stdout: true
+}
+
+call_arg_2: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        function eval() {
+            console.log("PASS");
+        }
+        var z = "foo";
+        (function() {
+            var z = false;
+            (function(e) {
+                var z = 42;
+                e("console.log(typeof z)");
+            })(eval);
+        })();
+    }
+    expect: {
+        function n() {
+            console.log("PASS");
+        }
+        var o = "foo";
+        (function() {
+            var o = false;
+            (function(o) {
+                var n = 42;
+                o("console.log(typeof z)");
+            })(n);
+        })();
+    }
+    expect_stdout: "PASS"
+}

test/compress/issue-637.js

@@ -16,7 +16,6 @@ wrongly_optimized: {
         function func() {
             foo();
         }
-        // TODO: optimize to `func(), bar()`
-        (func(), 1) && bar();
+        func(), 1, bar();
     }
 }

test/compress/issue-640.js

@@ -21,7 +21,7 @@ cond_5: {
         }
     }
     expect: {
-        some_condition() && some_other_condition() ? do_something() : alternate();
+        (some_condition() && some_other_condition() ? do_something : alternate)();
         if (some_condition() && some_other_condition()) do_something();
     }
 }
@@ -84,6 +84,7 @@ wrongly_optimized: {
     options = {
         booleans: true,
         conditionals: true,
+        dead_code: true,
         evaluate: true,
         expression: true,
     }
@@ -99,8 +100,8 @@ wrongly_optimized: {
         function func() {
             foo();
         }
-        // TODO: optimize to `func(), bar()`
-        if (func(), 1) bar();
+        func(), 1;
+        bar();
     }
 }
 

test/compress/issue-782.js

@@ -8,7 +8,7 @@ remove_sequence: {
         (0, 1, _decorators.logThis)();
     }
     expect: {
-        eval();
+        (0, eval)();
         logThis();
         (0, _decorators.logThis)();
     }

test/compress/issue-973.js

@@ -53,20 +53,23 @@ this_binding_conditionals: {
 this_binding_collapse_vars: {
     options = {
         collapse_vars: true,
-        toplevel: true,
         unused: true,
     }
     input: {
-        "use strict";
-        var c = a; c();
-        var d = a.b; d();
-        var e = eval; e();
+        function f() {
+            "use strict";
+            var c = a; c();
+            var d = a.b; d();
+            var e = eval; e();
+        }
     }
     expect: {
-        "use strict";
-        a();
-        (0, a.b)();
-        (0, eval)();
+        function f() {
+            "use strict";
+            a();
+            (0, a.b)();
+            (0, eval)();
+        }
     }
 }
 
@@ -97,7 +100,7 @@ this_binding_side_effects: {
         (function(foo) {
             foo();
             (0, foo.bar)();
-            eval("console.log(foo);");
+            (0, eval)("console.log(foo);");
         }());
         (function(foo) {
             "use strict";
@@ -144,7 +147,7 @@ this_binding_sequences: {
             return eval("this");
         }()),
         console.log(typeof function() {
-            return eval("this");
+            return (0, eval)("this");
         }()),
         console.log(typeof function() {
             "use strict";

test/compress/issue-976.js

@@ -63,42 +63,81 @@ eval_unused: {
         unused: true,
     }
     input: {
-        function f1(a, eval, c, d, e) {
-            return a('c') + eval;
-        }
-        function f2(a, b, c, d, e) {
-            return a + eval('c');
-        }
-        function f3(a, eval, c, d, e) {
-            return a + eval('c');
+        function o(k) {
+            return { c: 14 }[k];
         }
+        console.log(function f1(a, eval, c, d, e) {
+            return a("c") + eval;
+        }(o, 28, true));
+        console.log(function f2(a, b, c, d, e) {
+            return a + eval("c");
+        }(14, true, 28));
+        console.log(function f3(a, eval, c, d, e) {
+            return a + eval("c");
+        }(28, o, true));
     }
     expect: {
-        function f1(a, eval) {
-            return a('c') + eval;
-        }
-        function f2(a, b, c, d, e) {
-            return a + eval('c');
-        }
-        function f3(a, eval, c, d, e) {
-            return a + eval('c');
+        function o(k) {
+            return { c: 14 }[k];
         }
+        console.log(function(a, eval) {
+            return a("c") + eval;
+        }(o, 28));
+        console.log(function f2(a, b, c, d, e) {
+            return a + eval("c");
+        }(14, true, 28));
+        console.log(function f3(a, eval, c, d, e) {
+            return a + eval("c");
+        }(28, o, true));
     }
+    expect_stdout: [
+        "42",
+        "42",
+        "42",
+    ]
 }
 
 eval_mangle: {
-    mangle = {
-    };
-    input: {
-        function f1(a, eval, c, d, e) {
-            return a('c') + eval;
-        }
-        function f2(a, b, c, d, e) {
-            return a + eval('c');
-        }
-        function f3(a, eval, c, d, e) {
-            return a + eval('c');
-        }
+    mangle = {}
+    beautify = {
+        beautify: true,
     }
-    expect_exact: 'function f1(n,c,e,a,f){return n("c")+c}function f2(a,b,c,d,e){return a+eval("c")}function f3(a,eval,c,d,e){return a+eval("c")}'
+    input: {
+        function o(k) {
+            return { cc: 14 }[k + "c"];
+        }
+        console.log(function f1(a, eval, c, d, e) {
+            return a("c") + eval;
+        }(o, 28, true));
+        console.log(function f2(a, b, c, d, e) {
+            return a + eval("c");
+        }(14, true, 28));
+        console.log(function f3(a, eval, c, d, e) {
+            return a + eval("c");
+        }(28, o, true));
+    }
+    expect_exact: [
+        "function o(o) {",
+        "    return {",
+        "        cc: 14",
+        '    }[o + "c"];',
+        "}",
+        "",
+        "console.log(function o(c, e, n, r, t) {",
+        '    return c("c") + e;',
+        "}(o, 28, true));",
+        "",
+        "console.log(function f2(a, b, c, d, e) {",
+        '    return a + eval("c");',
+        "}(14, true, 28));",
+        "",
+        "console.log(function f3(a, eval, c, d, e) {",
+        '    return a + eval("c");',
+        "}(28, o, true));",
+    ]
+    expect_stdout: [
+        "42",
+        "42",
+        "42",
+    ]
 }

test/compress/labels.js

@@ -3,6 +3,7 @@ labels_1: {
         conditionals: true,
         dead_code: true,
         if_return: true,
+        unused: true,
     }
     input: {
         out: {
@@ -21,6 +22,7 @@ labels_2: {
         conditionals: true,
         dead_code: true,
         if_return: true,
+        unused: true,
     }
     input: {
         out: {
@@ -61,6 +63,7 @@ labels_4: {
         conditionals: true,
         dead_code: true,
         if_return: true,
+        unused: true,
     }
     input: {
         out: for (var i = 0; i < 5; ++i) {
@@ -105,6 +108,9 @@ labels_5: {
 }
 
 labels_6: {
+    options = {
+        dead_code: true,
+    }
     input: {
         out: break out;
     };
@@ -159,6 +165,7 @@ labels_9: {
         conditionals: true,
         dead_code: true,
         if_return: true,
+        unused: true,
     }
     input: {
         out: while (foo) {
@@ -200,3 +207,123 @@ labels_10: {
         }
     }
 }
+
+issue_4466_1: {
+    mangle = {
+        v8: false,
+    }
+    input: {
+        A: if (console.log("PASS"))
+            B:;
+        else
+            C:;
+    }
+    expect: {
+        e: if (console.log("PASS"))
+            l:;
+        else
+            l:;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+issue_4466_1_v8: {
+    mangle = {
+        v8: true,
+    }
+    input: {
+        A: if (console.log("PASS"))
+            B:;
+        else
+            C:;
+    }
+    expect: {
+        e: if (console.log("PASS"))
+            l:;
+        else
+            o:;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+issue_4466_2: {
+    mangle = {
+        toplevel: false,
+        v8: false,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            e:;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4466_2_v8: {
+    mangle = {
+        toplevel: false,
+        v8: true,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            l:;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4466_2_toplevel: {
+    mangle = {
+        toplevel: true,
+        v8: false,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            e:;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4466_2_toplevel_v8: {
+    mangle = {
+        toplevel: true,
+        v8: true,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            e:;
+    }
+    expect_stdout: "PASS"
+}

test/compress/loops.js

@@ -6,7 +6,7 @@ while_becomes_for: {
         while (foo()) bar();
     }
     expect: {
-        for (; foo(); ) bar();
+        for (;foo();) bar();
     }
 }
 
@@ -19,7 +19,7 @@ drop_if_break_1: {
             if (foo()) break;
     }
     expect: {
-        for (; !foo(););
+        for (;!foo(););
     }
 }
 
@@ -32,7 +32,7 @@ drop_if_break_2: {
             if (foo()) break;
     }
     expect: {
-        for (; bar() && !foo(););
+        for (;bar() && !foo(););
     }
 }
 
@@ -70,7 +70,7 @@ drop_if_break_4: {
         }
     }
     expect: {
-        for (; bar() && (x(), y(), !foo());) z(), k();
+        for (;bar() && (x(), y(), !foo());) z(), k();
     }
 }
 
@@ -82,7 +82,7 @@ drop_if_else_break_1: {
         for (;;) if (foo()) bar(); else break;
     }
     expect: {
-        for (; foo(); ) bar();
+        for (;foo();) bar();
     }
 }
 
@@ -97,7 +97,7 @@ drop_if_else_break_2: {
         }
     }
     expect: {
-        for (; bar() && foo();) baz();
+        for (;bar() && foo();) baz();
     }
 }
 
@@ -114,7 +114,7 @@ drop_if_else_break_3: {
         }
     }
     expect: {
-        for (; bar() && foo();) {
+        for (;bar() && foo();) {
             baz();
             stuff1();
             stuff2();
@@ -138,7 +138,7 @@ drop_if_else_break_4: {
         }
     }
     expect: {
-        for (; bar() && (x(), y(), foo());) baz(), z(), k();
+        for (;bar() && (x(), y(), foo());) baz(), z(), k();
     }
 }
 
@@ -201,7 +201,7 @@ evaluate: {
     }
 }
 
-issue_1532: {
+issue_1532_1: {
     options = {
         evaluate: true,
         loops: true,
@@ -210,18 +210,56 @@ issue_1532: {
         function f(x, y) {
             do {
                 if (x) break;
-                foo();
+                console.log(y);
             } while (false);
         }
+        f(null, "PASS");
+        f(42, "FAIL");
+    }
+    expect: {
+        function f(x, y) {
+            for (; !x && (console.log(y), false););
+        }
+        f(null, "PASS");
+        f(42, "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_1532_2: {
+    options = {
+        evaluate: true,
+        loops: true,
+    }
+    input: {
+        function f(x, y) {
+            do {
+                if (x) {
+                    console.log(x);
+                    break;
+                }
+                console.log(y);
+            } while (false);
+        }
+        f(null, "PASS");
+        f(42, "FAIL");
     }
     expect: {
         function f(x, y) {
             do {
-                if (x) break;
-                foo();
-            } while (false);
+                if (x) {
+                    console.log(x);
+                    break;
+                }
+            } while (console.log(y), false);
         }
+        f(null, "PASS");
+        f(42, "FAIL");
     }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
 }
 
 issue_186: {
@@ -463,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;);
     }
@@ -509,8 +547,8 @@ dead_code_condition: {
         console.log(a);
     }
     expect: {
-        var c;
         var a = 0, b = 5;
+        var c;
         a += 1, 0,
         console.log(a);
     }
@@ -523,13 +561,13 @@ issue_2740_1: {
         loops: true,
     }
     input: {
-        for (; ; ) break;
-        for (a(); ; ) break;
-        for (; b(); ) break;
-        for (c(); d(); ) break;
-        for (; ; e()) break;
-        for (f(); ; g()) break;
-        for (; h(); i()) break;
+        for (;;) break;
+        for (a();;) break;
+        for (;b();) break;
+        for (c(); d();) break;
+        for (;;e()) break;
+        for (f();; g()) break;
+        for (;h(); i()) break;
         for (j(); k(); l()) break;
     }
     expect: {
@@ -549,6 +587,7 @@ issue_2740_2: {
         dead_code: true,
         loops: true,
         passes: 2,
+        unused: true,
     }
     input: {
         L1: while (x()) {
@@ -564,6 +603,7 @@ issue_2740_3: {
     options = {
         dead_code: true,
         loops: true,
+        unused: true,
     }
     input: {
         L1: for (var x = 0; x < 3; x++) {
@@ -574,9 +614,11 @@ issue_2740_3: {
         console.log(x, y);
     }
     expect: {
-        L1: for (var x = 0; x < 3; x++)
-            for (var y = 0; y < 2; y++)
+        L1: for (var x = 0; x < 3; x++) {
+            var y = 0;
+            if (y < 2)
                 break L1;
+        }
         console.log(x, y);
     }
     expect_stdout: "0 0"
@@ -587,6 +629,7 @@ issue_2740_4: {
         dead_code: true,
         loops: true,
         passes: 2,
+        unused: true,
     }
     input: {
         L1: for (var x = 0; x < 3; x++) {
@@ -611,6 +654,7 @@ issue_2740_5: {
         dead_code: true,
         loops: true,
         passes: 2,
+        unused: true,
     }
     input: {
         L1: for (var x = 0; x < 3; x++) {
@@ -646,3 +690,635 @@ issue_2904: {
     }
     expect_stdout: "1"
 }
+
+issue_3371: {
+    options = {
+        functions: true,
+        join_vars: true,
+        loops: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = function() {
+                console.log("PASS");
+            };
+            while (a());
+        })();
+    }
+    expect: {
+        (function() {
+            function a() {
+                console.log("PASS");
+            }
+            for (;a(););
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+step: {
+    options = {
+        loops: true,
+        side_effects: true,
+    }
+    input: {
+        for (var i = 0; i < 42; "foo", i++, "bar");
+        console.log(i);
+    }
+    expect: {
+        for (var i = 0; i < 42; i++);
+        console.log(i);
+    }
+    expect_stdout: "42"
+}
+
+empty_for_in: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var a in [ 1, 2, 3 ]) {
+            var b = a + 1;
+        }
+    }
+    expect: {}
+    expect_warnings: [
+        "WARN: Dropping unused variable b [test/compress/loops.js:2,16]",
+        "INFO: Dropping unused loop variable a [test/compress/loops.js:1,17]",
+    ]
+}
+
+empty_for_in_used: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var a in [ 1, 2, 3 ]) {
+            var b = a + 1;
+        }
+        console.log(a);
+    }
+    expect: {
+        for (var a in [ 1, 2, 3 ]);
+        console.log(a);
+    }
+    expect_stdout: "2"
+    expect_warnings: [
+        "WARN: Dropping unused variable b [test/compress/loops.js:2,16]",
+    ]
+}
+
+empty_for_in_side_effects: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var a in {
+            foo: console.log("PASS")
+        }) {
+            var b = a + "bar";
+        }
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    expect_warnings: [
+        "WARN: Dropping unused variable b [test/compress/loops.js:4,16]",
+        "INFO: Dropping unused loop variable a [test/compress/loops.js:1,17]",
+        "WARN: Side effects in object of for-in loop [test/compress/loops.js:2,17]",
+    ]
+}
+
+empty_for_in_prop_init: {
+    options = {
+        loops: true,
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        console.log(function f() {
+            var a = "bar";
+            for ((a, f)[a] in console.log("foo"));
+            return a;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a = "bar";
+            console.log("foo");
+            return a;
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    expect_warnings: [
+        "INFO: Dropping unused loop variable f [test/compress/loops.js:3,21]",
+        "WARN: Side effects in object of for-in loop [test/compress/loops.js:3,30]",
+    ]
+}
+
+for_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"
+}
+
+issue_3631_1: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        L: do {
+            for (;;) continue L;
+            var b = 1;
+        } while (b && c++);
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        do {
+            var b;
+        } while (b && c++);
+        console.log(c);
+    }
+    expect_stdout: "0"
+}
+
+issue_3631_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        L: for (var a = 1; a--; console.log(b)) {
+            for (;;) continue L;
+            var b = "FAIL";
+        }
+    }
+    expect: {
+        for (var a = 1; a--; console.log(b))
+            var b;
+    }
+    expect_stdout: "undefined"
+}
+
+loop_if_break: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        function f(a, b) {
+            try {
+                while (a) {
+                    if (b) {
+                        break;
+                        var c = 42;
+                        console.log(c);
+                    } else {
+                        var d = false;
+                        throw d;
+                    }
+                }
+            } catch (e) {
+                console.log("E:", e);
+            }
+            console.log(a, b, c, d);
+        }
+        f(0, 0);
+        f(0, 1);
+        f(1, 0);
+        f(1, 1);
+    }
+    expect: {
+        function f(a, b) {
+            try {
+                for (;a && !b;) {
+                    var d = false;
+                    throw d;
+                    var c;
+                }
+            } catch (e) {
+                console.log("E:", e);
+            }
+            console.log(a, b, c, d);
+        }
+        f(0, 0);
+        f(0, 1);
+        f(1, 0);
+        f(1, 1);
+    }
+    expect_stdout: [
+        "0 0 undefined undefined",
+        "0 1 undefined undefined",
+        "E: false",
+        "1 0 undefined false",
+        "1 1 undefined undefined",
+    ]
+}
+
+loop_return: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        function f(a) {
+            while (a) return 42;
+            return "foo";
+        }
+        console.log(f(0), f(1));
+    }
+    expect: {
+        function f(a) {
+            if (a) return 42;
+            return "foo";
+        }
+        console.log(f(0), f(1));
+    }
+    expect_stdout: "foo 42"
+}
+
+issue_3634_1: {
+    options = {
+        loops: true,
+    }
+    input: {
+        var b = 0;
+        L: while (++b < 2)
+            while (1)
+                if (b) break L;
+        console.log(b);
+    }
+    expect: {
+        var b = 0;
+        L: for (;++b < 2;)
+            for (;1;)
+                if (b) break L;
+        console.log(b);
+    }
+    expect_stdout: "1"
+}
+
+issue_3634_2: {
+    options = {
+        loops: true,
+    }
+    input: {
+        var b = 0;
+        L: while (++b < 2)
+            while (1)
+                if (!b)
+                    continue L;
+                else
+                    break L;
+        console.log(b);
+    }
+    expect: {
+        var b = 0;
+        L: for (;++b < 2;)
+            for (;1;)
+                if (!b)
+                    continue L;
+                else
+                    break L;
+        console.log(b);
+    }
+    expect_stdout: "1"
+}
+
+issue_4075: {
+    options = {
+        loops: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function() {
+            for (a in { PASS: 0 });
+        })()
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function() {
+            for (a in { PASS: 0 });
+        })()
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4082: {
+    options = {
+        keep_fargs: false,
+        loops: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        (function(a) {
+            for (a in "foo")
+                var b;
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (function(a) {
+            for (a in "foo");
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4084: {
+    options = {
+        keep_fargs: false,
+        loops: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            function f(a) {
+                var b = a++;
+                for (a in "foo");
+            }
+            f();
+            return typeof a;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            (function() {
+                0;
+            })();
+            return typeof a;
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4091_1: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        try {
+            throw "FAIL";
+        } catch (e) {
+            for (var e in 42);
+        }
+        console.log(e && e);
+    }
+    expect: {
+        try {
+            throw "FAIL";
+        } catch (e) {
+            var e;
+        }
+        console.log(e && e);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4091_2: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        try {
+            throw "FAIL";
+        } catch (e) {
+            for (e in 42);
+            var e;
+        }
+        console.log(e && e);
+    }
+    expect: {
+        try {
+            throw "FAIL";
+        } catch (e) {
+            var e;
+        }
+        console.log(e && e);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4182_1: {
+    options = {
+        loops: true,
+    }
+    input: {
+        (function() {
+            do {
+                try {
+                    return;
+                } finally {
+                    continue;
+                }
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect: {
+        (function() {
+            do {
+                try {
+                    return;
+                } finally {
+                    continue;
+                }
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4182_2: {
+    options = {
+        loops: true,
+    }
+    input: {
+        (function() {
+            L: do {
+                do {
+                    try {
+                        return;
+                    } finally {
+                        continue L;
+                    }
+                    console.log("FAIL");
+                } while (0);
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect: {
+        (function() {
+            L: do {
+                do {
+                    try {
+                        return;
+                    } finally {
+                        continue L;
+                    }
+                } while (console.log("FAIL"), 0);
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+do_continue: {
+    options = {
+        loops: true,
+    }
+    input: {
+        try {
+            do {
+                continue;
+            } while ([ A ]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            do {
+                continue;
+            } while ([ A ]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4240: {
+    options = {
+        loops: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            function f() {
+                var o = { PASS: 42 };
+                for (a in o);
+            }
+            (function() {
+                if (f());
+            })();
+            console.log(a);
+        })();
+    }
+    expect: {
+        (function(a) {
+            (function() {
+                if (function() {
+                    for (a in { PASS: 42 });
+                }());
+            })();
+            console.log(a);
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4355: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        passes: 2,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        while (function() {
+            var a;
+            for (a in console.log("PASS"))
+                var b = 0;
+        }())
+            var c;
+    }
+    expect: {
+        (function() {
+            console.log("PASS");
+        })();
+        var c;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4564: {
+    options = {
+        loops: true,
+        unused: true,
+    }
+    input: {
+        try {
+            throw null;
+        } catch (a) {
+            var a;
+            (function() {
+                for (a in "foo");
+            })();
+            console.log(a);
+        }
+    }
+    expect: {
+        try {
+            throw null;
+        } catch (a) {
+            var a;
+            (function() {
+                for (a in "foo");
+            })();
+            console.log(a);
+        }
+    }
+    expect_stdout: "2"
+}

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/objects.js

@@ -0,0 +1,523 @@
+duplicate_key: {
+    options = {
+        objects: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            b: 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            a: 3,
+            b: 2,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "a 3",
+        "b 2",
+    ]
+}
+
+duplicate_key_strict: {
+    options = {
+        objects: true,
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        var o = {
+            a: 1,
+            b: 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        "use strict";
+        var o = {
+            a: 1,
+            a: 3,
+            b: 2,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: true
+}
+
+duplicate_key_side_effect: {
+    options = {
+        objects: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            b: o = 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            a: 1,
+            b: o = 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "a 3",
+        "b 2",
+    ]
+}
+
+duplicate_key_with_accessor: {
+    options = {
+        objects: true,
+        side_effects: true,
+    }
+    input: {
+        [
+            {
+                a: 0,
+                b: 1,
+                a: 2,
+                set b(v) {},
+            },
+            {
+                a: 3,
+                b: 4,
+                get a() {
+                    return 5;
+                },
+                a: 6,
+                b: 7,
+                a: 8,
+                b: 9,
+            },
+        ].forEach(function(o) {
+            for (var k in o)
+                console.log(k, o[k]);
+        });
+    }
+    expect: {
+        [
+            {
+                a: 2,
+                b: 1,
+                set b(v) {},
+            },
+            {
+                a: 3,
+                b: 4,
+                get a() {
+                    return 5;
+                },
+                a: 8,
+                b: 9,
+            },
+        ].forEach(function(o) {
+            for (var k in o)
+                console.log(k, o[k]);
+        });
+    }
+    expect_stdout: true
+}
+
+unsafe_object_repeated: {
+    options = {
+        evaluate: true,
+        objects: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var o = { a: { b: 1 }, a: 1 };
+        console.log(
+            o + 1,
+            o.a + 1,
+            o.b + 1,
+            o.a.b + 1
+        );
+    }
+    expect: {
+        var o = { a: 1 };
+        console.log(
+            o + 1,
+            2,
+            o.b + 1,
+            NaN
+        );
+    }
+    expect_stdout: true
+}
+
+numeric_literal: {
+    options = {
+        objects: true,
+        side_effects: true,
+    }
+    mangle = {
+        properties: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        var obj = {
+            0: 0,
+            "-0": 1,
+            42: 2,
+            "42": 3,
+            0x25: 4,
+            "0x25": 5,
+            1E42: 6,
+            "1E42": 7,
+            "1e+42": 8,
+        };
+        console.log(obj[-0], obj[-""], obj["-0"]);
+        console.log(obj[42], obj["42"]);
+        console.log(obj[0x25], obj["0x25"], obj[37], obj["37"]);
+        console.log(obj[1E42], obj["1E42"], obj["1e+42"]);
+    }
+    expect_exact: [
+        'var obj = {',
+        '    0: 0,',
+        '    "-0": 1,',
+        '    42: 3,',
+        '    37: 4,',
+        '    o: 5,',
+        '    1e42: 8,',
+        '    b: 7',
+        '};',
+        '',
+        'console.log(obj[-0], obj[-""], obj["-0"]);',
+        '',
+        'console.log(obj[42], obj["42"]);',
+        '',
+        'console.log(obj[37], obj["o"], obj[37], obj["37"]);',
+        '',
+        'console.log(obj[1e42], obj["b"], obj["1e+42"]);',
+    ]
+    expect_stdout: [
+        "0 0 1",
+        "3 3",
+        "4 5 4 4",
+        "8 7 8",
+    ]
+}
+
+evaluate_computed_key: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            ["foo" + "bar"]: "PASS",
+        }.foobar);
+    }
+    expect: {
+        console.log({
+            foobar: "PASS",
+        }.foobar);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+keep_computed_key: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            [console.log("PASS")]: 42,
+        });
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+shorthand_keywords: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var async = 1, get = 2, set = 3, o = {
+            async,
+            get,
+            set,
+        };
+        console.log(o.async, o.get, o.set);
+    }
+    expect: {
+        console.log(1, 2, 3);
+    }
+    expect_stdout: "1 2 3"
+    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,
+        objects: true,
+    }
+    input: {
+        console.log({
+            get 0() {
+                return "FAIL";
+            },
+            [0]: "PASS",
+        }[0]);
+    }
+    expect: {
+        console.log({
+            get 0() {
+                return "FAIL";
+            },
+            [0]: "PASS",
+        }[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4269_2: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            get [0]() {
+                return "FAIL";
+            },
+            0: "PASS",
+        }[0]);
+    }
+    expect: {
+        console.log({
+            get [0]() {
+                return "FAIL";
+            },
+            0: "PASS",
+        }[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4269_3: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            ["foo"]: "bar",
+            get 42() {
+                return "FAIL";
+            },
+            42: "PASS",
+        }[42]);
+    }
+    expect: {
+        console.log({
+            foo: "bar",
+            get [42]() {
+                return "FAIL";
+            },
+            42: "PASS",
+        }[42]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4269_4: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            get 42() {
+                return "FAIL";
+            },
+            ["foo"]: "bar",
+            42: "PASS",
+        }[42]);
+    }
+    expect: {
+        console.log({
+            get 42() {
+                return "FAIL";
+            },
+            foo: "bar",
+            [42]: "PASS",
+        }[42]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4269_5: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            get 42() {
+                return "FAIL";
+            },
+            [console]: "bar",
+            42: "PASS",
+        }[42]);
+    }
+    expect: {
+        console.log({
+            get 42() {
+                return "FAIL";
+            },
+            [console]: "bar",
+            42: "PASS",
+        }[42]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4380: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            get 0() {
+                return "FAIL 1";
+            },
+            0: "FAIL 2",
+            [0]: "PASS",
+        }[0]);
+    }
+    expect: {
+        console.log({
+            get 0() {
+                return "FAIL 1";
+            },
+            [0]: ("FAIL 2", "PASS"),
+        }[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4415: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            ["00"]: "FAIL",
+        }[0] || "PASS");
+    }
+    expect: {
+        console.log({
+            "00": "FAIL",
+        }[0] || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/properties.js

@@ -130,7 +130,7 @@ evaluate_string_length: {
     }
 }
 
-mangle_properties: {
+mangle_properties_1: {
     mangle = {
         properties: {
             keep_quoted: false,
@@ -152,6 +152,53 @@ mangle_properties: {
     }
 }
 
+mangle_properties_2: {
+    mangle = {
+        properties: {
+            reserved: [
+                "value",
+            ]
+        },
+    }
+    input: {
+        var o = {
+            prop1: 1,
+        };
+        Object.defineProperty(o, "prop2", {
+            value: 2,
+        });
+        Object.defineProperties(o, {
+            prop3: {
+                value: 3,
+            },
+        });
+        console.log("prop1", o.prop1, "prop1" in o);
+        console.log("prop2", o.prop2, o.hasOwnProperty("prop2"));
+        console.log("prop3", o.prop3, Object.getOwnPropertyDescriptor(o, "prop3").value);
+    }
+    expect: {
+        var o = {
+            o: 1,
+        };
+        Object.defineProperty(o, "p", {
+            value: 2,
+        });
+        Object.defineProperties(o, {
+            r: {
+                value: 3,
+            },
+        });
+        console.log("prop1", o.o, "o" in o);
+        console.log("prop2", o.p, o.hasOwnProperty("p"));
+        console.log("prop3", o.r, Object.getOwnPropertyDescriptor(o, "r").value);
+    }
+    expect_stdout: [
+        "prop1 1 true",
+        "prop2 2 true",
+        "prop3 3 3",
+    ]
+}
+
 mangle_unquoted_properties: {
     options = {
         evaluate: true,
@@ -817,6 +864,29 @@ issue_2208_5: {
     expect_stdout: "42"
 }
 
+issue_2208_6: {
+    options = {
+        inline: true,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        a = 42;
+        console.log(("FAIL", {
+            p: function() {
+                return this.a;
+            }
+        }.p)());
+    }
+    expect: {
+        a = 42;
+        console.log(function() {
+            return this.a;
+        }());
+    }
+    expect_stdout: "42"
+}
+
 issue_2256: {
     options = {
         side_effects: true,
@@ -1023,16 +1093,22 @@ array_hole: {
         side_effects: true,
     }
     input: {
-        console.log(
-            [ 1, 2, , 3][1],
-            [ 1, 2, , 3][2],
-            [ 1, 2, , 3][3]
-        );
+        Array.prototype[2] = "PASS";
+        console.log([ 1, 2, , 3 ][1]);
+        console.log([ 1, 2, , 3 ][2]);
+        console.log([ 1, 2, , 3 ][3]);
     }
     expect: {
-        console.log(2, void 0, 3);
+        Array.prototype[2] = "PASS";
+        console.log(2);
+        console.log([ , , , ][2]);
+        console.log(3);
     }
-    expect_stdout: "2 undefined 3"
+    expect_stdout: [
+        "2",
+        "PASS",
+        "3",
+    ]
 }
 
 new_this: {
@@ -1047,11 +1123,7 @@ new_this: {
             }
         }.f(42);
     }
-    expect: {
-        new function(a) {
-            this.a = a;
-        }(42);
-    }
+    expect: {}
 }
 
 issue_2513: {
@@ -1120,558 +1192,6 @@ const_prop_assign_pure: {
     }
 }
 
-join_object_assignments_1: {
-    options = {
-        evaluate: true,
-        join_vars: true,
-    }
-    input: {
-        console.log(function() {
-            var x = {
-                a: 1,
-                c: (console.log("c"), "C"),
-            };
-            x.b = 2;
-            x[3] = function() {
-                console.log(x);
-            },
-            x["a"] = /foo/,
-            x.bar = x;
-            return x;
-        }());
-    }
-    expect: {
-        console.log(function() {
-            var x = {
-                a: 1,
-                c: (console.log("c"), "C"),
-                b: 2,
-                3: function() {
-                    console.log(x);
-                },
-                a: /foo/,
-            };
-            x.bar = x;
-            return x;
-        }());
-    }
-    expect_stdout: true
-}
-
-join_object_assignments_2: {
-    options = {
-        evaluate: true,
-        hoist_props: true,
-        join_vars: true,
-        passes: 3,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var o = {
-            foo: 1,
-        };
-        o.bar = 2;
-        o.baz = 3;
-        console.log(o.foo, o.bar + o.bar, o.foo * o.bar * o.baz);
-    }
-    expect: {
-        console.log(1, 4, 6);
-    }
-    expect_stdout: "1 4 6"
-}
-
-join_object_assignments_3: {
-    options = {
-        evaluate: true,
-        join_vars: true,
-    }
-    input: {
-        console.log(function() {
-            var o = {
-                a: "PASS",
-            }, a = o.a;
-            o.a = "FAIL";
-            return a;
-        }());
-    }
-    expect: {
-        console.log(function() {
-            var o = {
-                a: "PASS",
-            }, a = o.a;
-            o.a = "FAIL";
-            return a;
-        }());
-    }
-    expect_stdout: "PASS"
-}
-
-join_object_assignments_4: {
-    options = {
-        join_vars: true,
-        sequences: true,
-    }
-    input: {
-        var o;
-        console.log(o);
-        o = {};
-        o.a = "foo";
-        console.log(o.b);
-        o.b = "bar";
-        console.log(o.a);
-    }
-    expect: {
-        var o;
-        console.log(o),
-        o = {
-            a: "foo",
-        },
-        console.log(o.b),
-        o.b = "bar",
-        console.log(o.a);
-    }
-    expect_stdout: [
-        "undefined",
-        "undefined",
-        "foo",
-    ]
-}
-
-join_object_assignments_return_1: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        console.log(function() {
-            var o = {
-                p: 3
-            };
-            return o.q = "foo";
-        }());
-    }
-    expect: {
-        console.log(function() {
-            var o = {
-                p: 3,
-                q: "foo"
-            };
-            return o.q;
-        }());
-    }
-    expect_stdout: "foo"
-}
-
-join_object_assignments_return_2: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        console.log(function() {
-            var o = {
-                p: 3
-            };
-            return o.q = /foo/,
-            o.r = "bar";
-        }());
-    }
-    expect: {
-        console.log(function() {
-            var o = {
-                p: 3,
-                q: /foo/,
-                r: "bar"
-            };
-            return o.r;
-        }());
-    }
-    expect_stdout: "bar"
-}
-
-join_object_assignments_return_3: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        console.log(function() {
-            var o = {
-                p: 3
-            };
-            return o.q = "foo",
-            o.p += "",
-            console.log(o.q),
-            o.p;
-        }());
-    }
-    expect: {
-        console.log(function() {
-            var o = {
-                p: 3,
-                q: "foo"
-            };
-            return o.p += "",
-            console.log(o.q),
-            o.p;
-        }());
-    }
-    expect_stdout: [
-        "foo",
-        "3",
-    ]
-}
-
-join_object_assignments_for: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        console.log(function() {
-            var o = {
-                p: 3
-            };
-            for (o.q = "foo"; console.log(o.q););
-            return o.p;
-        }());
-    }
-    expect: {
-        console.log(function() {
-            for (var o = {
-                p: 3,
-                q: "foo"
-            }; console.log(o.q););
-            return o.p;
-        }());
-    }
-    expect_stdout: [
-        "foo",
-        "3",
-    ]
-}
-
-join_object_assignments_if: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        console.log(function() {
-            var o = {};
-            if (o.a = "PASS") return o.a;
-        }())
-    }
-    expect: {
-        console.log(function() {
-            var o = { a: "PASS" };
-            if (o.a) return o.a;
-        }());
-    }
-    expect_stdout: "PASS"
-}
-
-join_object_assignments_forin: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        console.log(function() {
-            var o = {};
-            for (var a in o.a = "PASS", o)
-                return o[a];
-        }())
-    }
-    expect: {
-        console.log(function() {
-            var o = { a: "PASS" };
-            for (var a in o)
-                return o[a];
-        }());
-    }
-    expect_stdout: "PASS"
-}
-
-join_object_assignments_negative: {
-    options = {
-        evaluate: true,
-        join_vars: true,
-        properties: true,
-    }
-    input: {
-        var o = {};
-        o[0] = 0;
-        o[-0] = 1;
-        o[-1] = 2;
-        console.log(o[0], o[-0], o[-1]);
-    }
-    expect: {
-        var o = {
-            0: 0,
-            0: 1,
-            "-1": 2
-        };
-        console.log(o[0], o[-0], o[-1]);
-    }
-    expect_stdout: "1 1 2"
-}
-
-join_object_assignments_NaN_1: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        var o = {};
-        o[NaN] = 1;
-        o[0/0] = 2;
-        console.log(o[NaN], o[NaN]);
-    }
-    expect: {
-        var o = {};
-        o[NaN] = 1;
-        o[0/0] = 2;
-        console.log(o[NaN], o[NaN]);
-    }
-    expect_stdout: "2 2"
-}
-
-join_object_assignments_NaN_2: {
-    options = {
-        evaluate: true,
-        join_vars: true,
-        properties: true,
-    }
-    input: {
-        var o = {};
-        o[NaN] = 1;
-        o[0/0] = 2;
-        console.log(o[NaN], o[NaN]);
-    }
-    expect: {
-        var o = {
-            NaN: 1,
-            NaN: 2
-        };
-        console.log(o.NaN, o.NaN);
-    }
-    expect_stdout: "2 2"
-}
-
-join_object_assignments_null_0: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        var o = {};
-        o[null] = 1;
-        console.log(o[null]);
-    }
-    expect: {
-        var o = {};
-        o[null] = 1;
-        console.log(o[null]);
-    }
-    expect_stdout: "1"
-}
-
-join_object_assignments_null_1: {
-    options = {
-        evaluate: true,
-        join_vars: true,
-        properties: true,
-    }
-    input: {
-        var o = {};
-        o[null] = 1;
-        console.log(o[null]);
-    }
-    expect: {
-        var o = {
-            null: 1
-        };
-        console.log(o.null);
-    }
-    expect_stdout: "1"
-}
-
-join_object_assignments_void_0: {
-    options = {
-        evaluate: true,
-        join_vars: true,
-    }
-    input: {
-        var o = {};
-        o[void 0] = 1;
-        console.log(o[void 0]);
-    }
-    expect: {
-        var o = {
-            undefined: 1
-        };
-        console.log(o[void 0]);
-    }
-    expect_stdout: "1"
-}
-
-join_object_assignments_undefined_1: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        var o = {};
-        o[undefined] = 1;
-        console.log(o[undefined]);
-    }
-    expect: {
-        var o = {};
-        o[void 0] = 1;
-        console.log(o[void 0]);
-    }
-    expect_stdout: "1"
-}
-
-join_object_assignments_undefined_2: {
-    options = {
-        evaluate: true,
-        join_vars: true,
-        properties: true,
-    }
-    input: {
-        var o = {};
-        o[undefined] = 1;
-        console.log(o[undefined]);
-    }
-    expect: {
-        var o = {
-            undefined : 1
-        };
-        console.log(o[void 0]);
-    }
-    expect_stdout: "1"
-}
-
-join_object_assignments_Infinity: {
-    options = {
-        evaluate: true,
-        join_vars: true,
-        properties: true,
-    }
-    input: {
-        var o = {};
-        o[Infinity] = 1;
-        o[1/0] = 2;
-        o[-Infinity] = 3;
-        o[-1/0] = 4;
-        console.log(o[Infinity], o[1/0], o[-Infinity], o[-1/0]);
-    }
-    expect: {
-        var o = {
-            Infinity: 1,
-            Infinity: 2,
-            "-Infinity": 3,
-            "-Infinity": 4
-        };
-        console.log(o[1/0], o[1/0], o[-1/0], o[-1/0]);
-    }
-    expect_stdout: "2 2 4 4"
-}
-
-join_object_assignments_regex: {
-    options = {
-        evaluate: true,
-        join_vars: true,
-        properties: true,
-    }
-    input: {
-        var o = {};
-        o[/rx/] = 1;
-        console.log(o[/rx/]);
-    }
-    expect: {
-        var o = {
-            "/rx/": 1
-        };
-        console.log(o[/rx/]);
-    }
-    expect_stdout: "1"
-}
-
-issue_2816: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        "use strict";
-        var o = {
-            a: 1
-        };
-        o.b = 2;
-        o.a = 3;
-        o.c = 4;
-        console.log(o.a, o.b, o.c);
-    }
-    expect: {
-        "use strict";
-        var o = {
-            a: 1,
-            b: 2
-        };
-        o.a = 3;
-        o.c = 4;
-        console.log(o.a, o.b, o.c);
-    }
-    expect_stdout: "3 2 4"
-}
-
-issue_2893_1: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        var o = {
-            get a() {
-                return "PASS";
-            },
-        };
-        o.a = "FAIL";
-        console.log(o.a);
-    }
-    expect: {
-        var o = {
-            get a() {
-                return "PASS";
-            },
-        };
-        o.a = "FAIL";
-        console.log(o.a);
-    }
-    expect_stdout: "PASS"
-}
-
-issue_2893_2: {
-    options = {
-        join_vars: true,
-    }
-    input: {
-        var o = {
-            set a(v) {
-                this.b = v;
-            },
-            b: "FAIL",
-        };
-        o.a = "PASS";
-        console.log(o.b);
-    }
-    expect: {
-        var o = {
-            set a(v) {
-                this.b = v;
-            },
-            b: "FAIL",
-        };
-        o.a = "PASS";
-        console.log(o.b);
-    }
-    expect_stdout: "PASS"
-}
-
 issue_869_1: {
     mangle = {
         properties: {
@@ -1832,3 +1352,51 @@ issue_3188_3: {
     }
     expect_stdout: "PASS"
 }
+
+issue_3389: {
+    options = {
+        evaluate: true,
+        properties: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        (function() {
+            var a = "PASS";
+            if (delete b)
+                b = a[null] = 42;
+            console.log(a);
+        })();
+    }
+    expect: {
+        (function() {
+            var a = "PASS";
+            if (delete b)
+                b = a.null = 42;
+            console.log(a);
+        })();
+    }
+    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"
+}

test/compress/pure_funcs.js

@@ -136,7 +136,7 @@ relational: {
         side_effects :true,
     }
     input: {
-        foo() in foo();
+        foo() in new foo();
         foo() instanceof bar();
         foo() < "bar";
         bar() > 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,
@@ -642,3 +400,41 @@ issue_3065_4: {
         })();
     }
 }
+
+issue_3325_1: {
+    options = {
+        pure_funcs: "cb",
+        side_effects: true,
+    }
+    input: {
+        function cb() {
+            console.log("PASS");
+        }
+        cb();
+    }
+    expect: {
+        function cb() {
+            console.log("PASS");
+        }
+    }
+}
+
+issue_3325_2: {
+    options = {
+        pure_funcs: "xxxcbxxx",
+        side_effects: true,
+    }
+    input: {
+        function cb() {
+            console.log("PASS");
+        }
+        cb();
+    }
+    expect: {
+        function cb() {
+            console.log("PASS");
+        }
+        cb();
+    }
+    expect_stdout: "PASS"
+}

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,
@@ -848,9 +877,8 @@ collapse_vars_1_true: {
     }
     expect: {
         function f(a, b) {
-            for (;;) {
+            for (;;)
                 if (a.g() || b.p) break;
-            }
         }
     }
 }
@@ -980,6 +1008,7 @@ collapse_vars_2_strict: {
 collapse_rhs_true: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: true,
     }
     input: {
@@ -1016,6 +1045,7 @@ collapse_rhs_true: {
 collapse_rhs_false: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: false,
     }
     input: {
@@ -1052,6 +1082,7 @@ collapse_rhs_false: {
 collapse_rhs_strict: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: "strict",
     }
     input: {
@@ -1088,6 +1119,7 @@ collapse_rhs_strict: {
 collapse_rhs_setter: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: "strict",
     }
     input: {
@@ -1161,3 +1193,374 @@ collapse_rhs_lhs: {
     }
     expect_stdout: "1 3"
 }
+
+drop_arguments: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        (function() {
+            arguments.slice = function() {
+                console.log("PASS");
+            };
+            arguments[42];
+            arguments.length;
+            arguments.slice();
+        })();
+    }
+    expect: {
+        (function() {
+            arguments.slice = function() {
+                console.log("PASS");
+            };
+            arguments.slice();
+        })();
+    }
+    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 = {
+        evaluate: true,
+        inline: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        (function(b) {
+            b.p = 42;
+        })(a || (a = {}));
+    }
+    expect: {}
+    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",
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        try {
+            (function() {
+                arguments = null;
+                console.log(arguments.p = "FAIL");
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function() {
+                arguments = null;
+                console.log(arguments.p = "FAIL");
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    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"
+}

test/compress/regexp.js

@@ -35,3 +35,441 @@ regexp_2: {
     }
     expect_stdout: '["PASS","pass"]'
 }
+
+regexp_properties: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(/abc/g.source, /abc/g.global, /abc/g.ignoreCase, /abc/g.lastIndex, /abc/g.multiline);
+    }
+    expect: {
+        console.log("abc", true, false, /abc/g.lastIndex, false);
+    }
+    expect_stdout: "abc true false 0 false"
+}
+
+issue_3434_1: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        var o = {
+            "\n": RegExp("\n"),
+            "\r": RegExp("\r"),
+            "\t": RegExp("\t"),
+            "\b": RegExp("\b"),
+            "\f": RegExp("\f"),
+            "\0": RegExp("\0"),
+            "\x0B": RegExp("\x0B"),
+            "\u2028": RegExp("\u2028"),
+            "\u2029": RegExp("\u2029"),
+        };
+        for (var c in o)
+            console.log(o[c].test("\\"), o[c].test(c));
+    }
+    expect_exact: [
+        "var o = {",
+        '    "\\n": /\\n/,',
+        '    "\\r": /\\r/,',
+        '    "\\t": /\t/,',
+        '    "\\b": /\b/,',
+        '    "\\f": /\f/,',
+        '    "\\0": /\0/,',
+        '    "\\v": /\v/,',
+        '    "\\u2028": /\\u2028/,',
+        '    "\\u2029": /\\u2029/',
+        "};",
+        "",
+        'for (var c in o) console.log(o[c].test("\\\\"), o[c].test(c));',
+    ]
+    expect_stdout: [
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+    ]
+}
+
+issue_3434_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        var o = {
+            "\n": RegExp("\\\n"),
+            "\r": RegExp("\\\r"),
+            "\t": RegExp("\\\t"),
+            "\b": RegExp("\\\b"),
+            "\f": RegExp("\\\f"),
+            "\0": RegExp("\\\0"),
+            "\x0B": RegExp("\\\x0B"),
+            "\u2028": RegExp("\\\u2028"),
+            "\u2029": RegExp("\\\u2029"),
+        };
+        for (var c in o)
+            console.log(o[c].test("\\"), o[c].test(c));
+    }
+    expect_exact: [
+        "var o = {",
+        '    "\\n": /\\n/,',
+        '    "\\r": /\\r/,',
+        '    "\\t": /\t/,',
+        '    "\\b": /\b/,',
+        '    "\\f": /\f/,',
+        '    "\\0": /\0/,',
+        '    "\\v": /\v/,',
+        '    "\\u2028": /\\u2028/,',
+        '    "\\u2029": /\\u2029/',
+        "};",
+        "",
+        'for (var c in o) console.log(o[c].test("\\\\"), o[c].test(c));',
+    ]
+    expect_stdout: [
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+    ]
+}
+
+issue_3434_3: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        RegExp("\n");
+        RegExp("\r");
+        RegExp("\\n");
+        RegExp("\\\n");
+        RegExp("\\\\n");
+        RegExp("\\\\\n");
+        RegExp("\\\\\\n");
+        RegExp("\\\\\\\n");
+        RegExp("\u2028");
+        RegExp("\u2029");
+        RegExp("\n\r\u2028\u2029");
+        RegExp("\\\nfo\n[\n]o\\bbb");
+    }
+    expect: {
+        /\n/;
+        /\r/;
+        /\n/;
+        /\n/;
+        /\\n/;
+        /\\\n/;
+        /\\\n/;
+        /\\\n/;
+        /\u2028/;
+        /\u2029/;
+        /\n\r\u2028\u2029/;
+        /\nfo\n[\n]o\bbb/;
+    }
+}
+
+issue_3434_4: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        [
+            [ "", RegExp("") ],
+            [ "/", RegExp("/") ],
+            [ "//", RegExp("//") ],
+            [ "\/", RegExp("\\/") ],
+            [ "///", RegExp("///") ],
+            [ "/\/", RegExp("/\\/") ],
+            [ "\//", RegExp("\\//") ],
+            [ "\\/", RegExp("\\\\/") ],
+            [ "////", RegExp("////") ],
+            [ "//\/", RegExp("//\\/") ],
+            [ "/\//", RegExp("/\\//") ],
+            [ "/\\/", RegExp("/\\\\/") ],
+            [ "\///", RegExp("\\///") ],
+            [ "\/\/", RegExp("\\/\\/") ],
+            [ "\\//", RegExp("\\\\//") ],
+            [ "\\\/", RegExp("\\\\\\/") ],
+        ].forEach(function(test) {
+            console.log(test[1].test("\\"), test[1].test(test[0]));
+        });
+    }
+    expect: {
+        [
+            [ "", /(?:)/ ],
+            [ "/", /\// ],
+            [ "//", /\/\// ],
+            [ "/", /\// ],
+            [ "///", /\/\/\// ],
+            [ "//", /\/\// ],
+            [ "//", /\/\// ],
+            [ "\\/", /\\\// ],
+            [ "////", /\/\/\/\// ],
+            [ "///", /\/\/\// ],
+            [ "///", /\/\/\// ],
+            [ "/\\/", /\/\\\// ],
+            [ "///", /\/\/\// ],
+            [ "//", /\/\// ],
+            [ "\\//", /\\\/\// ],
+            [ "\\/", /\\\// ],
+        ].forEach(function(test) {
+            console.log(test[1].test("\\"), test[1].test(test[0]));
+        });
+    }
+    expect_stdout: [
+        "true true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+        "false true",
+    ]
+}
+
+exec: {
+    options = {
+        evaluate: true,
+        loops: true,
+        unsafe: true,
+    }
+    input: {
+        while (/a/.exec("AAA"))
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect: {
+        for (;null;)
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+exec_global: {
+    options = {
+        evaluate: true,
+        loops: true,
+        unsafe: true,
+    }
+    input: {
+        while (/a/g.exec("AAA"))
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect: {
+        for (;null;)
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+test: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        while (/a/.test("AAA"))
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect: {
+        while (false)
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+test_global: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        while (/a/g.test("AAA"))
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect: {
+        while (false)
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+var_exec: {
+    options = {
+        evaluate: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var r = /a/;
+        while (r.exec("AAA"))
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect: {
+        var r = /a/;
+        for (;null;)
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+var_exec_global: {
+    options = {
+        evaluate: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var r = /a/g;
+        while (r.exec("aaa"))
+            console.log("PASS");
+    }
+    expect: {
+        var r = /a/g;
+        for (;r.exec("aaa");)
+            console.log("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+}
+
+var_test: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var r = /a/;
+        while (r.test("AAA"))
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect: {
+        var r = /a/;
+        while (false)
+            console.log("FAIL");
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+var_test_global: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var r = /a/g;
+        while (r.test("aaa"))
+            console.log("PASS");
+    }
+    expect: {
+        var r = /a/g;
+        while (r.test("aaa"))
+            console.log("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+}
+
+lazy_boolean: {
+    options = {
+        evaluate: true,
+        passes: 2,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        /b/.exec({}) && console.log("PASS");
+        /b/.test({}) && console.log("PASS");
+        /b/g.exec({}) && console.log("PASS");
+        /b/g.test({}) && console.log("PASS");
+    }
+    expect: {
+        console.log("PASS");
+        console.log("PASS");
+        console.log("PASS");
+        console.log("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+}
+
+reset_state_between_evaluate: {
+    options = {
+        evaluate: true,
+        passes: 2,
+        unsafe: true,
+    }
+    input: {
+        console.log(function() {
+            for (var a in /[abc4]/g.exec("a"))
+                return "PASS";
+            return "FAIL";
+        }());
+    }
+    expect: {
+        console.log(function() {
+            for (var a in /[abc4]/g.exec("a"))
+                return "PASS";
+            return "FAIL";
+        }());
+    }
+    expect_stdout: "PASS"
+}

test/compress/rename.js

@@ -534,3 +534,208 @@ function_catch_catch_ie8: {
         "undefined",
     ]
 }
+
+function_do_catch_ie8: {
+    rename = true
+    options = {
+        ie8: true,
+        side_effects: true,
+        unused: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1, b = 1, c = 0;
+        function d(e) {
+            var f, g, h, i;
+            do {
+                try {
+                    try {
+                        var j = function q(){}();
+                    } catch (r) {
+                        --a && w("ddddddddeeeeeeegggggggggiiiiilllllllnnnnntuuuuuuuuyyyyyyy");
+                        var k, l, m, n, o;
+                        --m;
+                        --n;
+                        --o;
+                    }
+                    try {
+                        i[1];
+                    } catch (s) {
+                        var p;
+                        switch (function t() {
+                            c++;
+                        }()) {
+                          case j + --p:
+                        }
+                    }
+                } catch (u) {}
+            } while (--i);
+            b--;
+        }
+        d();
+        console.log(b, c);
+    }
+    expect: {
+        var u = 1, y = 1, a = 0;
+        function c(c) {
+            var d;
+            do {
+                try {
+                    try {
+                        var e = void 0;
+                    } catch (i) {
+                        --u && w("ddddddddeeeeeeegggggggggiiiiilllllllnnnnntuuuuuuuuyyyyyyy");
+                        0;
+                        0;
+                        0;
+                    }
+                    try {
+                        d[1];
+                    } catch (l) {
+                        var g;
+                        switch (function n() {
+                            a++;
+                        }()) {
+                        case e + --g:
+                        }
+                    }
+                } catch (t) {}
+            } while (--d);
+            y--;
+        }
+        c();
+        console.log(y, a);
+    }
+    expect_stdout: "0 1"
+}
+
+issue_3480: {
+    rename = true,
+    mangle = {
+        ie8: false,
+        toplevel: false,
+    }
+    input: {
+        var d, a, b, c = "FAIL";
+        (function b() {
+            (function() {
+                try {
+                    c = "PASS";
+                } catch (b) {
+                }
+            })();
+        })();
+        console.log(c);
+    }
+    expect: {
+        var d, a, b, c = "FAIL";
+        (function n() {
+            (function() {
+                try {
+                    c = "PASS";
+                } catch (c) {}
+            })();
+        })();
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3480_ie8: {
+    rename = true,
+    mangle = {
+        ie8: true,
+        toplevel: false,
+    }
+    input: {
+        var d, a, b, c = "FAIL";
+        (function b() {
+            (function() {
+                try {
+                    c = "PASS";
+                } catch (b) {
+                }
+            })();
+        })();
+        console.log(c);
+    }
+    expect: {
+        var d, a, b, c = "FAIL";
+        (function b() {
+            (function() {
+                try {
+                    c = "PASS";
+                } catch (b) {}
+            })();
+        })();
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3480_toplevel: {
+    rename = true,
+    mangle = {
+        ie8: false,
+        toplevel: true,
+    }
+    input: {
+        var d, a, b, c = "FAIL";
+        (function b() {
+            (function() {
+                try {
+                    c = "PASS";
+                } catch (b) {
+                }
+            })();
+        })();
+        console.log(c);
+    }
+    expect: {
+        var c, n, o, t = "FAIL";
+        (function c() {
+            (function() {
+                try {
+                    t = "PASS";
+                } catch (c) {}
+            })();
+        })();
+        console.log(t);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3480_ie8_toplevel: {
+    rename = true,
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var d, a, b, c = "FAIL";
+        (function b() {
+            (function() {
+                try {
+                    c = "PASS";
+                } catch (b) {
+                }
+            })();
+        })();
+        console.log(c);
+    }
+    expect: {
+        var c, n, o, t = "FAIL";
+        (function o() {
+            (function() {
+                try {
+                    t = "PASS";
+                } catch (o) {}
+            })();
+        })();
+        console.log(t);
+    }
+    expect_stdout: "PASS"
+}

test/compress/rests.js

@@ -0,0 +1,786 @@
+arrow_1: {
+    input: {
+        console.log.apply(console, ((...a) => a)("PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,((...a)=>a)("PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+arrow_2: {
+    input: {
+        console.log.apply(console, ((a, ...b) => b)("FAIL", "PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,((a,...b)=>b)("FAIL","PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+arrow_destructured_array_1: {
+    input: {
+        console.log.apply(console, (([ ...a ]) => a)("PASS"));
+    }
+    expect_exact: 'console.log.apply(console,(([...a])=>a)("PASS"));'
+    expect_stdout: "P A S S"
+    node_version: ">=6"
+}
+
+arrow_destructured_array_2: {
+    input: {
+        console.log.apply(console, (([ a, ...b ]) => b)([ "FAIL", "PASS", 42 ]));
+    }
+    expect_exact: 'console.log.apply(console,(([a,...b])=>b)(["FAIL","PASS",42]));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+arrow_destructured_array_3: {
+    input: {
+        console.log((([ [ ...a ] = "FAIL" ]) => a)([ "PASS" ]).join("|"));
+    }
+    expect_exact: 'console.log((([[...a]="FAIL"])=>a)(["PASS"]).join("|"));'
+    expect_stdout: "P|A|S|S"
+    node_version: ">=6"
+}
+
+arrow_destructured_object_1: {
+    input: {
+        var f = ({ ...a }) => a, o = f({ PASS: 42 });
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_exact: "var f=({...a})=>a,o=f({PASS:42});for(var k in o)console.log(k,o[k]);"
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+arrow_destructured_object_2: {
+    input: {
+        var f = ({ FAIL: a, ...b }) => b, o = f({ PASS: 42, FAIL: null });
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_exact: "var f=({FAIL:a,...b})=>b,o=f({PASS:42,FAIL:null});for(var k in o)console.log(k,o[k]);"
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+arrow_destructured_object_3: {
+    input: {
+        var f = ([ { ...a } = [ "FAIL" ] ]) => a;
+        var o = f([ "PASS" ]);
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_exact: 'var f=([{...a}=["FAIL"]])=>a;var o=f(["PASS"]);for(var k in o)console.log(k,o[k]);'
+    expect_stdout: [
+        "0 P",
+        "1 A",
+        "2 S",
+        "3 S",
+    ]
+    node_version: ">=8"
+}
+
+funarg_1: {
+    input: {
+        console.log.apply(console, function(...a) {
+            return a;
+        }("PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,function(...a){return a}("PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+funarg_2: {
+    input: {
+        console.log.apply(console, function(a, ...b) {
+            return b;
+        }("FAIL", "PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,function(a,...b){return b}("FAIL","PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+destructured_array_1: {
+    input: {
+        var [ ...a ] = [ "PASS", 42 ];
+        console.log.apply(console, a);
+    }
+    expect_exact: 'var[...a]=["PASS",42];console.log.apply(console,a);'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+destructured_array_2: {
+    input: {
+        var [ a, ...b ] = [ "FAIL", "PASS", 42 ];
+        console.log.apply(console, b);
+    }
+    expect_exact: 'var[a,...b]=["FAIL","PASS",42];console.log.apply(console,b);'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+destructured_object_1: {
+    input: {
+        var { ...a } = [ "FAIL", "PASS", 42 ];
+        console.log(a[1], a[2]);
+    }
+    expect_exact: 'var{...a}=["FAIL","PASS",42];console.log(a[1],a[2]);'
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+destructured_object_2: {
+    input: {
+        var { 0: a, ...b } = [ "FAIL", "PASS", 42 ];
+        console.log(b[1], b[2]);
+    }
+    expect_exact: 'var{0:a,...b}=["FAIL","PASS",42];console.log(b[1],b[2]);'
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+drop_fargs: {
+    options = {
+        keep_fargs: false,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, ...b) {
+            return b[0];
+        }("FAIL", "PASS"));
+    }
+    expect: {
+        console.log(function(b) {
+            return b[0];
+        }([ "PASS" ]));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+inline: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        console.log(function(a, ...[ b, c ]) {
+            return c + b + a;
+        }("SS", "A", "P"));
+    }
+    expect: {
+        console.log(([ a, ...[ b, c ] ] = [ "SS", "A", "P" ], c + b + a));
+        var a, b, c;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+retain_var: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var [ ...a ] = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect: {
+        var [ ...a ] = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+reduce_destructured_array: {
+    options = {
+        reduce_vars: true,
+        rests: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var [ ...a ] = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect: {
+        console.log([ "PASS" ][0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+reduce_destructured_object: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var { ...a } = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect: {
+        var { ...a } = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+retain_destructured_array: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var [ a, ...b ] = [ "FAIL", "PASS", 42 ];
+        console.log.apply(console, b);
+    }
+    expect: {
+        var [ , ...b ] = [ "FAIL", "PASS", 42 ];
+        console.log.apply(console, b);
+    }
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+retain_destructured_object_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var { 0: a, ...b } = [ "FAIL", "PASS", 42 ];
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect: {
+        var { 0: a, ...b } = [ "FAIL", "PASS", 42 ];
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect_stdout: [
+        "1 PASS",
+        "2 42",
+    ]
+    node_version: ">=8"
+}
+
+retain_destructured_object_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var { foo: [ a ], ...b } = { foo: [ "FAIL" ], bar: "PASS", baz: 42 };
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect: {
+        var { foo: [], ...b } = { foo: [ "FAIL" ], bar: "PASS", baz: 42 };
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect_stdout: [
+        "bar PASS",
+        "baz 42",
+    ]
+    node_version: ">=8"
+}
+
+retain_funarg_destructured_array_1: {
+    options = {
+        inline: true,
+        keep_fargs: false,
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        console.log((([ ...a ]) => a)([ "PASS" ])[0]);
+    }
+    expect: {
+        console.log((([ ...a ]) => a)([ "PASS" ])[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+retain_funarg_destructured_array_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function([ a, ...b ]) {
+            return b;
+        }("bar")[1]);
+    }
+    expect: {
+        console.log(function([ , ...b ]) {
+            return b;
+        }("bar")[1]);
+    }
+    expect_stdout: "r"
+    node_version: ">=6"
+}
+
+retain_funarg_destructured_object_1: {
+    options = {
+        inline: true,
+        keep_fargs: false,
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        console.log((({ ...a }) => a)([ "PASS" ])[0]);
+    }
+    expect: {
+        console.log((({ ...a }) => a)([ "PASS" ])[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+retain_funarg_destructured_object_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function({ p: a, ... b }) {
+            return b;
+        }({ p: "FAIL" }).p || "PASS");
+    }
+    expect: {
+        console.log(function({ p: a, ... b }) {
+            return b;
+        }({ p: "FAIL" }).p || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+drop_unused_call_args_1: {
+    options = {
+        rests: true,
+        unused: true,
+    }
+    input: {
+        (function(...a) {
+            console.log(a[0]);
+        })(42, console.log("PASS"));
+    }
+    expect: {
+        (function(a) {
+            console.log(a[0]);
+        })([ 42, console.log("PASS") ]);
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+drop_unused_call_args_2: {
+    options = {
+        keep_fargs: false,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, ...b) {
+            return b;
+        }(console).length);
+    }
+    expect: {
+        console.log(function(b) {
+            return b;
+        }((console, [])).length);
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+merge_funarg: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function(...a) {
+            var b = a.length;
+            console.log(b);
+        })();
+    }
+    expect: {
+        (function(...b) {
+            var b = b.length;
+            console.log(b);
+        })();
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+merge_funarg_destructured_array: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function([ ...a ]) {
+            var b = a.length;
+            console.log(b);
+        })([]);
+    }
+    expect: {
+        (function([ ...b ]) {
+            var b = b.length;
+            console.log(b);
+        })([]);
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+merge_funarg_destructured_object: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function({ ...a }) {
+            var b = a[0];
+            console.log(b);
+        })([ "PASS" ]);
+    }
+    expect: {
+        (function({ ...b }) {
+            var b = b[0];
+            console.log(b);
+        })([ "PASS" ]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+keep_arguments: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        (function(...[ {} ]) {
+            console.log(arguments[0]);
+        })("PASS");
+    }
+    expect: {
+        (function(...[ {} ]) {
+            console.log(arguments[0]);
+        })("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_rest_array: {
+    options = {
+        rests: true,
+    }
+    input: {
+        var [ ...[ a ]] = [ "PASS" ];
+        console.log(a);
+    }
+    expect: {
+        var [ a ] = [ "PASS" ];
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_rest_arrow: {
+    options = {
+        arrows: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        rests: true,
+    }
+    input: {
+        console.log(((...[ a ]) => a)("PASS"));
+    }
+    expect: {
+        console.log((a => a)("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_rest_lambda: {
+    options = {
+        keep_fargs: false,
+        reduce_vars: true,
+        rests: true,
+        toplevel: true,
+    }
+    input: {
+        function f(...[ a ]) {
+            return a;
+        }
+        console.log(f("PASS"), f(42));
+    }
+    expect: {
+        function f(a) {
+            return a;
+        }
+        console.log(f("PASS"), f(42));
+    }
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+issue_4525_1: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4525_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4538: {
+    options = {
+        rests: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function f(...a) {
+            return a.p, f;
+        }()());
+    }
+    expect: {
+        console.log(typeof function f(...a) {
+            return a.p, f;
+        }()());
+    }
+    expect_stdout: "function"
+    node_version: ">=6"
+}
+
+issue_4544_1: {
+    options = {
+        keep_fnames: true,
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function f(...[ {} ]) {})();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            [ ...[ {} ] ] = [];
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4544_2: {
+    options = {
+        keep_fnames: true,
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function f(a, ...[ {} ]) {})([]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            [ , ...[ {} ] ] = [ [] ];
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4562: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        rests: true,
+        unsafe: true,
+    }
+    input: {
+        console.log((([ ...[ a ] ]) => a)("foo"));
+    }
+    expect: {
+        console.log((([ a ]) => a)("foo"));
+    }
+    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

@@ -12,3 +12,163 @@ console_log: {
         "% %s",
     ]
 }
+
+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,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var arguments;
+        console.log((typeof arguments).length);
+    }
+    expect: {
+        var arguments;
+        console.log((typeof arguments).length);
+    }
+    expect_stdout: "6"
+}
+
+typeof_arguments_assigned: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var arguments = void 0;
+        console.log((typeof arguments).length);
+    }
+    expect: {
+        console.log("undefined".length);
+    }
+    expect_stdout: "9"
+}
+
+toplevel_Infinity_NaN_undefined: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var Infinity = "foo";
+        var NaN = 42;
+        var undefined = null;
+        console.log(Infinity, NaN, undefined);
+    }
+    expect: {
+        console.log("foo", 42, null);
+    }
+    expect_stdout: "foo 42 null"
+}
+
+log_global: {
+    input: {
+        console.log(function() {
+            return this;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            return this;
+        }());
+    }
+    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({
+            set p(v) {
+                throw "FAIL";
+            },
+        });
+    }
+    expect: {
+        console.log({
+            set p(v) {
+                throw "FAIL";
+            },
+        });
+    }
+    expect_stdout: "{ p: [Setter] }"
+}

test/compress/sequences.js

@@ -490,6 +490,7 @@ issue_1758: {
 delete_seq_1: {
     options = {
         booleans: true,
+        evaluate: true,
         side_effects: true,
     }
     input: {
@@ -514,6 +515,7 @@ delete_seq_1: {
 delete_seq_2: {
     options = {
         booleans: true,
+        evaluate: true,
         side_effects: true,
     }
     input: {
@@ -538,6 +540,7 @@ delete_seq_2: {
 delete_seq_3: {
     options = {
         booleans: true,
+        evaluate: true,
         keep_infinity: true,
         side_effects: true,
     }
@@ -563,6 +566,35 @@ 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,
         sequences: true,
         side_effects: true,
     }
@@ -590,6 +622,36 @@ 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,
         keep_infinity: true,
         sequences: true,
         side_effects: true,
@@ -618,6 +680,7 @@ delete_seq_5: {
 delete_seq_6: {
     options = {
         booleans: true,
+        evaluate: true,
         side_effects: true,
     }
     input: {
@@ -657,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: {
@@ -702,7 +774,7 @@ side_effects_cascade_3: {
     }
     expect: {
         function f(a, b) {
-            !(b += a) && ((b = a) || (b -= a, b ^= a)),
+            (b += a) || (b = a) || (b -= a, b ^= a),
             a--;
         }
     }
@@ -871,7 +943,7 @@ for_init_var: {
     expect_stdout: "PASS"
 }
 
-forin: {
+forin_1: {
     options = {
         sequences: true,
     }
@@ -889,6 +961,49 @@ forin: {
     expect_stdout: "PASS"
 }
 
+forin_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            p: 1,
+            q: 2,
+        };
+        var k = "k";
+        for ((console.log("exp"), o)[function() {
+            console.log("prop");
+            return k;
+        }()] in function() {
+            console.log("obj");
+            return o;
+        }())
+            console.log(o.k, o[o.k]);
+    }
+    expect: {
+        var o = {
+            p: 1,
+            q: 2,
+        };
+        for ((console.log("exp"), o)[console.log("prop"), "k"] in console.log("obj"), o)
+            console.log(o.k, o[o.k]);
+    }
+    expect_stdout: [
+        "obj",
+        "exp",
+        "prop",
+        "p 1",
+        "exp",
+        "prop",
+        "q 2",
+    ]
+}
+
 call: {
     options = {
         sequences: true,
@@ -904,15 +1019,23 @@ call: {
             console.log(this === b ? "bar" : "baz");
         };
         (a, b)();
+        (a, b).c();
         (a, b.c)();
+        (a, b)["c"]();
+        (a, b["c"])();
         (a, function() {
             console.log(this === a);
         })();
         new (a, b)();
+        new (a, b).c();
         new (a, b.c)();
+        new (a, b)["c"]();
+        new (a, b["c"])();
         new (a, function() {
             console.log(this === a);
         })();
+        console.log(typeof (a, b).c);
+        console.log(typeof (a, b)["c"]);
     }
     expect: {
         var a = function() {
@@ -924,23 +1047,199 @@ call: {
         b.c = function() {
             console.log(this === b ? "bar" : "baz");
         },
-        a, b(),
+        b(),
+        b.c(),
         (a, b.c)(),
-        a, function() {
+        b["c"](),
+        (a, b["c"])(),
+        function() {
             console.log(this === a);
         }(),
-        a, new b(),
-        a, new b.c(),
-        a, new function() {
+        new b(),
+        new b.c(),
+        new b.c(),
+        new b["c"](),
+        new b["c"](),
+        new function() {
             console.log(this === a);
-        }();
+        }(),
+        console.log((a, typeof b.c)),
+        console.log((a, typeof b["c"]));
     }
     expect_stdout: [
         "foo",
+        "bar",
+        "baz",
+        "bar",
         "baz",
         "true",
         "foo",
         "baz",
+        "baz",
+        "baz",
+        "baz",
         "false",
+        "function",
+        "function",
     ]
 }
+
+missing_link: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        sequences: true,
+    }
+    input: {
+        var a = 100;
+        a;
+        a++ + (0 ? 2 : 1);
+        console.log(a);
+    }
+    expect: {
+        var a = 100;
+        a,
+        a++,
+        console.log(a);
+    }
+}
+
+angularjs_chain: {
+    options = {
+        conditionals: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function nonComputedMember(left, right, context, create) {
+            var lhs = left();
+            if (create && create !== 1) {
+                if (lhs && lhs[right] == null) {
+                    lhs[right] = {};
+                }
+            }
+            var value = lhs != null ? lhs[right] : undefined;
+            if (context) {
+                return { context: lhs, name: right, value: value };
+            } else {
+                return value;
+            }
+        }
+    }
+    expect: {
+        function nonComputedMember(left, right, context, create) {
+            var lhs = left();
+            create && 1 !== create && lhs && null == lhs[right] && (lhs[right] = {});
+            var value = null != lhs ? lhs[right] : void 0;
+            return context ? {
+                context: lhs,
+                name: right,
+                value: value
+            } : value;
+        }
+    }
+}
+
+issue_3490_1: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        inline: 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;
+            a && a.p;
+        }(), c = "PASS", b) while ("" == typeof d);
+        console.log(c, b);
+    }
+    expect_stdout: "PASS 42"
+}
+
+issue_3490_2: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        reduce_vars: 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) for (; "" == typeof d;);
+        console.log(c, b);
+    }
+    expect: {
+        var b = 42, c = "FAIL";
+        for (function() {
+            var a;
+        }(), c = "PASS", b; "" == typeof d;);
+        console.log(c, b);
+    }
+    expect_stdout: "PASS 42"
+}
+
+issue_3703: {
+    options = {
+        evaluate: true,
+        sequences: true,
+        unsafe: true,
+    }
+    input: {
+        var a = "FAIL";
+        while ((a = "PASS", 0).foo = 0);
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        while (a = "PASS", (0).foo = 0);
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4079: {
+    options = {
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        try {
+            typeof (0, A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            A;
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/side_effects.js

@@ -0,0 +1,617 @@
+accessor: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            get a() {},
+            set a(v){
+                this.b = 2;
+            },
+            b: 1
+        });
+    }
+    expect: {}
+}
+
+issue_2233_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        Array.isArray;
+        Boolean;
+        console.log;
+        Date;
+        decodeURI;
+        decodeURIComponent;
+        encodeURI;
+        encodeURIComponent;
+        Error.name;
+        escape;
+        eval;
+        EvalError;
+        Function.length;
+        isFinite;
+        isNaN;
+        JSON;
+        Math.random;
+        Number.isNaN;
+        parseFloat;
+        parseInt;
+        RegExp;
+        Object.defineProperty;
+        String.fromCharCode;
+        RangeError;
+        ReferenceError;
+        SyntaxError;
+        TypeError;
+        unescape;
+        URIError;
+    }
+    expect: {}
+    expect_stdout: true
+}
+
+global_timeout_and_interval_symbols: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        // These global symbols do not exist in the test sandbox
+        // and must be tested separately.
+        clearInterval;
+        clearTimeout;
+        setInterval;
+        setTimeout;
+    }
+    expect: {}
+}
+
+issue_2233_2: {
+    options = {
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var RegExp;
+        Array.isArray;
+        RegExp;
+        UndeclaredGlobal;
+        function foo() {
+            var Number;
+            AnotherUndeclaredGlobal;
+            Math.sin;
+            Number.isNaN;
+        }
+    }
+    expect: {
+        var RegExp;
+        UndeclaredGlobal;
+        function foo() {
+            AnotherUndeclaredGlobal;
+            (void 0).isNaN;
+        }
+    }
+}
+
+issue_2233_3: {
+    options = {
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var RegExp;
+        Array.isArray;
+        RegExp;
+        UndeclaredGlobal;
+        function foo() {
+            var Number;
+            AnotherUndeclaredGlobal;
+            Math.sin;
+            Number.isNaN;
+        }
+    }
+    expect: {
+        UndeclaredGlobal;
+    }
+}
+
+global_fns: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        Boolean(1, 2);
+        decodeURI(1, 2);
+        decodeURIComponent(1, 2);
+        Date(1, 2);
+        encodeURI(1, 2);
+        encodeURIComponent(1, 2);
+        Error(1, 2);
+        escape(1, 2);
+        EvalError(1, 2);
+        isFinite(1, 2);
+        isNaN(1, 2);
+        Number(1, 2);
+        Object(1, 2);
+        parseFloat(1, 2);
+        parseInt(1, 2);
+        RangeError(1, 2);
+        ReferenceError(1, 2);
+        String(1, 2);
+        SyntaxError(1, 2);
+        TypeError(1, 2);
+        unescape(1, 2);
+        URIError(1, 2);
+        try {
+            Function(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            RegExp(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            Array(NaN);
+        } catch (e) {
+            console.log(e.name);
+        }
+    }
+    expect: {
+        try {
+            Function(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            RegExp(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            Array(NaN);
+        } catch (e) {
+            console.log(e.name);
+        }
+    }
+    expect_stdout: [
+        "SyntaxError",
+        "SyntaxError",
+        "RangeError",
+    ]
+}
+
+unsafe_builtin_1: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        (!w).constructor(x);
+        Math.abs(y);
+        [ 1, 2, z ].valueOf();
+    }
+    expect: {
+        w, x;
+        y;
+        z;
+    }
+}
+
+unsafe_builtin_2: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        var o = {};
+        constructor.call(o, 42);
+        __defineGetter__.call(o, "foo", function() {
+            return o.p;
+        });
+        __defineSetter__.call(o, void 0, function(a) {
+            o.p = a;
+        });
+        console.log(typeof o, o.undefined = "PASS", o.foo);
+    }
+    expect: {
+        var o = {};
+        constructor.call(o, 42);
+        __defineGetter__.call(o, "foo", function() {
+            return o.p;
+        });
+        __defineSetter__.call(o, void 0, function(a) {
+            o.p = a;
+        });
+        console.log(typeof o, o.undefined = "PASS", o.foo);
+    }
+    expect_stdout: "object PASS PASS"
+}
+
+unsafe_builtin_3: {
+    options = {
+        conditionals: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var o = {};
+        if (42 < Math.random())
+            o.p = "FAIL";
+        else
+            o.p = "PASS";
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {};
+        o.p = 42 < Math.random() ? "FAIL" : "PASS";
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: "p PASS"
+}
+
+unsafe_string_replace: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        "foo".replace("f", function() {
+            console.log("PASS");
+        });
+    }
+    expect: {
+        "foo".replace("f", function() {
+            console.log("PASS");
+        });
+    }
+    expect_stdout: "PASS"
+}
+
+drop_value: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (1, [2, foo()], 3, {a:1, b:bar()});
+    }
+    expect: {
+        foo(), bar();
+    }
+}
+
+operator_in: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        try {
+            "foo" in true;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            0 in true;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3983_1: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        function f() {
+            g && g();
+        }
+        f();
+        function g() {
+            0 ? a : 0;
+        }
+        var b = a;
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3983_2: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        function f() {
+            g && g();
+        }
+        f();
+        function g() {
+            0 ? a : 0;
+        }
+        var b = a;
+        console.log(a);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4008: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        function f(b, b) {
+            console.log(b);
+        }
+        f && f(a && a[a]);
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        function f(b, b) {
+            console.log(b);
+        }
+        f(a[a]);
+        console.log(a);
+    }
+    expect_stdout: [
+        "undefined",
+        "PASS",
+    ]
+}
+
+trim_new: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        new function(a) {
+            console.log(a);
+        }("PASS");
+    }
+    expect: {
+        (function(a) {
+            console.log(a);
+        })("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4325: {
+    options = {
+        keep_fargs: false,
+        passes: 2,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function f() {
+            (function(b, c) {
+                try {
+                    c.p = 0;
+                } catch (e) {
+                    console.log("PASS");
+                    return b;
+                }
+                c;
+            })(f++);
+        })();
+    }
+    expect: {
+        (function() {
+            (function(c) {
+                try {
+                    c.p = 0;
+                } catch (e) {
+                    console.log("PASS");
+                    return;
+                }
+            })(void 0);
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4366_1: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            p: 42,
+            get p() {},
+            q: console.log("PASS"),
+        });
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4366_2: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            set p(v) {},
+            q: console.log("PASS"),
+            p: 42,
+        });
+    }
+    expect: {
+        console.log("PASS");
+    }
+    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/switch.js

@@ -1,5 +1,6 @@
 constant_switch_1: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -19,6 +20,7 @@ constant_switch_1: {
 
 constant_switch_2: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -39,6 +41,7 @@ constant_switch_2: {
 
 constant_switch_3: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -60,6 +63,7 @@ constant_switch_3: {
 
 constant_switch_4: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -86,6 +90,7 @@ constant_switch_4: {
 
 constant_switch_5: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -120,6 +125,7 @@ constant_switch_5: {
 
 constant_switch_6: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -154,6 +160,7 @@ constant_switch_6: {
 
 constant_switch_7: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -197,6 +204,7 @@ constant_switch_7: {
 
 constant_switch_8: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -226,6 +234,7 @@ constant_switch_8: {
 
 constant_switch_9: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -261,13 +270,13 @@ drop_default_1: {
     }
     input: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
           default:
         }
     }
     expect: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
         }
     }
 }
@@ -279,14 +288,14 @@ drop_default_2: {
     }
     input: {
         switch (foo) {
-          case 'bar': baz(); break;
+          case "bar": baz(); break;
           default:
             break;
         }
     }
     expect: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
         }
     }
 }
@@ -298,7 +307,7 @@ keep_default: {
     }
     input: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
           default:
             something();
             break;
@@ -306,7 +315,7 @@ keep_default: {
     }
     expect: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
           default:
             something();
         }
@@ -315,6 +324,7 @@ keep_default: {
 
 issue_1663: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -347,25 +357,103 @@ issue_1663: {
     expect_stdout: true
 }
 
-drop_case: {
+drop_case_1: {
     options = {
         dead_code: true,
         switches: true,
     }
     input: {
         switch (foo) {
-          case 'bar': baz(); break;
-          case 'moo':
+          case "bar": baz(); break;
+          case "moo":
             break;
         }
     }
     expect: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
         }
     }
 }
 
+drop_case_2: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (foo) {
+          case "bar":
+            bar();
+            break;
+          default:
+          case "moo":
+            moo();
+            break;
+        }
+    }
+    expect: {
+        switch (foo) {
+          case "bar":
+            bar();
+            break;
+          default:
+            moo();
+        }
+    }
+}
+
+drop_case_3: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var c = "PASS";
+        switch ({}.p) {
+          default:
+          case void 0:
+            break;
+          case c = "FAIL":
+        }
+        console.log(c);
+    }
+    expect: {
+        var c = "PASS";
+        switch ({}.p) {
+          default:
+          case void 0:
+            break;
+          case c = "FAIL":
+        }
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+drop_case_4: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (0) {
+          case [ a, typeof b ]:
+          default:
+            var a;
+        }
+        console.log("PASS");
+    }
+    expect: {
+        switch (0) {
+          case [ a, typeof b ]:
+            var a;
+        }
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
 keep_case: {
     options = {
         dead_code: true,
@@ -373,14 +461,14 @@ keep_case: {
     }
     input: {
         switch (foo) {
-          case 'bar': baz(); break;
+          case "bar": baz(); break;
           case moo:
             break;
         }
     }
     expect: {
         switch (foo) {
-          case 'bar': baz(); break;
+          case "bar": baz(); break;
           case moo:
         }
     }
@@ -473,6 +561,7 @@ issue_441_2: {
 
 issue_1674: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -539,7 +628,7 @@ issue_1679: {
         f();
         console.log(a, b);
     }
-    expect_stdout: true
+    expect_stdout: "99 8"
 }
 
 issue_1680_1: {
@@ -798,6 +887,7 @@ beautify: {
 
 issue_1758: {
     options = {
+        conditionals: true,
         dead_code: true,
         switches: true,
     }
@@ -820,15 +910,16 @@ issue_1758: {
 
 issue_2535: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         switches: true,
     }
     input: {
         switch(w(), 42) {
-            case 13: x();
-            case 42: y();
-            default: z();
+          case 13: x();
+          case 42: y();
+          default: z();
         }
     }
     expect: {
@@ -841,6 +932,7 @@ issue_2535: {
 
 issue_1750: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         switches: true,
@@ -864,3 +956,228 @@ issue_1750: {
     }
     expect_stdout: "0 2"
 }
+
+drop_switch_1: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (foo) {
+          default:
+            break;
+          case "bar":
+            break;
+        }
+    }
+    expect: {
+        foo;
+    }
+}
+
+drop_switch_2: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (foo) {
+          default:
+          case "bar":
+            baz();
+        }
+    }
+    expect: {
+        foo;
+        baz();
+    }
+}
+
+drop_switch_3: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        console.log(function() {
+            switch (0) {
+              default:
+                return "PASS";
+              case 1:
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            switch (0) {
+              default:
+                return "PASS";
+              case 1:
+            }
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+drop_switch_4: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a = "FAIL";
+        switch (0) {
+          default:
+          case a:
+            var b = a = "PASS";
+            break;
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        0;
+        var b = a = "PASS";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+drop_switch_5: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (A) {
+          case B:
+            x();
+          default:
+        }
+        switch (C) {
+          default:
+            y();
+          case D:
+        }
+    }
+    expect: {
+        A === B && x();
+        C !== D && y();
+    }
+}
+
+drop_switch_6: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (A) {
+          case B:
+          default:
+            x();
+        }
+        switch (C) {
+          default:
+          case D:
+            y();
+        }
+    }
+    expect: {
+        A === B;
+        x();
+        C !== D;
+        y();
+    }
+}
+
+drop_switch_7: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (A) {
+          case B:
+            w();
+          default:
+            x();
+        }
+        switch (C) {
+          default:
+            y();
+          case D:
+            z();
+        }
+    }
+    expect: {
+        A === B && w();
+        x();
+        C !== D && y();
+        z();
+    }
+}
+
+drop_switch_8: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (A) {
+          case B:
+            w();
+            break;
+          default:
+            x();
+        }
+        switch (C) {
+          default:
+            y();
+            break;
+          case D:
+            z();
+        }
+    }
+    expect: {
+        (A === B ? w : x)();
+        (C !== D ? y : z)();
+    }
+}
+
+issue_4059: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        switch (0) {
+          default:
+          case 1:
+            break;
+          case a:
+            break;
+            var a;
+        }
+        console.log("PASS");
+    }
+    expect: {
+        switch (0) {
+          default:
+            break;
+          case a:
+            break;
+            var a;
+        }
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}

test/compress/templates.js

@@ -0,0 +1,368 @@
+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_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"
+}
+
+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"
+}
+
+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"
+}