Showing preview only (4,142K chars total). Download the full file or copy to clipboard to get everything.
Repository: mishoo/UglifyJS
Branch: master
Commit: 111746bbae5f
Files: 280
Total size: 3.9 MB
Directory structure:
gitextract_fobklhdg/
├── .gitattributes
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ └── bug_report.md
│ └── workflows/
│ ├── build.yml
│ ├── ci.yml
│ ├── moz.yml
│ └── ufuzz.yml
├── .gitignore
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── bin/
│ └── uglifyjs
├── lib/
│ ├── ast.js
│ ├── compress.js
│ ├── minify.js
│ ├── mozilla-ast.js
│ ├── output.js
│ ├── parse.js
│ ├── propmangle.js
│ ├── scope.js
│ ├── sourcemap.js
│ ├── transform.js
│ └── utils.js
├── package.json
├── test/
│ ├── benchmark.js
│ ├── compress/
│ │ ├── annotations.js
│ │ ├── arguments.js
│ │ ├── arrays.js
│ │ ├── arrows.js
│ │ ├── asm.js
│ │ ├── assignments.js
│ │ ├── awaits.js
│ │ ├── bigint.js
│ │ ├── blocks.js
│ │ ├── booleans.js
│ │ ├── classes.js
│ │ ├── collapse_vars.js
│ │ ├── comparisons.js
│ │ ├── concat-strings.js
│ │ ├── conditionals.js
│ │ ├── const.js
│ │ ├── dead-code.js
│ │ ├── debugger.js
│ │ ├── default-values.js
│ │ ├── destructured.js
│ │ ├── directives.js
│ │ ├── drop-console.js
│ │ ├── drop-unused.js
│ │ ├── evaluate.js
│ │ ├── exponentiation.js
│ │ ├── exports.js
│ │ ├── functions.js
│ │ ├── global_defs.js
│ │ ├── hoist_props.js
│ │ ├── hoist_vars.js
│ │ ├── html_comments.js
│ │ ├── ie.js
│ │ ├── if_return.js
│ │ ├── imports.js
│ │ ├── indentation.js
│ │ ├── issue-1034.js
│ │ ├── issue-1041.js
│ │ ├── issue-1052.js
│ │ ├── issue-1105.js
│ │ ├── issue-12.js
│ │ ├── issue-1202.js
│ │ ├── issue-126.js
│ │ ├── issue-1261.js
│ │ ├── issue-1275.js
│ │ ├── issue-1321.js
│ │ ├── issue-143.js
│ │ ├── issue-1431.js
│ │ ├── issue-1443.js
│ │ ├── issue-1446.js
│ │ ├── issue-1447.js
│ │ ├── issue-1569.js
│ │ ├── issue-1588.js
│ │ ├── issue-1609.js
│ │ ├── issue-1639.js
│ │ ├── issue-1656.js
│ │ ├── issue-1673.js
│ │ ├── issue-1704.js
│ │ ├── issue-1733.js
│ │ ├── issue-1750.js
│ │ ├── issue-1770.js
│ │ ├── issue-1787.js
│ │ ├── issue-1833.js
│ │ ├── issue-1943.js
│ │ ├── issue-208.js
│ │ ├── issue-22.js
│ │ ├── issue-2652.js
│ │ ├── issue-267.js
│ │ ├── issue-269.js
│ │ ├── issue-2719.js
│ │ ├── issue-281.js
│ │ ├── issue-2871.js
│ │ ├── issue-2989.js
│ │ ├── issue-368.js
│ │ ├── issue-3768.js
│ │ ├── issue-44.js
│ │ ├── issue-5614.js
│ │ ├── issue-59.js
│ │ ├── issue-597.js
│ │ ├── issue-611.js
│ │ ├── issue-637.js
│ │ ├── issue-640.js
│ │ ├── issue-747.js
│ │ ├── issue-751.js
│ │ ├── issue-782.js
│ │ ├── issue-892.js
│ │ ├── issue-913.js
│ │ ├── issue-973.js
│ │ ├── issue-976.js
│ │ ├── issue-979.js
│ │ ├── join_vars.js
│ │ ├── keep_fargs.js
│ │ ├── labels.js
│ │ ├── let.js
│ │ ├── loops.js
│ │ ├── max_line_len.js
│ │ ├── merge_vars.js
│ │ ├── negate-iife.js
│ │ ├── new.js
│ │ ├── node_version.js
│ │ ├── nullish.js
│ │ ├── numbers.js
│ │ ├── objects.js
│ │ ├── optional-chains.js
│ │ ├── preserve_line.js
│ │ ├── properties.js
│ │ ├── pure_funcs.js
│ │ ├── pure_getters.js
│ │ ├── reduce_vars.js
│ │ ├── regexp.js
│ │ ├── rename.js
│ │ ├── rests.js
│ │ ├── return_undefined.js
│ │ ├── sandbox.js
│ │ ├── sequences.js
│ │ ├── side_effects.js
│ │ ├── spreads.js
│ │ ├── string-literal.js
│ │ ├── switches.js
│ │ ├── templates.js
│ │ ├── transform.js
│ │ ├── typeof.js
│ │ ├── unicode.js
│ │ ├── varify.js
│ │ ├── webkit.js
│ │ ├── wrap_iife.js
│ │ └── yields.js
│ ├── compress.js
│ ├── exports.js
│ ├── fetch.js
│ ├── input/
│ │ ├── comments/
│ │ │ └── filter.js
│ │ ├── enclose/
│ │ │ └── input.js
│ │ ├── global_defs/
│ │ │ ├── nested.js
│ │ │ └── simple.js
│ │ ├── invalid/
│ │ │ ├── assign_1.js
│ │ │ ├── assign_2.js
│ │ │ ├── assign_3.js
│ │ │ ├── assign_4.js
│ │ │ ├── assign_5.js
│ │ │ ├── delete.js
│ │ │ ├── destructured_var.js
│ │ │ ├── dot_1.js
│ │ │ ├── dot_2.js
│ │ │ ├── dot_3.js
│ │ │ ├── else.js
│ │ │ ├── eof.js
│ │ │ ├── for-await.js
│ │ │ ├── for-in_1.js
│ │ │ ├── for-in_2.js
│ │ │ ├── for-of_1.js
│ │ │ ├── for-of_2.js
│ │ │ ├── function_1.js
│ │ │ ├── function_2.js
│ │ │ ├── function_3.js
│ │ │ ├── loop-no-body.js
│ │ │ ├── object.js
│ │ │ ├── optional-template.js
│ │ │ ├── return.js
│ │ │ ├── simple.js
│ │ │ ├── switch.js
│ │ │ ├── tab.js
│ │ │ ├── try.js
│ │ │ └── var.js
│ │ ├── issue-1236/
│ │ │ └── simple.js
│ │ ├── issue-1242/
│ │ │ ├── bar.es5
│ │ │ ├── baz.es5
│ │ │ ├── foo.es5
│ │ │ └── qux.js
│ │ ├── issue-1323/
│ │ │ └── sample.js
│ │ ├── issue-1431/
│ │ │ └── sample.js
│ │ ├── issue-1482/
│ │ │ ├── beautify.js
│ │ │ ├── braces.js
│ │ │ ├── default.js
│ │ │ └── input.js
│ │ ├── issue-1632/
│ │ │ └── ^{foo}[bar](baz)+$.js
│ │ ├── issue-2082/
│ │ │ └── sample.js
│ │ ├── issue-2310/
│ │ │ └── input.js
│ │ ├── issue-3040/
│ │ │ ├── expect.js
│ │ │ └── input.js
│ │ ├── issue-3294/
│ │ │ ├── input.js
│ │ │ └── output.js
│ │ ├── issue-3315/
│ │ │ ├── config.json
│ │ │ └── input.js
│ │ ├── issue-3441/
│ │ │ └── input.js
│ │ ├── issue-505/
│ │ │ ├── input.js
│ │ │ └── output.js
│ │ ├── issue-520/
│ │ │ ├── input.js
│ │ │ └── output.js
│ │ ├── module/
│ │ │ ├── expect.js
│ │ │ └── input.js
│ │ ├── reduce/
│ │ │ ├── destructured_assign.js
│ │ │ ├── destructured_assign.reduced.js
│ │ │ ├── destructured_catch.js
│ │ │ ├── destructured_catch.reduced.js
│ │ │ ├── diff_error.js
│ │ │ ├── diff_error.reduced.js
│ │ │ ├── export_default.js
│ │ │ ├── label.js
│ │ │ ├── label.reduced.js
│ │ │ ├── setter.js
│ │ │ ├── setter.reduced.js
│ │ │ ├── unsafe_math.js
│ │ │ └── unsafe_math.reduced.js
│ │ └── rename/
│ │ └── input.js
│ ├── jetstream.js
│ ├── mocha/
│ │ ├── arguments.js
│ │ ├── awaits.js
│ │ ├── bug-report.js
│ │ ├── cli.js
│ │ ├── comments.js
│ │ ├── directives.js
│ │ ├── exports.js
│ │ ├── getter-setter.js
│ │ ├── glob.js
│ │ ├── imports.js
│ │ ├── let.js
│ │ ├── line-endings.js
│ │ ├── minify-file-map.js
│ │ ├── minify.js
│ │ ├── number-literal.js
│ │ ├── operator.js
│ │ ├── parentheses.js
│ │ ├── reduce.js
│ │ ├── sourcemaps.js
│ │ ├── spidermonkey.js
│ │ ├── string-literal.js
│ │ ├── templates.js
│ │ ├── tokens.js
│ │ ├── with.js
│ │ └── yields.js
│ ├── mocha.js
│ ├── mozilla-ast.js
│ ├── node.js
│ ├── reduce.js
│ ├── release/
│ │ ├── acorn.sh
│ │ ├── benchmark.js
│ │ ├── bootstrap.sh
│ │ ├── buble.sh
│ │ ├── butternut.sh
│ │ ├── install.sh
│ │ ├── jetstream.js
│ │ ├── mathjs.sh
│ │ ├── rollup-es.sh
│ │ ├── rollup-ts.sh
│ │ ├── run.js
│ │ ├── sucrase.sh
│ │ └── web-tooling-benchmark.sh
│ ├── sandbox.js
│ └── ufuzz/
│ ├── actions.js
│ ├── index.js
│ ├── job.js
│ └── options.json
└── tools/
├── domprops.html
├── domprops.json
├── exports.js
├── node.js
└── tty.js
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
*.js text eol=lf
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
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.
-->
================================================
FILE: .github/workflows/build.yml
================================================
name: Build testing
on:
pull_request:
push:
branches: [ master ]
jobs:
ufuzz:
strategy:
fail-fast: false
matrix:
options:
- '--ie -c'
- '-mb braces'
- '--toplevel -mc'
- '-p acorn -mco spidermonkey'
- '-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@v4
- name: Perform uglify, build & test
shell: bash
run: |
. ./test/release/install.sh
./test/release/$SCRIPT $OPTIONS
================================================
FILE: .github/workflows/ci.yml
================================================
name: CI
on:
pull_request:
push:
branches: [ master ]
jobs:
test:
strategy:
matrix:
node: [ '0.10', '0.12', '4', '6', '8', '10', '12', '14', '16', '18', '20' ]
os: [ ubuntu-latest, windows-latest ]
script: [ compress, mocha, release/benchmark, release/jetstream ]
name: ${{ matrix.node }} ${{ matrix.os }} ${{ matrix.script }}
runs-on: ${{ matrix.os }}
env:
NODE: ${{ matrix.node }}
TYPE: ${{ matrix.script }}
UGLIFY_GITHUB_LAG: 10000
steps:
- uses: actions/checkout@v4
- uses: actions/cache@v4
with:
path: tmp
key: tmp ${{ matrix.script }}
- name: Patch OpenSSL on Ubuntu
if: runner.os == 'Linux'
shell: bash
run: |
sudo sed -i 's/providers = provider_sect/# providers = provider_sect/' /etc/ssl/openssl.cnf
- name: Perform tests
shell: bash
run: |
. ./test/release/install.sh
node test/$TYPE
================================================
FILE: .github/workflows/moz.yml
================================================
name: ESTree
on:
pull_request:
push:
branches: [ master ]
jobs:
test:
name: fuzzing
runs-on: ubuntu-latest
env:
NODE: 22
steps:
- uses: actions/checkout@v4
- name: Perform tests
shell: bash
run: |
. ./test/release/install.sh
node test/mozilla-ast.js 5000
================================================
FILE: .github/workflows/ufuzz.yml
================================================
name: Fuzzing
on:
pull_request:
schedule:
- cron: '*/15 * * * *'
workflow_dispatch:
workflow_run:
branches: [ master ]
types: [ completed ]
workflows: [ 'Build testing', CI ]
env:
BASE_URL: https://api.github.com/repos/${{ github.repository }}
TOKEN: ${{ github.token }}
jobs:
ufuzz:
strategy:
fail-fast: false
matrix:
include:
- node: '16'
os: macos-latest
- node: '12'
os: ubuntu-latest
- node: '8'
os: ubuntu-latest
- node: '12'
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@v4
- name: Perform fuzzing
shell: bash
run: |
. ./test/release/install.sh
if [[ $GITHUB_EVENT_NAME == "pull_request" ]]; then
node test/ufuzz/job 5000
else
node test/ufuzz/job $BASE_URL $TOKEN $GITHUB_RUN_NUMBER
fi
================================================
FILE: .gitignore
================================================
/node_modules/
/npm-debug.log
tmp/
================================================
FILE: CONTRIBUTING.md
================================================
Contributing
============
## Documentation
Every new feature and API change should be accompanied by a README addition.
## Testing
All features and bugs should have tests that verify the fix. You can run all
tests using `npm test`.
The most common type of test are tests that verify input and output of the
Uglify transforms. These tests exist in `test/compress`. New tests can be added
either to an existing file or in a new file `issue-xxx.js`.
Tests that cannot be expressed as a simple AST can be found in `test/mocha`.
## Code style
- File encoding must be `UTF-8`.
- `LF` is always used as a line ending.
- Statements end with semicolons.
- Indentation uses 4 spaces, switch `case` 2 spaces.
- Identifiers use `snake_case`.
- Strings use double quotes (`"`).
- Use a trailing comma for multiline array and object literals to minimize diffs.
- The Uglify code only uses ES5, even in the `harmony` branch.
- Line length should be at most 80 cols, except when it is easier to read a
longer line.
- If both sides of a comparison are of the same type, `==` and `!=` are used.
- Multiline conditions place `&&` and `||` first on the line.
**Example feature**
```js
OPT(AST_Debugger, function(self, compressor) {
if (compressor.option("drop_debugger"))
return make_node(AST_EmptyStatement, self);
return self;
});
```
**Example test case**
```js
drop_debugger: {
options = {
drop_debugger: true,
}
input: {
debugger;
if (foo) debugger;
}
expect: {
if (foo);
}
}
```
================================================
FILE: LICENSE
================================================
UglifyJS is released under the BSD license:
Copyright 2012-2024 (c) Mihai Bazon <mihai.bazon@gmail.com>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials
provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: README.md
================================================
UglifyJS 3
==========
UglifyJS is a JavaScript parser, minifier, compressor and beautifier toolkit.
#### Note:
- `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
-------
First make sure you have installed the latest version of [node.js](http://nodejs.org/)
(You may need to restart your computer after this step).
From NPM for use as a command line app:
npm install uglify-js -g
From NPM for programmatic use:
npm install uglify-js
# Command line usage
uglifyjs [input files] [options]
UglifyJS can take multiple input files. It's recommended that you pass the
input files first, then pass the options. UglifyJS will parse input files
in sequence and apply any compression options. The files are parsed in the
same global scope, that is, a reference from a file to some
variable/function declared in another file will be matched properly.
If no input file is specified, UglifyJS will read from STDIN.
If you wish to pass your options before the input files, separate the two with
a double dash to prevent input files being used as option arguments:
uglifyjs --compress --mangle -- input.js
### Command line options
```
-h, --help Print usage information.
`--help options` for details on available options.
-V, --version Print version number.
-p, --parse <options> Specify parser options:
`acorn` Use Acorn for parsing.
`bare_returns` Allow return outside of functions.
Useful when minifying CommonJS
modules and Userscripts that may
be anonymous function wrapped (IIFE)
by the .user.js engine `caller`.
`spidermonkey` Assume input files are SpiderMonkey
AST format (as JSON).
-c, --compress [options] Enable compressor/specify compressor options:
`pure_funcs` List of functions that can be safely
removed when their return values are
not used.
-m, --mangle [options] Mangle names/specify mangler options:
`reserved` List of names that should not be mangled.
--mangle-props [options] Mangle properties/specify mangler options:
`builtins` Mangle property names that overlaps
with standard JavaScript globals.
`debug` Add debug prefix and suffix.
`domprops` Mangle property names that overlaps
with DOM properties.
`globals` Mangle variable access via global object.
`keep_quoted` Only mangle unquoted properties.
`regex` Only mangle matched property names.
`reserved` List of names that should not be mangled.
-b, --beautify [options] Beautify output/specify output options:
`beautify` Enabled with `--beautify` by default.
`preamble` Preamble to prepend to the output. You
can use this to insert a comment, for
example for licensing information.
This will not be parsed, but the source
map will adjust for its presence.
`quote_style` Quote style:
0 - auto
1 - single
2 - double
3 - original
`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
"@preserve". You can optionally pass one of the
following arguments to this flag:
- "all" to keep all comments
- a valid JS RegExp like `/foo/` or `/^!/` to
keep only matching comments.
Note that currently not *all* comments can be
kept when compression is on, because of dead
code removal or cascading statements into
sequences.
--config-file <file> Read `minify()` options from JSON file.
-d, --define <expr>[=value] Global definitions.
-e, --enclose [arg[:value]] Embed everything in a big function, with configurable
argument(s) & value(s).
--expression Parse a single expression, rather than a program
(for parsing JSON).
--ie Support non-standard Internet Explorer.
Equivalent to setting `ie: true` in `minify()`
for `compress`, `mangle` and `output` options.
By default UglifyJS will not try to be IE-proof.
--keep-fargs Do not mangle/drop function arguments.
--keep-fnames Do not mangle/drop function names. Useful for
code relying on Function.prototype.name.
--module Process input as ES module (implies --toplevel)
--no-module Avoid optimizations which may alter runtime behavior
under prior versions of JavaScript.
--name-cache <file> File to hold mangled name mappings.
--self Build UglifyJS as a library (implies --wrap UglifyJS)
--source-map [options] Enable source map/specify source map options:
`base` Path to compute relative paths from input files.
`content` Input source map, useful if you're compressing
JS that was generated from some other original
code. Specify "inline" if the source map is
included within the sources.
`filename` Filename and/or location of the output source
(sets `file` attribute in source map).
`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 `compress`, `mangle` and `output` options.
By default UglifyJS will not try to be Safari-proof.
--wrap <name> Embed everything in a big function, making the
“exports” and “global” variables available. You
need to pass an argument to this option to
specify the name that your module will take
when included in, say, a browser.
```
Specify `--output` (`-o`) to declare the output file. Otherwise the output
goes to STDOUT.
## CLI source map options
UglifyJS can generate a source map file, which is highly useful for
debugging your compressed JavaScript. To get a source map, pass
`--source-map --output output.js` (source map will be written out to
`output.js.map`).
Additional options:
- `--source-map "filename='<NAME>'"` to specify the name of the source map. The value of
`filename` is only used to set `file` attribute (see [the spec][sm-spec])
in source map file.
- `--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.
For example:
uglifyjs js/file1.js js/file2.js \
-o foo.min.js -c -m \
--source-map "root='http://foo.com/src',url='foo.min.js.map'"
The above will compress and mangle `file1.js` and `file2.js`, will drop the
output in `foo.min.js` and the source map in `foo.min.js.map`. The source
mapping will refer to `http://foo.com/src/js/file1.js` and
`http://foo.com/src/js/file2.js` (in fact it will list `http://foo.com/src`
as the source map root, and the original files as `js/file1.js` and
`js/file2.js`).
### Composed source map
When you're compressing JS code that was output by a compiler such as
CoffeeScript, mapping to the JS code won't be too helpful. Instead, you'd
like to map back to the original code (i.e. CoffeeScript). UglifyJS has an
option to take an input source map. Assuming you have a mapping from
CoffeeScript → compiled JS, UglifyJS can generate a map from CoffeeScript →
compressed JS by mapping every token in the compiled JS to its original
location.
To use this feature pass `--source-map "content='/path/to/input/source.map'"`
or `--source-map "content=inline"` if the source map is included inline with
the sources.
## CLI compress options
You need to pass `--compress` (`-c`) to enable the compressor. Optionally
you can pass a comma-separated list of [compress options](#compress-options).
Options are in the form `foo=bar`, or just `foo` (the latter implies
a boolean option that you want to set `true`; it's effectively a
shortcut for `foo=true`).
Example:
uglifyjs file.js -c toplevel,sequences=false
## CLI mangle options
To enable the mangler you need to pass `--mangle` (`-m`). The following
(comma-separated) options are supported:
- `eval` (default: `false`) — mangle names visible in scopes where `eval` or
`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:
uglifyjs ... -m reserved=['$','require','exports']
to prevent the `require`, `exports` and `$` names from being changed.
### CLI mangling property names (`--mangle-props`)
**Note:** THIS WILL PROBABLY BREAK YOUR CODE. Mangling property names
is a separate step, different from variable name mangling. Pass
`--mangle-props` to enable it. It will mangle all properties in the
input code with the exception of built in DOM properties and properties
in core JavaScript classes. For example:
```javascript
// example.js
var x = {
baz_: 0,
foo_: 1,
calc: function() {
return this.foo_ + this.baz_;
}
};
x.bar_ = 2;
x["baz_"] = 3;
console.log(x.calc());
```
Mangle all properties (except for JavaScript `builtins`):
```bash
$ uglifyjs example.js -c -m --mangle-props
```
```javascript
var x={o:0,_:1,l:function(){return this._+this.o}};x.t=2,x.o=3,console.log(x.l());
```
Mangle all properties except for `reserved` properties:
```bash
$ uglifyjs example.js -c -m --mangle-props reserved=[foo_,bar_]
```
```javascript
var x={o:0,foo_:1,_:function(){return this.foo_+this.o}};x.bar_=2,x.o=3,console.log(x._());
```
Mangle all properties matching a `regex`:
```bash
$ uglifyjs example.js -c -m --mangle-props regex=/_$/
```
```javascript
var x={o:0,_:1,calc:function(){return this._+this.o}};x.l=2,x.o=3,console.log(x.calc());
```
Combining mangle properties options:
```bash
$ uglifyjs example.js -c -m --mangle-props regex=/_$/,reserved=[bar_]
```
```javascript
var x={o:0,_:1,calc:function(){return this._+this.o}};x.bar_=2,x.o=3,console.log(x.calc());
```
In order for this to be of any use, we avoid mangling standard JS names by
default (`--mangle-props builtins` to override).
Specify `--mangle-props globals` to mangle property names of global
object (e.g. `self.foo`) as global variables.
A default exclusion file is provided in `tools/domprops.json` which should
cover most standard JS and DOM properties defined in various browsers. Pass
`--mangle-props domprops` to disable this feature.
A regular expression can be used to define which property names should be
mangled. For example, `--mangle-props regex=/^_/` will only mangle property
names that start with an underscore.
When you compress multiple files using this option, in order for them to
work together in the end we need to ensure somehow that one property gets
mangled to the same name in all of them. For this, pass `--name-cache filename.json`
and UglifyJS will maintain these mappings in a file which can then be reused.
It should be initially empty. Example:
```bash
$ rm -f /tmp/cache.json # start fresh
$ uglifyjs file1.js file2.js --mangle-props --name-cache /tmp/cache.json -o part1.js
$ uglifyjs file3.js file4.js --mangle-props --name-cache /tmp/cache.json -o part2.js
```
Now, `part1.js` and `part2.js` will be consistent with each other in terms
of mangled property names.
Using the name cache is not necessary if you compress all your files in a
single call to UglifyJS.
### Mangling unquoted names (`--mangle-props keep_quoted`)
Using quoted property name (`o["foo"]`) reserves the property name (`foo`)
so that it is not mangled throughout the entire script even when used in an
unquoted style (`o.foo`). Example:
```javascript
// stuff.js
var o = {
"foo": 1,
bar: 3,
};
o.foo += o.bar;
console.log(o.foo);
```
```bash
$ uglifyjs stuff.js --mangle-props keep_quoted -c -m
```
```javascript
var o={foo:1,o:3};o.foo+=o.o,console.log(o.foo);
```
If the minified output will be processed again by UglifyJS, consider specifying
`keep_quoted_props` so the same property names are preserved:
```bash
$ uglifyjs stuff.js --mangle-props keep_quoted -c -m -O keep_quoted_props
```
```javascript
var o={"foo":1,o:3};o.foo+=o.o,console.log(o.foo);
```
### Debugging property name mangling
You can also pass `--mangle-props debug` in order to mangle property names
without completely obscuring them. For example the property `o.foo`
would mangle to `o._$foo$_` with this option. This allows property mangling
of a large codebase while still being able to debug the code and identify
where mangling is breaking things.
```bash
$ uglifyjs stuff.js --mangle-props debug -c -m
```
```javascript
var o={_$foo$_:1,_$bar$_:3};o._$foo$_+=o._$bar$_,console.log(o._$foo$_);
```
You can also pass a custom suffix using `--mangle-props debug=XYZ`. This would then
mangle `o.foo` to `o._$foo$XYZ_`. You can change this each time you compile a
script to identify how a property got mangled. One technique is to pass a
random number on every compile to simulate mangling changing with different
inputs (e.g. as you update the input script with new properties), and to help
identify mistakes like writing mangled keys to storage.
# API Reference
Assuming installation via NPM, you can load UglifyJS in your application
like this:
```javascript
var UglifyJS = require("uglify-js");
```
There is a single high level function, **`minify(code, options)`**,
which will perform all minification [phases](#minify-options) in a configurable
manner. By default `minify()` will enable the options [`compress`](#compress-options)
and [`mangle`](#mangle-options). Example:
```javascript
var code = "function add(first, second) { return first + second; }";
var result = UglifyJS.minify(code);
console.log(result.error); // runtime error, or `undefined` if no error
console.log(result.code); // minified output: function add(n,d){return n+d}
```
You can `minify` more than one JavaScript file at a time by using an object
for the first argument where the keys are file names and the values are source
code:
```javascript
var code = {
"file1.js": "function add(first, second) { return first + second; }",
"file2.js": "console.log(add(1 + 2, 3 + 4));"
};
var result = UglifyJS.minify(code);
console.log(result.code);
// function add(d,n){return d+n}console.log(add(3,7));
```
The `toplevel` option:
```javascript
var code = {
"file1.js": "function add(first, second) { return first + second; }",
"file2.js": "console.log(add(1 + 2, 3 + 4));"
};
var options = { toplevel: true };
var result = UglifyJS.minify(code, options);
console.log(result.code);
// console.log(3+7);
```
The `nameCache` option:
```javascript
var options = {
mangle: {
toplevel: true,
},
nameCache: {}
};
var result1 = UglifyJS.minify({
"file1.js": "function add(first, second) { return first + second; }"
}, options);
var result2 = UglifyJS.minify({
"file2.js": "console.log(add(1 + 2, 3 + 4));"
}, options);
console.log(result1.code);
// function n(n,r){return n+r}
console.log(result2.code);
// console.log(n(3,7));
```
You may persist the name cache to the file system in the following way:
```javascript
var cacheFileName = "/tmp/cache.json";
var options = {
mangle: {
properties: true,
},
nameCache: JSON.parse(fs.readFileSync(cacheFileName, "utf8"))
};
fs.writeFileSync("part1.js", UglifyJS.minify({
"file1.js": fs.readFileSync("file1.js", "utf8"),
"file2.js": fs.readFileSync("file2.js", "utf8")
}, options).code, "utf8");
fs.writeFileSync("part2.js", UglifyJS.minify({
"file3.js": fs.readFileSync("file3.js", "utf8"),
"file4.js": fs.readFileSync("file4.js", "utf8")
}, options).code, "utf8");
fs.writeFileSync(cacheFileName, JSON.stringify(options.nameCache), "utf8");
```
An example of a combination of `minify()` options:
```javascript
var code = {
"file1.js": "function add(first, second) { return first + second; }",
"file2.js": "console.log(add(1 + 2, 3 + 4));"
};
var options = {
toplevel: true,
compress: {
global_defs: {
"@console.log": "alert"
},
passes: 2
},
output: {
beautify: false,
preamble: "/* uglified */"
}
};
var result = UglifyJS.minify(code, options);
console.log(result.code);
// /* uglified */
// alert(10);"
```
To produce warnings:
```javascript
var code = "function f(){ var u; return 2 + 3; }";
var options = { warnings: true };
var result = UglifyJS.minify(code, options);
console.log(result.error); // runtime error, `undefined` in this case
console.log(result.warnings); // [ 'Dropping unused variable u [0:1,18]' ]
console.log(result.code); // function f(){return 5}
```
An error example:
```javascript
var result = UglifyJS.minify({"foo.js" : "if (0) else console.log(1);"});
console.log(JSON.stringify(result.error));
// {"message":"Unexpected token: keyword (else)","filename":"foo.js","line":1,"col":7,"pos":7}
```
Note: unlike `uglify-js@2.x`, the `3.x` API does not throw errors. To
achieve a similar effect one could do the following:
```javascript
var result = UglifyJS.minify(code, options);
if (result.error) throw result.error;
```
## Minify options
- `annotations` — pass `false` to ignore all comment annotations and elide them
from output. Useful when, for instance, external tools incorrectly applied
`/*@__PURE__*/` or `/*#__PURE__*/`. Pass `true` to both compress and retain
comment annotations in output to allow for further processing downstream.
- `compress` (default: `{}`) — pass `false` to skip compressing entirely.
Pass an object to specify custom [compress options](#compress-options).
- `expression` (default: `false`) — parse as a single expression, e.g. JSON.
- `ie` (default: `false`) — enable workarounds for Internet Explorer bugs.
- `keep_fargs` (default: `false`) — pass `true` to prevent discarding or mangling
of function arguments.
- `keep_fnames` (default: `false`) — pass `true` to prevent discarding or mangling
of function names. Useful for code relying on `Function.prototype.name`.
- `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.
Pass an object to specify custom [mangle property options](#mangle-properties-options).
- `module` (default: `true`) — process input as ES module, i.e. implicit
`"use strict";` and support for top-level `await`. When explicitly specified,
also enables `toplevel`.
- `nameCache` (default: `null`) — pass an empty object `{}` or a previously
used `nameCache` object if you wish to cache mangled variable and
property names across multiple invocations of `minify()`. Note: this is
a read/write property. `minify()` will read the name cache state of this
object and update it during minification so that it may be
reused or externally persisted by the user.
- `output` (default: `null`) — pass an object if you wish to specify
additional [output options](#output-options). The defaults are optimized
for best compression.
- `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
```javascript
{
parse: {
// parse options
},
compress: {
// compress options
},
mangle: {
// mangle options
properties: {
// mangle property options
}
},
output: {
// output options
},
sourceMap: {
// source map options
},
nameCache: null, // or specify a name cache object
toplevel: false,
warnings: false,
}
```
### Source map options
To generate a source map:
```javascript
var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, {
sourceMap: {
filename: "out.js",
url: "out.js.map"
}
});
console.log(result.code); // minified output
console.log(result.map); // source map
```
Note that the source map is not saved in a file, it's just returned in
`result.map`. The value passed for `sourceMap.url` is only used to set
`//# sourceMappingURL=out.js.map` in `result.code`. The value of
`filename` is only used to set `file` attribute (see [the spec][sm-spec])
in source map file.
You can set option `sourceMap.url` to be `"inline"` and source map will
be appended to code.
You can also specify sourceRoot property to be included in source map:
```javascript
var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, {
sourceMap: {
root: "http://example.com/src",
url: "out.js.map"
}
});
```
If you're compressing compiled JavaScript and have a source map for it, you
can use `sourceMap.content`:
```javascript
var result = UglifyJS.minify({"compiled.js": "compiled code"}, {
sourceMap: {
content: "content from compiled.js.map",
url: "minified.js.map"
}
});
// same as before, it returns `code` and `map`
```
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
- `html5_comments` (default: `true`) — process HTML comment as workaround for
browsers which do not recognize `<script>` tags
- `module` (default: `false`) — set to `true` if you wish to process input as
ES module, i.e. implicit `"use strict";` and support for top-level `await`.
- `shebang` (default: `true`) — support `#!command` as the first line
## Compress options
- `annotations` (default: `true`) — Pass `false` to disable potentially dropping
functions marked as "pure". A function call is marked as "pure" if a comment
annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
example: `/*@__PURE__*/foo();`
- `arguments` (default: `true`) — replace `arguments[index]` with function
parameter name whenever possible.
- `arrows` (default: `true`) — apply optimizations to arrow functions
- `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,
side effects permitting.
- `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
expressions
- `dead_code` (default: `true`) — remove unreachable code
- `default_values` (default: `true`) — drop overshadowed default values
- `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
- `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
from terminal statements without `return`, e.g. in bookmarklets.
- `functions` (default: `true`) — convert declarations from `var` to `function`
whenever possible.
- `global_defs` (default: `{}`) — see [conditional compilation](#conditional-compilation)
- `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 `toplevel` and `mangle` enabled, alongside with `compress` option
`passes` set to `2` or higher.
- `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
- `imports` (default: `true`) — drop unreferenced import symbols when used with `unused`
- `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
- `4` — inline functions with arguments, variables and statements
- `true` — same as `4`
- `join_vars` (default: `true`) — join consecutive `var` statements
- `keep_fargs` (default: `false`) — discard unused function arguments except
when unsafe to do so, e.g. code which relies on `Function.prototype.length`.
Pass `true` to always retain function arguments.
- `keep_infinity` (default: `false`) — Pass `true` to prevent `Infinity` from
being compressed into `1/0`, which may cause performance issues on Chrome.
- `loops` (default: `true`) — optimizations for `do`, `while` and `for` loops
when we can statically determine the condition.
- `merge_vars` (default: `true`) — combine and reuse variables.
- `module` (default: `false`) — set to `true` if you wish to process input as
ES module, i.e. implicit `"use strict";`.
- `negate_iife` (default: `true`) — negate "Immediately-Called Function Expressions"
where the return value is discarded, to avoid the parentheses that the
code generator would insert.
- `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
example `foo["bar"] → foo.bar`
- `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
variable `q` is not used elsewhere, UglifyJS will drop it, but will
still keep the `Math.floor(a/b)`, not knowing what it does. You can
pass `pure_funcs: [ 'Math.floor' ]` to let it know that this
function won't produce any side effect, in which case the whole
statement would get discarded. The current implementation adds some
overhead (compression will be slower). Make sure symbols under `pure_funcs`
are also under `mangle.reserved` to avoid mangling.
- `pure_getters` (default: `"strict"`) — Pass `true` for UglifyJS to assume that
object property access (e.g. `foo.bar` or `a[42]`) does not throw exception or
alter program states via getter function. Pass `"strict"` to allow dropping or
reordering `foo.bar` only if `foo` is not `null` or `undefined` and is safe to
access as a variable. Pass `false` to retain all property accesses.
- `reduce_funcs` (default: `true`) — Allows single-use functions to be
inlined as function expressions when permissible allowing further
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
used as constant values.
- `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`
to disable. The smallest `sequences` length is `2`. A `sequences` value of `1`
is grandfathered to be equivalent to `true` and as such means `200`. On rare
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`) — drop extraneous code which does not affect
outcome of runtime execution.
- `spreads` (default: `true`) — flatten spread expressions.
- `strings` (default: `true`) — compact string concatenations.
- `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`)
- `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`) — compress `typeof` expressions, e.g.
`typeof foo == "undefined" → void 0 === foo`
- `unsafe` (default: `false`) — apply "unsafe" transformations (discussion below)
- `unsafe_comps` (default: `false`) — assume operands cannot be (coerced to) `NaN`
in numeric comparisons, e.g. `a <= b`. In addition, expressions involving `in`
or `instanceof` would never throw.
- `unsafe_Function` (default: `false`) — compress and mangle `Function(args, code)`
when both `args` and `code` are string literals.
- `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
`Array.prototype.slice.call(a)` into `[].slice.call(a)`
- `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
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
direct variable assignments do not count as references unless set to `"keep_assign"`)
- `varify` (default: `true`) — convert block-scoped declarations 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
where `eval` or `with` are used.
- `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
top level scope.
Examples:
```javascript
// test.js
var globalVar;
function funcName(firstLongName, anotherLongName) {
var myVariable = firstLongName + anotherLongName;
}
```
```javascript
var code = fs.readFileSync("test.js", "utf8");
UglifyJS.minify(code).code;
// 'function funcName(a,n){}var globalVar;'
UglifyJS.minify(code, { mangle: { reserved: ['firstLongName'] } }).code;
// 'function funcName(firstLongName,a){}var globalVar;'
UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
// 'function n(n,a){}var a;'
```
### Mangle properties options
- `builtins` (default: `false`) — Use `true` to allow the mangling of built-in
properties of JavaScript API. Not recommended to override this setting.
- `debug` (default: `false`) — Mangle names with the original name still present.
Pass an empty string `""` to enable, or a non-empty string to set the debug suffix.
- `domprops` (default: `false`) — Use `true` to allow the mangling of properties
commonly found in Document Object Model. Not recommended to override this setting.
- `globals` (default: `false`) — Use `true` to mangle properties of global object
alongside undeclared variables.
- `keep_fargs` (default: `false`) — Use `true` to prevent mangling of function
arguments.
- `keep_quoted` (default: `false`) — Only mangle unquoted property names.
- `regex` (default: `null`) — Pass a RegExp literal to only mangle property
names matching the regular expression.
- `reserved` (default: `[]`) — Do not mangle property names listed in the
`reserved` array.
## Output options
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:
- `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.
Passing `-b` will set this to true. Use `-O` if you want to generate minified
code and specify additional arguments.
- `braces` (default: `false`) — always insert braces in `if`, `for`,
`do`, `while` or `with` statements, even if their body is a single
statement.
- `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;
}
```
- `extendscript` (default: `false`) — enable workarounds for Adobe ExtendScript
bugs
- `galio` (default: `false`) — enable workarounds for ANT Galio bugs
- `indent_level` (default: `4`) — indent by specified number of spaces or the
exact whitespace sequence supplied, e.g. `"\t"`.
- `indent_start` (default: `0`) — prefix all lines by whitespace sequence
specified in the same format as `indent_level`.
- `inline_script` (default: `true`) — escape HTML comments and the slash in
occurrences of `</script>` in strings
- `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)
- `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
a best effort basis.
- `quote_keys` (default: `false`) — pass `true` to quote all keys in literal
objects
- `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
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
- `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)
- `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
function expressions. See
[#640](https://github.com/mishoo/UglifyJS/issues/640) for more details.
# Miscellaneous
### Keeping copyright notices or other comments
You can pass `--comments` to retain certain comments in the output. By
default it will keep JSDoc-style comments that contain "@preserve",
"@license" or "@cc_on" (conditional compilation for IE). You can pass
`--comments all` to keep all the comments, or a valid JavaScript regexp to
keep only comments that match this regexp. For example `--comments /^!/`
will keep comments like `/*! Copyright Notice */`.
Note, however, that there might be situations where comments are lost. For
example:
```javascript
function f() {
/** @preserve Foo Bar */
function g() {
// this function is never called
}
return something();
}
```
Even though it has "@preserve", the comment will be lost because the inner
function `g` (which is the AST node to which the comment is attached to) is
discarded by the compressor as not referenced.
The safest comments where to place copyright information (or other info that
needs to be kept in the output) are comments attached to toplevel nodes.
### The `unsafe` `compress` option
It enables some transformations that *might* break code logic in certain
contrived cases, but should be fine for most code. You might want to try it
on your own code, it should reduce the minified size. Here's what happens
when this flag is on:
- `new Array(1, 2, 3)` or `Array(1, 2, 3)` → `[ 1, 2, 3 ]`
- `new Object()` → `{}`
- `String(exp)` or `exp.toString()` → `"" + exp`
- `new Object/RegExp/Function/Error/Array (...)` → we discard the `new`
### Conditional compilation
You can use the `--define` (`-d`) switch in order to declare global
variables that UglifyJS will assume to be constants (unless defined in
scope). For example if you pass `--define DEBUG=false` then, coupled with
dead code removal UglifyJS will discard the following from the output:
```javascript
if (DEBUG) {
console.log("debug stuff");
}
```
You can specify nested constants in the form of `--define env.DEBUG=false`.
UglifyJS will warn about the condition being always false and about dropping
unreachable code; for now there is no option to turn off only this specific
warning, you can pass `warnings=false` to turn off *all* warnings.
Another way of doing that is to declare your globals as constants in a
separate file and include it into the build. For example you can have a
`build/defines.js` file with the following:
```javascript
var DEBUG = false;
var PRODUCTION = true;
// etc.
```
and build your code like this:
uglifyjs build/defines.js js/foo.js js/bar.js... -c
UglifyJS will notice the constants and, since they cannot be altered, it
will evaluate references to them to the value itself and drop unreachable
code as usual. The build will contain the `const` declarations if you use
them. If you are targeting < ES6 environments which does not support `const`,
using `var` with `reduce_vars` (enabled by default) should suffice.
### Conditional compilation API
You can also use conditional compilation via the programmatic API. With the difference that the
property name is `global_defs` and is a compressor property:
```javascript
var result = UglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
compress: {
dead_code: true,
global_defs: {
DEBUG: false
}
}
});
```
To replace an identifier with an arbitrary non-constant expression it is
necessary to prefix the `global_defs` key with `"@"` to instruct UglifyJS
to parse the value as an expression:
```javascript
UglifyJS.minify("alert('hello');", {
compress: {
global_defs: {
"@alert": "console.log"
}
}
}).code;
// returns: 'console.log("hello");'
```
Otherwise it would be replaced as string literal:
```javascript
UglifyJS.minify("alert('hello');", {
compress: {
global_defs: {
"alert": "console.log"
}
}
}).code;
// returns: '"console.log"("hello");'
```
### Using native Uglify AST with `minify()`
```javascript
// example: parse only, produce native Uglify AST
var result = UglifyJS.minify(code, {
parse: {},
compress: false,
mangle: false,
output: {
ast: true,
code: false // optional - faster if false
}
});
// result.ast contains native Uglify AST
```
```javascript
// example: accept native Uglify AST input and then compress and mangle
// to produce both code and native AST.
var result = UglifyJS.minify(ast, {
compress: {},
mangle: {},
output: {
ast: true,
code: true // optional - faster if false
}
});
// result.ast contains native Uglify AST
// result.code contains the minified code in string form.
```
### Working with Uglify AST
Transversal and transformation of the native AST can be performed through
[`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
UglifyJS has its own abstract syntax tree format; for
[practical reasons](http://lisperator.net/blog/uglifyjs-why-not-switching-to-spidermonkey-ast/)
we can't easily change to using the SpiderMonkey AST internally. However,
UglifyJS now has a converter which can import a SpiderMonkey AST.
For example [Acorn][acorn] is a super-fast parser that produces a
SpiderMonkey AST. It has a small CLI utility that parses one file and dumps
the AST in JSON on the standard output. To use UglifyJS to mangle and
compress that:
acorn file.js | uglifyjs -p spidermonkey -m -c
The `-p spidermonkey` option tells UglifyJS that all input files are not
JavaScript, but JS code described in SpiderMonkey AST in JSON. Therefore we
don't use our own parser in this case, but just transform that AST into our
internal AST.
### Use Acorn for parsing
More for fun, I added the `-p acorn` option which will use Acorn to do all
the parsing. If you pass this option, UglifyJS will `require("acorn")`.
Acorn is really fast (e.g. 250ms instead of 380ms on some 650K code), but
converting the SpiderMonkey tree that Acorn produces takes another 150ms so
in total it's a bit more than just using UglifyJS's own parser.
[acorn]: https://github.com/ternjs/acorn
[sm-spec]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k
### Uglify Fast Minify Mode
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 5 times.
| d3.js | minify size | gzip size | minify time (seconds) |
| --- | ---: | ---: | ---: |
| 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:
```javascript
UglifyJS.minify(code, { compress: false, mangle: true });
```
### 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
expected as code is optimized and mappings are often simply not possible as
some code no longer exists. For highest fidelity in source map debugging
disable the Uglify `compress` option and just use `mangle`.
### Compiler assumptions
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.
- `arguments.callee`, `arguments.caller` and `Function.prototype.caller` are not used.
- The code doesn't expect the contents of `Function.prototype.toString()` or
`Error.prototype.stack` to be anything in particular.
- Getting and setting properties on a plain object does not cause other side effects
(using `.watch()` or `Proxy`).
- Object properties can be added, removed and modified (not prevented with
`Object.defineProperty()`, `Object.defineProperties()`, `Object.freeze()`,
`Object.preventExtensions()` or `Object.seal()`).
- If array destructuring is present, index-like properties in `Array.prototype`
have not been overridden:
```javascript
Object.prototype[0] = 42;
var [ a ] = [];
var { 0: b } = {};
// 42 undefined
console.log([][0], a);
// 42 42
console.log({}[0], b);
```
- Earlier versions of JavaScript will throw `SyntaxError` with the following:
```javascript
({
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.
- Later versions of JavaScript will throw `SyntaxError` with the following:
```javascript
var await;
class A {
static p = await;
}
// SyntaxError: Unexpected reserved word
```
UglifyJS may modify the input which in turn may suppress those errors.
- Later versions of JavaScript will throw `SyntaxError` with the following:
```javascript
var async;
for (async of []);
// SyntaxError: The left-hand side of a for-of loop may not be 'async'.
```
UglifyJS may modify the input which in turn may suppress those errors.
- Some versions of Chrome and Node.js will give incorrect results with the
following:
```javascript
console.log({
...console,
get 42() {
return "FAIL";
},
[42]: "PASS",
}[42], {
...console,
get 42() {
return "FAIL";
},
42: "PASS",
}[42]);
// Expected: "PASS PASS"
// Actual: "PASS FAIL"
```
UglifyJS may modify the input which in turn may suppress those errors.
- Earlier versions of JavaScript will throw `TypeError` with the following:
```javascript
(function() {
{
const a = "foo";
}
{
const a = "bar";
}
})();
// TypeError: const 'a' has already been declared
```
UglifyJS may modify the input which in turn may suppress those errors.
- Later versions of Chrome and Node.js will give incorrect results with the
following:
```javascript
try {
class A {
static 42;
static get 42() {}
}
console.log("PASS");
} catch (e) {
console.log("FAIL");
}
// Expected: "PASS"
// Actual: "FAIL"
```
UglifyJS may modify the input which in turn may suppress those errors.
- Some versions of Chrome and Node.js will give incorrect results with the
following:
```javascript
(async function(a) {
(function() {
var b = await => console.log("PASS");
b();
})();
})().catch(console.error);
// Expected: "PASS"
// Actual: SyntaxError: Unexpected reserved word
```
UglifyJS may modify the input which in turn may suppress those errors.
- Later versions of Chrome and Node.js will give incorrect results with the
following:
```javascript
try {
f();
function f() {
throw 42;
}
} catch (e) {
console.log(typeof f, e);
}
// Expected: "function 42"
// Actual: "undefined 42"
```
UglifyJS may modify the input which in turn may suppress those errors.
- Later versions of JavaScript will throw `SyntaxError` with the following:
```javascript
"use strict";
console.log(function f() {
return f = "PASS";
}());
// Expected: "PASS"
// Actual: TypeError: invalid assignment to const 'f'
```
UglifyJS may modify the input which in turn may suppress those errors.
- Adobe ExtendScript will give incorrect results with the following:
```javascript
alert(true ? "PASS" : false ? "FAIL" : null);
// Expected: "PASS"
// Actual: "FAIL"
```
UglifyJS may modify the input which in turn may suppress those errors.
- Adobe ExtendScript will give incorrect results with the following:
```javascript
alert(42 ? null ? "FAIL" : "PASS" : "FAIL");
// Expected: "PASS"
// Actual: SyntaxError: Expected: :
```
UglifyJS may modify the input which in turn may suppress those errors.
================================================
FILE: bin/uglifyjs
================================================
#! /usr/bin/env node
// -*- js -*-
"use strict";
require("../tools/tty");
var fs = require("fs");
var info = require("../package.json");
var path = require("path");
var UglifyJS = require("../tools/node");
var skip_keys = [ "cname", "fixed", "in_arg", "inlined", "length_read", "parent_scope", "redef", "scope", "unused" ];
var truthy_keys = [ "optional", "pure", "terminal", "uses_arguments", "uses_eval", "uses_with" ];
var files = {};
var options = {};
var short_forms = {
b: "beautify",
c: "compress",
d: "define",
e: "enclose",
h: "help",
m: "mangle",
o: "output",
O: "output-opts",
p: "parse",
v: "version",
V: "version",
};
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);
});
}
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_fargs: "keep-fargs",
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).",
" --expression Parse a single expression, rather than a program.",
" --ie Support non-standard Internet Explorer.",
" --keep-fargs Do not mangle/drop function arguments.",
" --keep-fnames Do not mangle/drop function names. Useful for code relying on Function.prototype.name.",
" --module Process input as ES module (implies --toplevel).",
" --no-module Process input with improved JavaScript compatibility.",
" --name-cache <file> File to hold mangled name mappings.",
" --rename Force symbol expansion.",
" --no-rename Disable symbol expansion.",
" --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.",
" --v8 Support non-standard Chrome & Node.js.",
" --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 "expression":
case "ie":
case "ie8":
case "timings":
case "toplevel":
case "v8":
case "validate":
case "webkit":
options[name] = true;
break;
case "no-annotations":
options.annotations = false;
break;
case "keep-fargs":
options.keep_fargs = true;
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 "module":
options.module = true;
break;
case "no-module":
options.module = false;
break;
case "name-cache":
nameCache = read_value(true);
options.nameCache = JSON.parse(read_file(nameCache, "{}"));
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 (/^ast|spidermonkey$/.test(output)) {
if (typeof options.output != "object") options.output = {};
options.output.ast = true;
options.output.code = false;
}
if (options.parse && (options.parse.acorn || options.parse.spidermonkey)
&& options.sourceMap && options.sourceMap.content == "inline") {
fatal("inline source map only works with built-in parser");
}
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 options.sourceMap == "object" && "base" in options.sourceMap) {
convert_path = function() {
var base = options.sourceMap.base;
delete options.sourceMap.base;
return function(name) {
return path.relative(base, name);
};
}();
}
if (specified["self"]) {
if (paths.length) UglifyJS.AST_Node.warn("Ignoring input files since --self was passed");
if (!options.wrap) options.wrap = "UglifyJS";
paths = UglifyJS.FILES;
} else if (paths.length) {
paths = simple_glob(paths);
}
if (specified["in-situ"]) {
if (output && output != "spidermonkey" || specified["reduce-test"] || specified["self"]) {
fatal("incompatible options specified");
}
paths.forEach(function(name) {
print(name);
if (/^ast|spidermonkey$/.test(name)) fatal("invalid file name specified");
files = {};
files[convert_path(name)] = read_file(name);
output = name;
run();
});
} else if (paths.length) {
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.once("data", function() {
clearTimeout(timerId);
}).on("data", process.stdin.isTTY ? function(chunk) {
// emulate console input termination via Ctrl+D / Ctrl+Z
var match = /[\x04\x1a]\r?\n?$/.exec(chunk);
if (match) {
chunks.push(chunk.slice(0, -match[0].length));
process.stdin.pause();
process.stdin.emit("end");
} else {
chunks.push(chunk);
}
} : function(chunk) {
chunks.push(chunk);
}).once("end", function() {
files = { STDIN: chunks.join("") };
run();
});
process.stdin.resume();
}
function convert_ast(fn) {
return UglifyJS.AST_Node.from_mozilla_ast(Object.keys(files).reduce(fn, null));
}
function run() {
var content = options.sourceMap && options.sourceMap.content;
if (content && content != "inline") {
UglifyJS.AST_Node.info("Using input source map: {content}", {
content : content,
});
options.sourceMap.content = read_file(content, content);
}
try {
if (options.parse) {
if (options.parse.acorn) {
var annotations = Object.create(null);
files = convert_ast(function(toplevel, name) {
var content = files[name];
var list = annotations[name] = [];
var prev = -1;
return require("acorn").parse(content, {
allowHashBang: true,
ecmaVersion: "latest",
locations: true,
onComment: function(block, text, start, end) {
var match = /[@#]__PURE__/.exec(text);
if (!match) {
if (start != prev) return;
match = [ list[prev] ];
}
while (/\s/.test(content[end])) end++;
list[end] = match[0];
prev = end;
},
preserveParens: true,
program: toplevel,
sourceFile: name,
sourceType: "module",
});
});
files.walk(new UglifyJS.TreeWalker(function(node) {
if (!(node instanceof UglifyJS.AST_Call)) return;
var list = annotations[node.start.file];
var pure = list[node.start.pos];
if (!pure) {
var tokens = node.start.parens;
if (tokens) for (var i = 0; !pure && i < tokens.length; i++) {
pure = list[tokens[i].pos];
}
}
if (pure) node.pure = pure;
}));
} else if (options.parse.spidermonkey) {
files = convert_ast(function(toplevel, name) {
var obj = JSON.parse(files[name]);
if (!toplevel) return obj;
toplevel.body = toplevel.body.concat(obj.body);
return toplevel;
});
}
}
} catch (ex) {
fatal(ex);
}
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 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, " ") + "^");
}
}
} else if (ex.defs) {
print_error("Supported options:");
print_error(format_object(ex.defs));
}
fatal(ex);
} else if (output == "ast") {
if (!options.compress && !options.mangle) {
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 "enclosed":
return value.length ? value.map(symdef) : undefined;
case "functions":
case "globals":
case "variables":
return value.size() ? value.map(symdef) : undefined;
case "thedef":
return symdef(value);
}
if (skip_property(key, value)) return;
if (value instanceof UglifyJS.AST_Token) return;
if (value instanceof UglifyJS.Dictionary) return;
if (value instanceof UglifyJS.AST_Node) {
var result = {
_class: "AST_" + value.TYPE
};
value.CTOR.PROPS.forEach(function(prop) {
result[prop] = value[prop];
});
return result;
}
return value;
}, 2));
} else if (output == "spidermonkey") {
print(JSON.stringify(result.ast.to_mozilla_ast(), null, 2));
} else if (output) {
var code;
if (result.ast) {
var output_options = {};
for (var name in UglifyJS.default_options("output")) {
if (name in options) output_options[name] = options[name];
}
for (var name in options.output) {
if (!/^ast|code$/.test(name)) output_options[name] = options.output[name];
}
code = UglifyJS.AST_Node.from_mozilla_ast(result.ast.to_mozilla_ast()).print_to_string(output_options);
} else {
code = result.code;
}
fs.writeFileSync(output, code);
if (result.map) fs.writeFileSync(output + ".map", result.map);
} else {
print(result.code);
}
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:")
} else {
message = "ERROR: " + message;
}
print_error(message);
process.exit(1);
}
// A file glob function that only supports "*" and "?" wildcards in the basename.
// Example: "foo/bar/*baz??.*.js"
// Argument `paths` must be an array of strings.
// Returns an array of strings. Garbage in, garbage out.
function simple_glob(paths) {
return paths.reduce(function(paths, glob) {
if (/\*|\?/.test(glob)) {
var dir = path.dirname(glob);
try {
var entries = fs.readdirSync(dir).filter(function(name) {
try {
return fs.statSync(path.join(dir, name)).isFile();
} catch (ex) {
return false;
}
});
} catch (ex) {}
if (entries) {
var pattern = "^" + path.basename(glob)
.replace(/[.+^$[\]\\(){}]/g, "\\$&")
.replace(/\*/g, "[^/\\\\]*")
.replace(/\?/g, "[^/\\\\]") + "$";
var mod = process.platform === "win32" ? "i" : "";
var rx = new RegExp(pattern, mod);
var results = entries.filter(function(name) {
return rx.test(name);
}).sort().map(function(name) {
return path.join(dir, name);
});
if (results.length) {
[].push.apply(paths, results);
return paths;
}
}
}
paths.push(glob);
return paths;
}, []);
}
function read_file(path, default_value) {
try {
return fs.readFileSync(path, "utf8");
} catch (ex) {
if (ex.code == "ENOENT" && default_value != null) return default_value;
fatal(ex);
}
}
function parse_js(value, options, flag) {
if (!options || typeof options != "object") options = Object.create(null);
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);
}
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;
}
function skip_property(key, value) {
return skip_keys.indexOf(key) >= 0
// only skip truthy_keys if their value is falsy
|| truthy_keys.indexOf(key) >= 0 && !value;
}
function symdef(def) {
var ret = (1e6 + def.id) + " " + def.name;
if (def.mangled_name) ret += " " + def.mangled_name;
return ret;
}
function format_object(obj) {
var lines = [];
var padding = "";
Object.keys(obj).map(function(name) {
if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
return [ name, JSON.stringify(obj[name]) ];
}).forEach(function(tokens) {
lines.push(" " + tokens[0] + padding.slice(tokens[0].length - 2) + tokens[1]);
});
return lines.join("\n");
}
function print_error(msg) {
process.stderr.write(msg);
process.stderr.write("\n");
}
function print(txt) {
process.stdout.write(txt);
process.stdout.write("\n");
}
================================================
FILE: lib/ast.js
================================================
/***********************************************************************
A JavaScript tokenizer / parser / beautifier / compressor.
https://github.com/mishoo/UglifyJS
-------------------------------- (C) ---------------------------------
Author: Mihai Bazon
<mihai.bazon@gmail.com>
http://mihai.bazon.net/blog
Distributed under the BSD license:
Copyright 2012 (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
are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials
provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
***********************************************************************/
"use strict";
function DEFNODE(type, props, methods, base) {
if (typeof base === "undefined") base = AST_Node;
props = props ? props.split(/\s+/) : [];
var self_props = props;
if (base && base.PROPS) props = props.concat(base.PROPS);
var code = [
"return function AST_", type, "(props){",
// not essential, but speeds up compress by a few percent
"this._bits=0;",
"if(props){",
];
props.forEach(function(prop) {
code.push("this.", prop, "=props.", prop, ";");
});
code.push("}");
var proto = Object.create(base && base.prototype);
if (methods.initialize || proto.initialize) code.push("this.initialize();");
code.push("};");
var ctor = new Function(code.join(""))();
ctor.prototype = proto;
ctor.prototype.CTOR = ctor;
ctor.prototype.TYPE = ctor.TYPE = type;
if (base) {
ctor.BASE = base;
base.SUBCLASSES.push(ctor);
}
ctor.DEFMETHOD = function(name, method) {
this.prototype[name] = method;
};
ctor.PROPS = props;
ctor.SELF_PROPS = self_props;
ctor.SUBCLASSES = [];
for (var name in methods) if (HOP(methods, name)) {
if (/^\$/.test(name)) {
ctor[name.substr(1)] = methods[name];
} else {
ctor.DEFMETHOD(name, methods[name]);
}
}
if (typeof exports !== "undefined") exports["AST_" + type] = ctor;
return ctor;
}
var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before comments_after file raw", {
}, null);
var AST_Node = DEFNODE("Node", "start end", {
_clone: function(deep) {
if (deep) {
var self = this.clone();
return self.transform(new TreeTransformer(function(node) {
if (node !== self) {
return node.clone(true);
}
}));
}
return new this.CTOR(this);
},
clone: function(deep) {
return this._clone(deep);
},
$documentation: "Base class of all AST nodes",
$propdoc: {
start: "[AST_Token] The first token of this node",
end: "[AST_Token] The last token of this node"
},
equals: function(node) {
return this.TYPE == node.TYPE && this._equals(node);
},
walk: function(visitor) {
visitor.visit(this);
},
_validate: function() {
if (this.TYPE == "Node") throw new Error("should not instantiate AST_Node");
},
validate: function() {
var ctor = this.CTOR;
do {
ctor.prototype._validate.call(this);
} while (ctor = ctor.BASE);
},
validate_ast: function() {
var marker = {};
this.walk(new TreeWalker(function(node) {
if (node.validate_visited === marker) {
throw new Error(string_template("cannot reuse AST_{TYPE} from [{start}]", node));
}
node.validate_visited = marker;
}));
},
}, null);
DEF_BITPROPS(AST_Node, [
// AST_Node
"_optimized",
"_squeezed",
// AST_Call
"call_only",
// AST_Lambda
"collapse_scanning",
// AST_SymbolRef
"defined",
"evaluating",
"falsy",
// AST_SymbolRef
"in_arg",
// AST_Return
"in_bool",
// AST_SymbolRef
"is_undefined",
// AST_LambdaExpression
// AST_LambdaDefinition
"inlined",
// AST_Lambda
"length_read",
// AST_Yield
"nested",
// AST_Lambda
"new",
// AST_Call
// AST_PropAccess
"optional",
// AST_ClassProperty
"private",
// AST_Call
"pure",
// AST_Node
"single_use",
// AST_ClassProperty
"static",
// AST_Call
// AST_PropAccess
"terminal",
"truthy",
// AST_Scope
"uses_eval",
// AST_Scope
"uses_with",
]);
(AST_Node.log_function = function(fn, verbose) {
if (typeof fn != "function") {
AST_Node.info = AST_Node.warn = noop;
return;
}
var printed = Object.create(null);
AST_Node.info = verbose ? function(text, props) {
log("INFO: " + string_template(text, props));
} : noop;
AST_Node.warn = function(text, props) {
log("WARN: " + string_template(text, props));
};
function log(msg) {
if (printed[msg]) return;
printed[msg] = true;
fn(msg);
}
})();
var restore_transforms = [];
AST_Node.enable_validation = function() {
AST_Node.disable_validation();
(function validate_transform(ctor) {
ctor.SUBCLASSES.forEach(validate_transform);
if (!HOP(ctor.prototype, "transform")) return;
var transform = ctor.prototype.transform;
ctor.prototype.transform = function(tw, in_list) {
var node = transform.call(this, tw, in_list);
if (node instanceof AST_Node) {
node.validate();
} else if (!(node === null || in_list && List.is_op(node))) {
throw new Error("invalid transformed value: " + node);
}
return node;
};
restore_transforms.push(function() {
ctor.prototype.transform = transform;
});
})(this);
};
AST_Node.disable_validation = function() {
var restore;
while (restore = restore_transforms.pop()) restore();
};
function all_equals(k, l) {
return k.length == l.length && all(k, function(m, i) {
return m.equals(l[i]);
});
}
function list_equals(s, t) {
return s.length == t.length && all(s, function(u, i) {
return u == t[i];
});
}
function prop_equals(u, v) {
if (u === v) return true;
if (u == null) return v == null;
return u instanceof AST_Node && v instanceof AST_Node && u.equals(v);
}
/* -----[ statements ]----- */
var AST_Statement = DEFNODE("Statement", null, {
$documentation: "Base class of all statements",
_validate: function() {
if (this.TYPE == "Statement") throw new Error("should not instantiate AST_Statement");
},
});
var AST_Debugger = DEFNODE("Debugger", null, {
$documentation: "Represents a debugger statement",
_equals: return_true,
}, AST_Statement);
var AST_Directive = DEFNODE("Directive", "quote value", {
$documentation: "Represents a directive, like \"use strict\";",
$propdoc: {
quote: "[string?] the original quote character",
value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
},
_equals: function(node) {
return this.value == node.value;
},
_validate: function() {
if (this.quote != null) {
if (typeof this.quote != "string") throw new Error("quote must be string");
if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
}
if (typeof this.value != "string") throw new Error("value must be string");
},
}, AST_Statement);
var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
$documentation: "The empty statement (empty block or simply a semicolon)",
_equals: return_true,
}, AST_Statement);
function is_statement(node) {
return node instanceof AST_Statement
&& !(node instanceof AST_ClassExpression)
&& !(node instanceof AST_LambdaExpression);
}
function validate_expression(value, prop, multiple, allow_spread, allow_hole) {
multiple = multiple ? "contain" : "be";
if (!(value instanceof AST_Node)) throw new Error(prop + " must " + multiple + " AST_Node");
if (value instanceof AST_DefaultValue) throw new Error(prop + " cannot " + multiple + " AST_DefaultValue");
if (value instanceof AST_Destructured) throw new Error(prop + " cannot " + multiple + " AST_Destructured");
if (value instanceof AST_Hole && !allow_hole) throw new Error(prop + " cannot " + multiple + " AST_Hole");
if (value instanceof AST_Spread && !allow_spread) throw new Error(prop + " cannot " + multiple + " AST_Spread");
if (is_statement(value)) throw new Error(prop + " cannot " + multiple + " AST_Statement");
if (value instanceof AST_SymbolDeclaration) {
throw new Error(prop + " cannot " + multiple + " AST_SymbolDeclaration");
}
}
function must_be_expression(node, prop) {
validate_expression(node[prop], prop);
}
var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
$documentation: "A statement consisting of an expression, i.e. a = 1 + 2",
$propdoc: {
body: "[AST_Node] an expression node (should not be instanceof AST_Statement)",
},
_equals: function(node) {
return this.body.equals(node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.body.walk(visitor);
});
},
_validate: function() {
must_be_expression(this, "body");
},
}, AST_Statement);
var AST_BlockScope = DEFNODE("BlockScope", "_var_names enclosed functions make_def parent_scope variables", {
$documentation: "Base class for all statements introducing a lexical scope",
$propdoc: {
enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any inner scopes",
functions: "[Dictionary/S] like `variables`, but only lists function declarations",
parent_scope: "[AST_Scope?/S] link to the parent scope",
variables: "[Dictionary/S] a map of name ---> SymbolDef for all variables/functions defined in this scope",
},
clone: function(deep) {
var node = this._clone(deep);
if (this.enclosed) node.enclosed = this.enclosed.slice();
if (this.functions) node.functions = this.functions.clone();
if (this.variables) node.variables = this.variables.clone();
return node;
},
pinned: function() {
return this.resolve().pinned();
},
resolve: function() {
return this.parent_scope.resolve();
},
_validate: function() {
if (this.TYPE == "BlockScope") throw new Error("should not instantiate AST_BlockScope");
if (this.parent_scope == null) return;
if (!(this.parent_scope instanceof AST_BlockScope)) throw new Error("parent_scope must be AST_BlockScope");
if (!(this.resolve() instanceof AST_Scope)) throw new Error("must be contained within AST_Scope");
},
}, AST_Statement);
function walk_body(node, visitor) {
node.body.forEach(function(node) {
node.walk(visitor);
});
}
var AST_Block = DEFNODE("Block", "body", {
$documentation: "A body of statements (usually braced)",
$propdoc: {
body: "[AST_Statement*] an array of statements"
},
_equals: function(node) {
return all_equals(this.body, node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
walk_body(node, visitor);
});
},
_validate: function() {
if (this.TYPE == "Block") throw new Error("should not instantiate AST_Block");
this.body.forEach(function(node) {
if (!is_statement(node)) throw new Error("body must contain AST_Statement");
});
},
}, AST_BlockScope);
var AST_BlockStatement = DEFNODE("BlockStatement", null, {
$documentation: "A block statement",
}, AST_Block);
var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
$documentation: "Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`",
$propdoc: {
body: "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
},
_validate: function() {
if (this.TYPE == "StatementWithBody") throw new Error("should not instantiate AST_StatementWithBody");
if (!is_statement(this.body)) throw new Error("body must be AST_Statement");
},
}, AST_BlockScope);
var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
$documentation: "Statement with a label",
$propdoc: {
label: "[AST_Label] a label definition"
},
_equals: function(node) {
return this.label.equals(node.label)
&& this.body.equals(node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.label.walk(visitor);
node.body.walk(visitor);
});
},
clone: function(deep) {
var node = this._clone(deep);
if (deep) {
var label = node.label;
var def = this.label;
node.walk(new TreeWalker(function(node) {
if (node instanceof AST_LoopControl) {
if (!node.label || node.label.thedef !== def) return;
node.label.thedef = label;
label.references.push(node);
return true;
}
if (node instanceof AST_Scope) return true;
}));
}
return node;
},
_validate: function() {
if (!(this.label instanceof AST_Label)) throw new Error("label must be AST_Label");
},
}, AST_StatementWithBody);
var AST_IterationStatement = DEFNODE("IterationStatement", null, {
$documentation: "Internal class. All loops inherit from it.",
_validate: function() {
if (this.TYPE == "IterationStatement") throw new Error("should not instantiate AST_IterationStatement");
},
}, AST_StatementWithBody);
var AST_DWLoop = DEFNODE("DWLoop", "condition", {
$documentation: "Base class for do/while statements",
$propdoc: {
condition: "[AST_Node] the loop condition. Should not be instanceof AST_Statement"
},
_equals: function(node) {
return this.body.equals(node.body)
&& this.condition.equals(node.condition);
},
_validate: function() {
if (this.TYPE == "DWLoop") throw new Error("should not instantiate AST_DWLoop");
must_be_expression(this, "condition");
},
}, AST_IterationStatement);
var AST_Do = DEFNODE("Do", null, {
$documentation: "A `do` statement",
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.body.walk(visitor);
node.condition.walk(visitor);
});
},
}, AST_DWLoop);
var AST_While = DEFNODE("While", null, {
$documentation: "A `while` statement",
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.condition.walk(visitor);
node.body.walk(visitor);
});
},
}, AST_DWLoop);
var AST_For = DEFNODE("For", "init condition step", {
$documentation: "A `for` statement",
$propdoc: {
init: "[AST_Node?] the `for` initialization code, or null if empty",
condition: "[AST_Node?] the `for` termination clause, or null if empty",
step: "[AST_Node?] the `for` update clause, or null if empty"
},
_equals: function(node) {
return prop_equals(this.init, node.init)
&& prop_equals(this.condition, node.condition)
&& prop_equals(this.step, node.step)
&& this.body.equals(node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.init) node.init.walk(visitor);
if (node.condition) node.condition.walk(visitor);
if (node.step) node.step.walk(visitor);
node.body.walk(visitor);
});
},
_validate: function() {
if (this.init != null) {
if (!(this.init instanceof AST_Node)) throw new Error("init must be AST_Node");
if (is_statement(this.init) && !(this.init instanceof AST_Definitions)) {
throw new Error("init cannot be AST_Statement");
}
}
if (this.condition != null) must_be_expression(this, "condition");
if (this.step != null) must_be_expression(this, "step");
},
}, AST_IterationStatement);
var AST_ForEnumeration = DEFNODE("ForEnumeration", "init object", {
$documentation: "Base class for enumeration loops, i.e. `for ... in`, `for ... of` & `for await ... of`",
$propdoc: {
init: "[AST_Node] the assignment target during iteration",
object: "[AST_Node] the object to iterate over"
},
_equals: function(node) {
return this.init.equals(node.init)
&& this.object.equals(node.object)
&& this.body.equals(node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.init.walk(visitor);
node.object.walk(visitor);
node.body.walk(visitor);
});
},
_validate: function() {
if (this.TYPE == "ForEnumeration") throw new Error("should not instantiate AST_ForEnumeration");
if (this.init instanceof AST_Definitions) {
if (this.init.definitions.length != 1) throw new Error("init must have single declaration");
} else {
validate_destructured(this.init, function(node) {
if (!(node instanceof AST_PropAccess || node instanceof AST_SymbolRef)) {
throw new Error("init must be assignable: " + node.TYPE);
}
});
}
must_be_expression(this, "object");
},
}, AST_IterationStatement);
var AST_ForIn = DEFNODE("ForIn", null, {
$documentation: "A `for ... in` statement",
}, AST_ForEnumeration);
var AST_ForOf = DEFNODE("ForOf", null, {
$documentation: "A `for ... of` statement",
}, AST_ForEnumeration);
var AST_ForAwaitOf = DEFNODE("ForAwaitOf", null, {
$documentation: "A `for await ... of` statement",
}, AST_ForOf);
var AST_With = DEFNODE("With", "expression", {
$documentation: "A `with` statement",
$propdoc: {
expression: "[AST_Node] the `with` expression"
},
_equals: function(node) {
return this.expression.equals(node.expression)
&& this.body.equals(node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.expression.walk(visitor);
node.body.walk(visitor);
});
},
_validate: function() {
must_be_expression(this, "expression");
},
}, AST_StatementWithBody);
/* -----[ scope and functions ]----- */
var AST_Scope = DEFNODE("Scope", "fn_defs may_call_this uses_eval uses_with", {
$documentation: "Base class for all statements introducing a lambda scope",
$propdoc: {
uses_eval: "[boolean/S] tells whether this scope contains a direct call to the global `eval`",
uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
},
pinned: function() {
return this.uses_eval || this.uses_with;
},
resolve: return_this,
_validate: function() {
if (this.TYPE == "Scope") throw new Error("should not instantiate AST_Scope");
},
}, AST_Block);
var AST_Toplevel = DEFNODE("Toplevel", "globals", {
$documentation: "The toplevel scope",
$propdoc: {
globals: "[Dictionary/S] a map of name ---> SymbolDef for all undeclared names",
},
wrap: function(name) {
var body = this.body;
return parse([
"(function(exports){'$ORIG';})(typeof ",
name,
"=='undefined'?(",
name,
"={}):",
name,
");"
].join(""), {
filename: "wrap=" + JSON.stringify(name)
}).transform(new TreeTransformer(function(node) {
if (node instanceof AST_Directive && node.value == "$ORIG") {
return List.splice(body);
}
}));
},
enclose: function(args_values) {
if (typeof args_values != "string") args_values = "";
var index = args_values.indexOf(":");
if (index < 0) index = args_values.length;
var body = this.body;
return parse([
"(function(",
args_values.slice(0, index),
'){"$ORIG"})(',
args_values.slice(index + 1),
")"
].join(""), {
filename: "enclose=" + JSON.stringify(args_values)
}).transform(new TreeTransformer(function(node) {
if (node instanceof AST_Directive && node.value == "$ORIG") {
return List.splice(body);
}
}));
}
}, AST_Scope);
var AST_ClassInitBlock = DEFNODE("ClassInitBlock", null, {
$documentation: "Value for `class` static initialization blocks",
}, AST_Scope);
var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest safe_ids uses_arguments", {
$documentation: "Base class for functions",
$propdoc: {
argnames: "[(AST_DefaultValue|AST_Destructured|AST_SymbolFunarg)*] array of function arguments and/or destructured literals",
length_read: "[boolean/S] whether length property of this function is accessed",
rest: "[(AST_Destructured|AST_SymbolFunarg)?] rest parameter, or null if absent",
uses_arguments: "[boolean|number/S] whether this function accesses the arguments array",
},
each_argname: function(visit) {
var tw = new TreeWalker(function(node) {
if (node instanceof AST_DefaultValue) {
node.name.walk(tw);
return true;
}
if (node instanceof AST_DestructuredKeyVal) {
node.value.walk(tw);
return true;
}
if (node instanceof AST_SymbolFunarg) visit(node);
});
this.argnames.forEach(function(argname) {
argname.walk(tw);
});
if (this.rest) this.rest.walk(tw);
},
_equals: function(node) {
return prop_equals(this.rest, node.rest)
&& prop_equals(this.name, node.name)
&& prop_equals(this.value, node.value)
&& all_equals(this.argnames, node.argnames)
&& all_equals(this.body, node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.name) node.name.walk(visitor);
node.argnames.forEach(function(argname) {
argname.walk(visitor);
});
if (node.rest) node.rest.walk(visitor);
walk_body(node, visitor);
});
},
_validate: function() {
if (this.TYPE == "Lambda") throw new Error("should not instantiate AST_Lambda");
this.argnames.forEach(function(node) {
validate_destructured(node, function(node) {
if (!(node instanceof AST_SymbolFunarg)) throw new Error("argnames must be AST_SymbolFunarg[]");
}, true);
});
if (this.rest != null) validate_destructured(this.rest, function(node) {
if (!(node instanceof AST_SymbolFunarg)) throw new Error("rest must be AST_SymbolFunarg");
});
},
}, AST_Scope);
var AST_Accessor = DEFNODE("Accessor", null, {
$documentation: "A getter/setter function",
_validate: function() {
if (this.name != null) throw new Error("name must be null");
},
}, AST_Lambda);
var AST_LambdaExpression = DEFNODE("LambdaExpression", "inlined", {
$documentation: "Base class for function expressions",
$propdoc: {
inlined: "[boolean/S] whether this function has been inlined",
},
_validate: function() {
if (this.TYPE == "LambdaExpression") throw new Error("should not instantiate AST_LambdaExpression");
},
}, AST_Lambda);
function is_arrow(node) {
return node instanceof AST_Arrow || node instanceof AST_AsyncArrow;
}
function is_async(node) {
return node instanceof AST_AsyncArrow
|| node instanceof AST_AsyncDefun
|| node instanceof AST_AsyncFunction
|| node instanceof AST_AsyncGeneratorDefun
|| node instanceof AST_AsyncGeneratorFunction;
}
function is_generator(node) {
return node instanceof AST_AsyncGeneratorDefun
|| node instanceof AST_AsyncGeneratorFunction
|| node instanceof AST_GeneratorDefun
|| node instanceof AST_GeneratorFunction;
}
function walk_lambda(node, tw) {
if (is_arrow(node) && node.value) {
node.value.walk(tw);
} else {
walk_body(node, tw);
}
}
var AST_Arrow = DEFNODE("Arrow", "value", {
$documentation: "An arrow function expression",
$propdoc: {
value: "[AST_Node?] simple return expression, or null if using function body.",
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.argnames.forEach(function(argname) {
argname.walk(visitor);
});
if (node.rest) node.rest.walk(visitor);
if (node.value) {
node.value.walk(visitor);
} else {
walk_body(node, visitor);
}
});
},
_validate: function() {
if (this.name != null) throw new Error("name must be null");
if (this.uses_arguments) throw new Error("uses_arguments must be false");
if (this.value != null) {
must_be_expression(this, "value");
if (this.body.length) throw new Error("body must be empty if value exists");
}
},
}, AST_LambdaExpression);
var AST_AsyncArrow = DEFNODE("AsyncArrow", "value", {
$documentation: "An asynchronous arrow function expression",
$propdoc: {
value: "[AST_Node?] simple return expression, or null if using function body.",
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.argnames.forEach(function(argname) {
argname.walk(visitor);
});
if (node.rest) node.rest.walk(visitor);
if (node.value) {
node.value.walk(visitor);
} else {
walk_body(node, visitor);
}
});
},
_validate: function() {
if (this.name != null) throw new Error("name must be null");
if (this.uses_arguments) throw new Error("uses_arguments must be false");
if (this.value != null) {
must_be_expression(this, "value");
if (this.body.length) throw new Error("body must be empty if value exists");
}
},
}, AST_LambdaExpression);
var AST_AsyncFunction = DEFNODE("AsyncFunction", "name", {
$documentation: "An asynchronous function expression",
$propdoc: {
name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
},
_validate: function() {
if (this.name != null) {
if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
}
},
}, AST_LambdaExpression);
var AST_AsyncGeneratorFunction = DEFNODE("AsyncGeneratorFunction", "name", {
$documentation: "An asynchronous generator function expression",
$propdoc: {
name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
},
_validate: function() {
if (this.name != null) {
if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
}
},
}, AST_LambdaExpression);
var AST_Function = DEFNODE("Function", "name", {
$documentation: "A function expression",
$propdoc: {
name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
},
_validate: function() {
if (this.name != null) {
if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
}
},
}, AST_LambdaExpression);
var AST_GeneratorFunction = DEFNODE("GeneratorFunction", "name", {
$documentation: "A generator function expression",
$propdoc: {
name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
},
_validate: function() {
if (this.name != null) {
if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
}
},
}, AST_LambdaExpression);
var AST_LambdaDefinition = DEFNODE("LambdaDefinition", "inlined name", {
$documentation: "Base class for function definitions",
$propdoc: {
inlined: "[boolean/S] whether this function has been inlined",
name: "[AST_SymbolDefun] the name of this function",
},
_validate: function() {
if (this.TYPE == "LambdaDefinition") throw new Error("should not instantiate AST_LambdaDefinition");
if (!(this.name instanceof AST_SymbolDefun)) throw new Error("name must be AST_SymbolDefun");
},
}, AST_Lambda);
var AST_AsyncDefun = DEFNODE("AsyncDefun", null, {
$documentation: "An asynchronous function definition",
}, AST_LambdaDefinition);
var AST_AsyncGeneratorDefun = DEFNODE("AsyncGeneratorDefun", null, {
$documentation: "An asynchronous generator function definition",
}, AST_LambdaDefinition);
var AST_Defun = DEFNODE("Defun", null, {
$documentation: "A function definition",
}, AST_LambdaDefinition);
var AST_GeneratorDefun = DEFNODE("GeneratorDefun", null, {
$documentation: "A generator function definition",
}, AST_LambdaDefinition);
/* -----[ classes ]----- */
var AST_Class = DEFNODE("Class", "extends name properties", {
$documentation: "Base class for class literals",
$propdoc: {
extends: "[AST_Node?] the super class, or null if not specified",
properties: "[AST_ClassProperty*] array of class properties",
},
_equals: function(node) {
return prop_equals(this.name, node.name)
&& prop_equals(this.extends, node.extends)
&& all_equals(this.properties, node.properties);
},
resolve: function(def_class) {
return def_class ? this : this.parent_scope.resolve();
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.name) node.name.walk(visitor);
if (node.extends) node.extends.walk(visitor);
node.properties.forEach(function(prop) {
prop.walk(visitor);
});
});
},
_validate: function() {
if (this.TYPE == "Class") throw new Error("should not instantiate AST_Class");
if (this.extends != null) must_be_expression(this, "extends");
this.properties.forEach(function(node) {
if (!(node instanceof AST_ClassProperty)) throw new Error("properties must contain AST_ClassProperty");
});
},
}, AST_BlockScope);
var AST_DefClass = DEFNODE("DefClass", null, {
$documentation: "A class definition",
$propdoc: {
name: "[AST_SymbolDefClass] the name of this class",
},
_validate: function() {
if (!(this.name instanceof AST_SymbolDefClass)) throw new Error("name must be AST_SymbolDefClass");
},
}, AST_Class);
var AST_ClassExpression = DEFNODE("ClassExpression", null, {
$documentation: "A class expression",
$propdoc: {
name: "[AST_SymbolClass?] the name of this class, or null if not specified",
},
_validate: function() {
if (this.name != null) {
if (!(this.name instanceof AST_SymbolClass)) throw new Error("name must be AST_SymbolClass");
}
},
}, AST_Class);
var AST_ClassProperty = DEFNODE("ClassProperty", "key private static value", {
$documentation: "Base class for `class` properties",
$propdoc: {
key: "[string|AST_Node?] property name (AST_Node for computed property, null for initialization block)",
private: "[boolean] whether this is a private property",
static: "[boolean] whether this is a static property",
value: "[AST_Node?] property value (AST_Accessor for getters/setters, AST_LambdaExpression for methods, null if not specified for fields)",
},
_equals: function(node) {
return !this.private == !node.private
&& !this.static == !node.static
&& prop_equals(this.key, node.key)
&& prop_equals(this.value, node.value);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.key instanceof AST_Node) node.key.walk(visitor);
if (node.value) node.value.walk(visitor);
});
},
_validate: function() {
if (this.TYPE == "ClassProperty") throw new Error("should not instantiate AST_ClassProperty");
if (this instanceof AST_ClassInit) {
if (this.key != null) throw new Error("key must be null");
} else if (typeof this.key != "string") {
if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
if (this.private) throw new Error("computed key cannot be private");
must_be_expression(this, "key");
} else if (this.private) {
if (!/^#/.test(this.key)) throw new Error("private key must prefix with #");
}
if (this.value != null) {
if (!(this.value instanceof AST_Node)) throw new Error("value must be AST_Node");
}
},
});
var AST_ClassField = DEFNODE("ClassField", null, {
$documentation: "A `class` field",
_validate: function() {
if (this.value != null) must_be_expression(this, "value");
},
}, AST_ClassProperty);
var AST_ClassGetter = DEFNODE("ClassGetter", null, {
$documentation: "A `class` getter",
_validate: function() {
if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor");
},
}, AST_ClassProperty);
var AST_ClassSetter = DEFNODE("ClassSetter", null, {
$documentation: "A `class` setter",
_validate: function() {
if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor");
},
}, AST_ClassProperty);
var AST_ClassMethod = DEFNODE("ClassMethod", null, {
$documentation: "A `class` method",
_validate: function() {
if (!(this.value instanceof AST_LambdaExpression)) throw new Error("value must be AST_LambdaExpression");
if (is_arrow(this.value)) throw new Error("value cannot be AST_Arrow or AST_AsyncArrow");
if (this.value.name != null) throw new Error("name of class method's lambda must be null");
},
}, AST_ClassProperty);
var AST_ClassInit = DEFNODE("ClassInit", null, {
$documentation: "A `class` static initialization block",
_validate: function() {
if (!this.static) throw new Error("static must be true");
if (!(this.value instanceof AST_ClassInitBlock)) throw new Error("value must be AST_ClassInitBlock");
},
initialize: function() {
this.static = true;
},
}, AST_ClassProperty);
/* -----[ JUMPS ]----- */
var AST_Jump = DEFNODE("Jump", null, {
$documentation: "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)",
_validate: function() {
if (this.TYPE == "Jump") throw new Error("should not instantiate AST_Jump");
},
}, AST_Statement);
var AST_Exit = DEFNODE("Exit", "value", {
$documentation: "Base class for “exits” (`return` and `throw`)",
$propdoc: {
value: "[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return"
},
_equals: function(node) {
return prop_equals(this.value, node.value);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.value) node.value.walk(visitor);
});
},
_validate: function() {
if (this.TYPE == "Exit") throw new Error("should not instantiate AST_Exit");
},
}, AST_Jump);
var AST_Return = DEFNODE("Return", null, {
$documentation: "A `return` statement",
_validate: function() {
if (this.value != null) must_be_expression(this, "value");
},
}, AST_Exit);
var AST_Throw = DEFNODE("Throw", null, {
$documentation: "A `throw` statement",
_validate: function() {
must_be_expression(this, "value");
},
}, AST_Exit);
var AST_LoopControl = DEFNODE("LoopControl", "label", {
$documentation: "Base class for loop control statements (`break` and `continue`)",
$propdoc: {
label: "[AST_LabelRef?] the label, or null if none",
},
_equals: function(node) {
return prop_equals(this.label, node.label);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.label) node.label.walk(visitor);
});
},
_validate: function() {
if (this.TYPE == "LoopControl") throw new Error("should not instantiate AST_LoopControl");
if (this.label != null) {
if (!(this.label instanceof AST_LabelRef)) throw new Error("label must be AST_LabelRef");
}
},
}, AST_Jump);
var AST_Break = DEFNODE("Break", null, {
$documentation: "A `break` statement"
}, AST_LoopControl);
var AST_Continue = DEFNODE("Continue", null, {
$documentation: "A `continue` statement"
}, AST_LoopControl);
/* -----[ IF ]----- */
var AST_If = DEFNODE("If", "condition alternative", {
$documentation: "A `if` statement",
$propdoc: {
condition: "[AST_Node] the `if` condition",
alternative: "[AST_Statement?] the `else` part, or null if not present"
},
_equals: function(node) {
return this.body.equals(node.body)
&& this.condition.equals(node.condition)
&& prop_equals(this.alternative, node.alternative);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.condition.walk(visitor);
node.body.walk(visitor);
if (node.alternative) node.alternative.walk(visitor);
});
},
_validate: function() {
must_be_expression(this, "condition");
if (this.alternative != null) {
if (!is_statement(this.alternative)) throw new Error("alternative must be AST_Statement");
}
},
}, AST_StatementWithBody);
/* -----[ SWITCH ]----- */
var AST_Switch = DEFNODE("Switch", "expression", {
$documentation: "A `switch` statement",
$propdoc: {
expression: "[AST_Node] the `switch` “discriminant”"
},
_equals: function(node) {
return this.expression.equals(node.expression)
&& all_equals(this.body, node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.expression.walk(visitor);
walk_body(node, visitor);
});
},
_validate: function() {
must_be_expression(this, "expression");
this.body.forEach(function(node) {
if (!(node instanceof AST_SwitchBranch)) throw new Error("body must be AST_SwitchBranch[]");
});
},
}, AST_Block);
var AST_SwitchBranch = DEFNODE("SwitchBranch", null, {
$documentation: "Base class for `switch` branches",
_validate: function() {
if (this.TYPE == "SwitchBranch") throw new Error("should not instantiate AST_SwitchBranch");
},
}, AST_Block);
var AST_Default = DEFNODE("Default", null, {
$documentation: "A `default` switch branch",
}, AST_SwitchBranch);
var AST_Case = DEFNODE("Case", "expression", {
$documentation: "A `case` switch branch",
$propdoc: {
expression: "[AST_Node] the `case` expression"
},
_equals: function(node) {
return this.expression.equals(node.expression)
&& all_equals(this.body, node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.expression.walk(visitor);
walk_body(node, visitor);
});
},
_validate: function() {
must_be_expression(this, "expression");
},
}, AST_SwitchBranch);
/* -----[ EXCEPTIONS ]----- */
var AST_Try = DEFNODE("Try", "bcatch bfinally", {
$documentation: "A `try` statement",
$propdoc: {
bcatch: "[AST_Catch?] the catch block, or null if not present",
bfinally: "[AST_Finally?] the finally block, or null if not present"
},
_equals: function(node) {
return all_equals(this.body, node.body)
&& prop_equals(this.bcatch, node.bcatch)
&& prop_equals(this.bfinally, node.bfinally);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
walk_body(node, visitor);
if (node.bcatch) node.bcatch.walk(visitor);
if (node.bfinally) node.bfinally.walk(visitor);
});
},
_validate: function() {
if (this.bcatch != null) {
if (!(this.bcatch instanceof AST_Catch)) throw new Error("bcatch must be AST_Catch");
}
if (this.bfinally != null) {
if (!(this.bfinally instanceof AST_Finally)) throw new Error("bfinally must be AST_Finally");
}
},
}, AST_Block);
var AST_Catch = DEFNODE("Catch", "argname", {
$documentation: "A `catch` node; only makes sense as part of a `try` statement",
$propdoc: {
argname: "[(AST_Destructured|AST_SymbolCatch)?] symbol for the exception, or null if not present",
},
_equals: function(node) {
return prop_equals(this.argname, node.argname)
&& all_equals(this.body, node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.argname) node.argname.walk(visitor);
walk_body(node, visitor);
});
},
_validate: function() {
if (this.argname != null) validate_destructured(this.argname, function(node) {
if (!(node instanceof AST_SymbolCatch)) throw new Error("argname must be AST_SymbolCatch");
});
},
}, AST_Block);
var AST_Finally = DEFNODE("Finally", null, {
$documentation: "A `finally` node; only makes sense as part of a `try` statement"
}, AST_Block);
/* -----[ VAR ]----- */
var AST_Definitions = DEFNODE("Definitions", "definitions", {
$documentation: "Base class for `var` nodes (variable declarations/initializations)",
$propdoc: {
definitions: "[AST_VarDef*] array of variable definitions"
},
_equals: function(node) {
return all_equals(this.definitions, node.definitions);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.definitions.forEach(function(defn) {
defn.walk(visitor);
});
});
},
_validate: function() {
if (this.TYPE == "Definitions") throw new Error("should not instantiate AST_Definitions");
if (this.definitions.length < 1) throw new Error("must have at least one definition");
},
}, AST_Statement);
var AST_Const = DEFNODE("Const", null, {
$documentation: "A `const` statement",
_validate: function() {
this.definitions.forEach(function(node) {
if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]");
validate_destructured(node.name, function(node) {
if (!(node instanceof AST_SymbolConst)) throw new Error("name must be AST_SymbolConst");
});
});
},
}, AST_Definitions);
var AST_Let = DEFNODE("Let", null, {
$documentation: "A `let` statement",
_validate: function() {
this.definitions.forEach(function(node) {
if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]");
validate_destructured(node.name, function(node) {
if (!(node instanceof AST_SymbolLet)) throw new Error("name must be AST_SymbolLet");
});
});
},
}, AST_Definitions);
var AST_Var = DEFNODE("Var", null, {
$documentation: "A `var` statement",
_validate: function() {
this.definitions.forEach(function(node) {
if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]");
validate_destructured(node.name, function(node) {
if (!(node instanceof AST_SymbolVar)) throw new Error("name must be AST_SymbolVar");
});
});
},
}, AST_Definitions);
var AST_VarDef = DEFNODE("VarDef", "name value", {
$documentation: "A variable declaration; only appears in a AST_Definitions node",
$propdoc: {
name: "[AST_Destructured|AST_SymbolVar] name of the variable",
value: "[AST_Node?] initializer, or null of there's no initializer",
},
_equals: function(node) {
return this.name.equals(node.name)
&& prop_equals(this.value, node.value);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.name.walk(visitor);
if (node.value) node.value.walk(visitor);
});
},
_validate: function() {
if (this.value != null) must_be_expression(this, "value");
},
});
/* -----[ OTHER ]----- */
var AST_ExportDeclaration = DEFNODE("ExportDeclaration", "body", {
$documentation: "An `export` statement",
$propdoc: {
body: "[AST_DefClass|AST_Definitions|AST_LambdaDefinition] the statement to export",
},
_equals: function(node) {
return this.body.equals(node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.body.walk(visitor);
});
},
_validate: function() {
if (!(this.body instanceof AST_DefClass
|| this.body instanceof AST_Definitions
|| this.body instanceof AST_LambdaDefinition)) {
throw new Error("body must be AST_DefClass, AST_Definitions or AST_LambdaDefinition");
}
},
}, AST_Statement);
var AST_ExportDefault = DEFNODE("ExportDefault", "body", {
$documentation: "An `export default` statement",
$propdoc: {
body: "[AST_Node] the default export",
},
_equals: function(node) {
return this.body.equals(node.body);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.body.walk(visitor);
});
},
_validate: function() {
if (!(this.body instanceof AST_DefClass || this.body instanceof AST_LambdaDefinition)) {
must_be_expression(this, "body");
}
},
}, AST_Statement);
var AST_ExportForeign = DEFNODE("ExportForeign", "aliases keys path", {
$documentation: "An `export ... from '...'` statement",
$propdoc: {
aliases: "[AST_String*] array of aliases to export",
keys: "[AST_String*] array of keys to import",
path: "[AST_String] the path to import module",
},
_equals: function(node) {
return this.path.equals(node.path)
&& all_equals(this.aliases, node.aliases)
&& all_equals(this.keys, node.keys);
},
_validate: function() {
if (this.aliases.length != this.keys.length) {
throw new Error("aliases:key length mismatch: " + this.aliases.length + " != " + this.keys.length);
}
this.aliases.forEach(function(name) {
if (!(name instanceof AST_String)) throw new Error("aliases must contain AST_String");
});
this.keys.forEach(function(name) {
if (!(name instanceof AST_String)) throw new Error("keys must contain AST_String");
});
if (!(this.path instanceof AST_String)) throw new Error("path must be AST_String");
},
}, AST_Statement);
var AST_ExportReferences = DEFNODE("ExportReferences", "properties", {
$documentation: "An `export { ... }` statement",
$propdoc: {
properties: "[AST_SymbolExport*] array of aliases to export",
},
_equals: function(node) {
return all_equals(this.properties, node.properties);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.properties.forEach(function(prop) {
prop.walk(visitor);
});
});
},
_validate: function() {
this.properties.forEach(function(prop) {
if (!(prop instanceof AST_SymbolExport)) throw new Error("properties must contain AST_SymbolExport");
});
},
}, AST_Statement);
var AST_Import = DEFNODE("Import", "all default path properties", {
$documentation: "An `import` statement",
$propdoc: {
all: "[AST_SymbolImport?] the imported namespace, or null if not specified",
default: "[AST_SymbolImport?] the alias for default `export`, or null if not specified",
path: "[AST_String] the path to import module",
properties: "[(AST_SymbolImport*)?] array of aliases, or null if not specified",
},
_equals: function(node) {
return this.path.equals(node.path)
&& prop_equals(this.all, node.all)
&& prop_equals(this.default, node.default)
&& !this.properties == !node.properties
&& (!this.properties || all_equals(this.properties, node.properties));
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.all) node.all.walk(visitor);
if (node.default) node.default.walk(visitor);
if (node.properties) node.properties.forEach(function(prop) {
prop.walk(visitor);
});
});
},
_validate: function() {
if (this.all != null) {
if (!(this.all instanceof AST_SymbolImport)) throw new Error("all must be AST_SymbolImport");
if (this.properties != null) throw new Error("cannot import both * and {} in the same statement");
}
if (this.default != null) {
if (!(this.default instanceof AST_SymbolImport)) throw new Error("default must be AST_SymbolImport");
if (this.default.key.value !== "") throw new Error("invalid default key: " + this.default.key.value);
}
if (!(this.path instanceof AST_String)) throw new Error("path must be AST_String");
if (this.properties != null) this.properties.forEach(function(node) {
if (!(node instanceof AST_SymbolImport)) throw new Error("properties must contain AST_SymbolImport");
});
},
}, AST_Statement);
var AST_DefaultValue = DEFNODE("DefaultValue", "name value", {
$documentation: "A default value declaration",
$propdoc: {
name: "[AST_Destructured|AST_SymbolDeclaration] name of the variable",
value: "[AST_Node] value to assign if variable is `undefined`",
},
_equals: function(node) {
return this.name.equals(node.name)
&& this.value.equals(node.value);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.name.walk(visitor);
node.value.walk(visitor);
});
},
_validate: function() {
must_be_expression(this, "value");
},
});
function must_be_expressions(node, prop, allow_spread, allow_hole) {
node[prop].forEach(function(node) {
validate_expression(node, prop, true, allow_spread, allow_hole);
});
}
var AST_Call = DEFNODE("Call", "args expression optional pure terminal", {
$documentation: "A function call expression",
$propdoc: {
args: "[AST_Node*] array of arguments",
expression: "[AST_Node] expression to invoke as function",
optional: "[boolean] whether the expression is optional chaining",
pure: "[boolean/S] marker for side-effect-free call expression",
terminal: "[boolean] whether the chain has ended",
},
_equals: function(node) {
return !this.optional == !node.optional
&& this.expression.equals(node.expression)
&& all_equals(this.args, node.args);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.expression.walk(visitor);
node.args.forEach(function(arg) {
arg.walk(visitor);
});
});
},
_validate: function() {
must_be_expression(this, "expression");
must_be_expressions(this, "args", true);
},
});
var AST_New = DEFNODE("New", null, {
$documentation: "An object instantiation. Derives from a function call since it has exactly the same properties",
_validate: function() {
if (this.optional) throw new Error("optional must be false");
if (this.terminal) throw new Error("terminal must be false");
},
}, AST_Call);
var AST_Sequence = DEFNODE("Sequence", "expressions", {
$documentation: "A sequence expression (comma-separated expressions)",
$propdoc: {
expressions: "[AST_Node*] array of expressions (at least two)",
},
_equals: function(node) {
return all_equals(this.expressions, node.expressions);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.expressions.forEach(function(expr) {
expr.walk(visitor);
});
});
},
_validate: function() {
if (this.expressions.length < 2) throw new Error("expressions must contain multiple elements");
must_be_expressions(this, "expressions");
},
});
function root_expr(prop) {
while (prop instanceof AST_PropAccess) prop = prop.expression;
return prop;
}
var AST_PropAccess = DEFNODE("PropAccess", "expression optional property terminal", {
$documentation: "Base class for property access expressions, i.e. `a.foo` or `a[\"foo\"]`",
$propdoc: {
expression: "[AST_Node] the “container” expression",
optional: "[boolean] whether the expression is optional chaining",
property: "[AST_Node|string] the property to access. For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node",
terminal: "[boolean] whether the chain has ended",
},
_equals: function(node) {
return !this.optional == !node.optional
&& prop_equals(this.property, node.property)
&& this.expression.equals(node.expression);
},
get_property: function() {
var p = this.property;
if (p instanceof AST_Constant) return p.value;
if (p instanceof AST_UnaryPrefix && p.operator == "void" && p.expression instanceof AST_Constant) return;
return p;
},
_validate: function() {
if (this.TYPE == "PropAccess") throw new Error("should not instantiate AST_PropAccess");
must_be_expression(this, "expression");
},
});
var AST_Dot = DEFNODE("Dot", "quoted", {
$documentation: "A dotted property access expression",
$propdoc: {
quoted: "[boolean] whether property is transformed from a quoted string",
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.expression.walk(visitor);
});
},
_validate: function() {
if (typeof this.property != "string") throw new Error("property must be string");
},
}, AST_PropAccess);
var AST_Sub = DEFNODE("Sub", null, {
$documentation: "Index-style property access, i.e. `a[\"foo\"]`",
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.expression.walk(visitor);
node.property.walk(visitor);
});
},
_validate: function() {
must_be_expression(this, "property");
},
}, AST_PropAccess);
var AST_Spread = DEFNODE("Spread", "expression", {
$documentation: "Spread expression in array/object literals or function calls",
$propdoc: {
expression: "[AST_Node] expression to be expanded",
},
_equals: function(node) {
return this.expression.equals(node.expression);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.expression.walk(visitor);
});
},
_validate: function() {
must_be_expression(this, "expression");
},
});
var AST_Unary = DEFNODE("Unary", "operator expression", {
$documentation: "Base class for unary expressions",
$propdoc: {
operator: "[string] the operator",
expression: "[AST_Node] expression that this unary operator applies to",
},
_equals: function(node) {
return this.operator == node.operator
&& this.expression.equals(node.expression);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.expression.walk(visitor);
});
},
_validate: function() {
if (this.TYPE == "Unary") throw new Error("should not instantiate AST_Unary");
if (typeof this.operator != "string") throw new Error("operator must be string");
must_be_expression(this, "expression");
},
});
var AST_UnaryPrefix = DEFNODE("UnaryPrefix", null, {
$documentation: "Unary prefix expression, i.e. `typeof i` or `++i`"
}, AST_Unary);
var AST_UnaryPostfix = DEFNODE("UnaryPostfix", null, {
$documentation: "Unary postfix expression, i.e. `i++`"
}, AST_Unary);
var AST_Binary = DEFNODE("Binary", "operator left right", {
$documentation: "Binary expression, i.e. `a + b`",
$propdoc: {
left: "[AST_Node] left-hand side expression",
operator: "[string] the operator",
right: "[AST_Node] right-hand side expression"
},
_equals: function(node) {
return this.operator == node.operator
&& this.left.equals(node.left)
&& this.right.equals(node.right);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.left.walk(visitor);
node.right.walk(visitor);
});
},
_validate: function() {
if (!(this instanceof AST_Assign)) must_be_expression(this, "left");
if (typeof this.operator != "string") throw new Error("operator must be string");
must_be_expression(this, "right");
},
});
var AST_Conditional = DEFNODE("Conditional", "condition consequent alternative", {
$documentation: "Conditional expression using the ternary operator, i.e. `a ? b : c`",
$propdoc: {
condition: "[AST_Node]",
consequent: "[AST_Node]",
alternative: "[AST_Node]"
},
_equals: function(node) {
return this.condition.equals(node.condition)
&& this.consequent.equals(node.consequent)
&& this.alternative.equals(node.alternative);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.condition.walk(visitor);
node.consequent.walk(visitor);
node.alternative.walk(visitor);
});
},
_validate: function() {
must_be_expression(this, "condition");
must_be_expression(this, "consequent");
must_be_expression(this, "alternative");
},
});
var AST_Assign = DEFNODE("Assign", null, {
$documentation: "An assignment expression — `a = b + 5`",
_validate: function() {
if (this.operator.indexOf("=") < 0) throw new Error('operator must contain "="');
if (this.left instanceof AST_Destructured) {
if (this.operator != "=") throw new Error("invalid destructuring operator: " + this.operator);
validate_destructured(this.left, function(node) {
if (!(node instanceof AST_PropAccess || node instanceof AST_SymbolRef)) {
throw new Error("left must be assignable: " + node.TYPE);
}
});
} else if (!(this.left instanceof AST_Infinity
|| this.left instanceof AST_NaN
|| this.left instanceof AST_PropAccess && !this.left.optional
|| this.left instanceof AST_SymbolRef
|| this.left instanceof AST_Undefined)) {
throw new Error("left must be assignable");
}
},
}, AST_Binary);
var AST_Await = DEFNODE("Await", "expression", {
$documentation: "An await expression",
$propdoc: {
expression: "[AST_Node] expression with Promise to resolve on",
},
_equals: function(node) {
return this.expression.equals(node.expression);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.expression.walk(visitor);
});
},
_validate: function() {
must_be_expression(this, "expression");
},
});
var AST_Yield = DEFNODE("Yield", "expression nested", {
$documentation: "A yield expression",
$propdoc: {
expression: "[AST_Node?] return value for iterator, or null if undefined",
nested: "[boolean] whether to iterate over expression as generator",
},
_equals: function(node) {
return !this.nested == !node.nested
&& prop_equals(this.expression, node.expression);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.expression) node.expression.walk(visitor);
});
},
_validate: function() {
if (this.expression != null) {
must_be_expression(this, "expression");
} else if (this.nested) {
throw new Error("yield* must contain expression");
}
},
});
/* -----[ LITERALS ]----- */
var AST_Array = DEFNODE("Array", "elements", {
$documentation: "An array literal",
$propdoc: {
elements: "[AST_Node*] array of elements"
},
_equals: function(node) {
return all_equals(this.elements, node.elements);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.elements.forEach(function(element) {
element.walk(visitor);
});
});
},
_validate: function() {
must_be_expressions(this, "elements", true, true);
},
});
var AST_Destructured = DEFNODE("Destructured", "rest", {
$documentation: "Base class for destructured literal",
$propdoc: {
rest: "[(AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef)?] rest parameter, or null if absent",
},
_validate: function() {
if (this.TYPE == "Destructured") throw new Error("should not instantiate AST_Destructured");
},
});
function validate_destructured(node, check, allow_default) {
if (node instanceof AST_DefaultValue && allow_default) return validate_destructured(node.name, check);
if (node instanceof AST_Destructured) {
if (node.rest != null) validate_destructured(node.rest, check);
if (node instanceof AST_DestructuredArray) return node.elements.forEach(function(node) {
if (!(node instanceof AST_Hole)) validate_destructured(node, check, true);
});
if (node instanceof AST_DestructuredObject) return node.properties.forEach(function(prop) {
validate_destructured(prop.value, check, true);
});
}
check(node);
}
var AST_DestructuredArray = DEFNODE("DestructuredArray", "elements", {
$documentation: "A destructured array literal",
$propdoc: {
elements: "[(AST_DefaultValue|AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef)*] array of elements",
},
_equals: function(node) {
return prop_equals(this.rest, node.rest)
&& all_equals(this.elements, node.elements);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.elements.forEach(function(element) {
element.walk(visitor);
});
if (node.rest) node.rest.walk(visitor);
});
},
}, AST_Destructured);
var AST_DestructuredKeyVal = DEFNODE("DestructuredKeyVal", "key value", {
$documentation: "A key: value destructured property",
$propdoc: {
key: "[string|AST_Node] property name. For computed property this is an AST_Node.",
value: "[AST_DefaultValue|AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef] property value",
},
_equals: function(node) {
return prop_equals(this.key, node.key)
&& this.value.equals(node.value);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.key instanceof AST_Node) node.key.walk(visitor);
node.value.walk(visitor);
});
},
_validate: function() {
if (typeof this.key != "string") {
if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
must_be_expression(this, "key");
}
if (!(this.value instanceof AST_Node)) throw new Error("value must be AST_Node");
},
});
var AST_DestructuredObject = DEFNODE("DestructuredObject", "properties", {
$documentation: "A destructured object literal",
$propdoc: {
properties: "[AST_DestructuredKeyVal*] array of properties",
},
_equals: function(node) {
return prop_equals(this.rest, node.rest)
&& all_equals(this.properties, node.properties);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.properties.forEach(function(prop) {
prop.walk(visitor);
});
if (node.rest) node.rest.walk(visitor);
});
},
_validate: function() {
this.properties.forEach(function(node) {
if (!(node instanceof AST_DestructuredKeyVal)) throw new Error("properties must be AST_DestructuredKeyVal[]");
});
},
}, AST_Destructured);
var AST_Object = DEFNODE("Object", "properties", {
$documentation: "An object literal",
$propdoc: {
properties: "[(AST_ObjectProperty|AST_Spread)*] array of properties"
},
_equals: function(node) {
return all_equals(this.properties, node.properties);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
node.properties.forEach(function(prop) {
prop.walk(visitor);
});
});
},
_validate: function() {
this.properties.forEach(function(node) {
if (!(node instanceof AST_ObjectProperty || node instanceof AST_Spread)) {
throw new Error("properties must contain AST_ObjectProperty and/or AST_Spread only");
}
});
},
});
var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
$documentation: "Base class for literal object properties",
$propdoc: {
key: "[string|AST_Node] property name. For computed property this is an AST_Node.",
value: "[AST_Node] property value. For getters and setters this is an AST_Accessor.",
},
_equals: function(node) {
return prop_equals(this.key, node.key)
&& this.value.equals(node.value);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.key instanceof AST_Node) node.key.walk(visitor);
node.value.walk(visitor);
});
},
_validate: function() {
if (this.TYPE == "ObjectProperty") throw new Error("should not instantiate AST_ObjectProperty");
if (typeof this.key != "string") {
if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
must_be_expression(this, "key");
}
if (!(this.value instanceof AST_Node)) throw new Error("value must be AST_Node");
},
});
var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", null, {
$documentation: "A key: value object property",
_validate: function() {
must_be_expression(this, "value");
},
}, AST_ObjectProperty);
var AST_ObjectMethod = DEFNODE("ObjectMethod", null, {
$documentation: "A key(){} object property",
_validate: function() {
if (!(this.value instanceof AST_LambdaExpression)) throw new Error("value must be AST_LambdaExpression");
if (is_arrow(this.value)) throw new Error("value cannot be AST_Arrow or AST_AsyncArrow");
if (this.value.name != null) throw new Error("name of object method's lambda must be null");
},
}, AST_ObjectKeyVal);
var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
$documentation: "An object setter property",
_validate: function() {
if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor");
},
}, AST_ObjectProperty);
var AST_ObjectGetter = DEFNODE("ObjectGetter", null, {
$documentation: "An object getter property",
_validate: function() {
if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor");
},
}, AST_ObjectProperty);
var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
$documentation: "Base class for all symbols",
$propdoc: {
name: "[string] name of this symbol",
scope: "[AST_Scope/S] the current scope (not necessarily the definition scope)",
thedef: "[SymbolDef/S] the definition of this symbol"
},
_equals: function(node) {
return this.thedef ? this.thedef === node.thedef : this.name == node.name;
},
_validate: function() {
if (this.TYPE == "Symbol") throw new Error("should not instantiate AST_Symbol");
if (typeof this.name != "string") throw new Error("name must be string");
},
});
var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
$documentation: "A declaration symbol (symbol in var, function name or argument, symbol in catch)",
}, AST_Symbol);
var AST_SymbolConst = DEFNODE("SymbolConst", null, {
$documentation: "Symbol defining a constant",
}, AST_SymbolDeclaration);
var AST_SymbolImport = DEFNODE("SymbolImport", "key", {
$documentation: "Symbol defined by an `import` statement",
$propdoc: {
key: "[AST_String] the original `export` name",
},
_equals: function(node) {
return this.name == node.name
&& this.key.equals(node.key);
},
_validate: function() {
if (!(this.key instanceof AST_String)) throw new Error("key must be AST_String");
},
}, AST_SymbolConst);
var AST_SymbolLet = DEFNODE("SymbolLet", null, {
$documentation: "Symbol defining a lexical-scoped variable",
}, AST_SymbolDeclaration);
var AST_SymbolVar = DEFNODE("SymbolVar", null, {
$documentation: "Symbol defining a variable",
}, AST_SymbolDeclaration);
var AST_SymbolFunarg = DEFNODE("SymbolFunarg", "unused", {
$documentation: "Symbol naming a function argument",
}, AST_SymbolVar);
var AST_SymbolDefun = DEFNODE("SymbolDefun", null, {
$documentation: "Symbol defining a function",
}, AST_SymbolDeclaration);
var AST_SymbolLambda = DEFNODE("SymbolLambda", null, {
$documentation: "Symbol naming a function expression",
}, AST_SymbolDeclaration);
var AST_SymbolDefClass = DEFNODE("SymbolDefClass", null, {
$documentation: "Symbol defining a class",
}, AST_SymbolConst);
var AST_SymbolClass = DEFNODE("SymbolClass", null, {
$documentation: "Symbol naming a class expression",
}, AST_SymbolConst);
var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
$documentation: "Symbol naming the exception in catch",
}, AST_SymbolDeclaration);
var AST_Label = DEFNODE("Label", "references", {
$documentation: "Symbol naming a label (declaration)",
$propdoc: {
references: "[AST_LoopControl*] a list of nodes referring to this label"
},
initialize: function() {
this.references = [];
this.thedef = this;
},
}, AST_Symbol);
var AST_SymbolRef = DEFNODE("SymbolRef", "fixed in_arg redef", {
$documentation: "Reference to some symbol (not definition/declaration)",
}, AST_Symbol);
var AST_SymbolExport = DEFNODE("SymbolExport", "alias", {
$documentation: "Reference in an `export` statement",
$propdoc: {
alias: "[AST_String] the `export` alias",
},
_equals: function(node) {
return this.name == node.name
&& this.alias.equals(node.alias);
},
_validate: function() {
if (!(this.alias instanceof AST_String)) throw new Error("alias must be AST_String");
},
}, AST_SymbolRef);
var AST_LabelRef = DEFNODE("LabelRef", null, {
$documentation: "Reference to a label symbol",
}, AST_Symbol);
var AST_ObjectIdentity = DEFNODE("ObjectIdentity", null, {
$documentation: "Base class for `super` & `this`",
_equals: return_true,
_validate: function() {
if (this.TYPE == "ObjectIdentity") throw new Error("should not instantiate AST_ObjectIdentity");
},
}, AST_Symbol);
var AST_Super = DEFNODE("Super", null, {
$documentation: "The `super` symbol",
_validate: function() {
if (this.name !== "super") throw new Error('name must be "super"');
},
}, AST_ObjectIdentity);
var AST_This = DEFNODE("This", null, {
$documentation: "The `this` symbol",
_validate: function() {
if (this.TYPE == "This" && this.name !== "this") throw new Error('name must be "this"');
},
}, AST_ObjectIdentity);
var AST_NewTarget = DEFNODE("NewTarget", null, {
$documentation: "The `new.target` symbol",
initialize: function() {
this.name = "new.target";
},
_validate: function() {
if (this.name !== "new.target") throw new Error('name must be "new.target": ' + this.name);
},
}, AST_This);
var AST_Template = DEFNODE("Template", "expressions strings tag", {
$documentation: "A template literal, i.e. tag`str1${expr1}...strN${exprN}strN+1`",
$propdoc: {
expressions: "[AST_Node*] the placeholder expressions",
strings: "[string*] the raw text segments",
tag: "[AST_Node?] tag function, or null if absent",
},
_equals: function(node) {
return prop_equals(this.tag, node.tag)
&& list_equals(this.strings, node.strings)
&& all_equals(this.expressions, node.expressions);
},
walk: function(visitor) {
var node = this;
visitor.visit(node, function() {
if (node.tag) node.tag.walk(visitor);
node.expressions.forEach(function(expr) {
expr.walk(visitor);
});
});
},
_validate: function() {
if (this.expressions.length + 1 != this.strings.length) {
throw new Error("malformed template with " + this.expressions.length + " placeholder(s) but " + this.strings.length + " text segment(s)");
}
must_be_expressions(this, "expressions");
this.strings.forEach(function(string) {
if (typeof string != "string") throw new Error("strings must contain string");
});
if (this.tag != null) must_be_expression(this, "tag");
},
});
var AST_Constant = DEFNODE("Constant", null, {
$documentation: "Base class for all constants",
_equals: function(node) {
return this.value === node.value;
},
_validate: function() {
if (this.TYPE == "Constant") throw new Error("should not instantiate AST_Constant");
},
});
var AST_String = DEFNODE("String", "quote value", {
$documentation: "A string literal",
$propdoc: {
quote: "[string?] the original quote character",
value: "[string] the contents of this string",
},
_validate: function() {
if (this.quote != null) {
if (typeof this.quote != "string") throw new Error("quote must be string");
if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
}
if (typeof this.value != "string") throw new Error("value must be string");
},
}, AST_Constant);
var AST_Number = DEFNODE("Number", "value", {
$documentation: "A number literal",
$propdoc: {
value: "[number] the numeric value",
},
_validate: function() {
if (typeof this.value != "number") throw new Error("value must be number");
if (!isFinite(this.value)) throw new Error("value must be finite");
if (this.value < 0) throw new Error("value cannot be negative");
},
}, AST_Constant);
var AST_BigInt = DEFNODE("BigInt", "value", {
$documentation: "A BigInt literal",
$propdoc: {
value: "[string] the numeric representation",
},
_validate: function() {
if (typeof this.value != "string") throw new Error("value must be string");
if (this.value[0] == "-") throw new Error("value cannot be negative");
},
}, AST_Constant);
var AST_RegExp = DEFNODE("RegExp", "value", {
$documentation: "A regexp literal",
$propdoc: {
value: "[RegExp] the actual regexp"
},
_equals: function(node) {
return "" + this.value == "" + node.value;
},
_validate: function() {
if (!(this.value instanceof RegExp)) throw new Error("value must be RegExp");
},
}, AST_Constant);
var AST_Atom = DEFNODE("Atom", null, {
$documentation: "Base class for atoms",
_equals: return_true,
_validate: function() {
if (this.TYPE == "Atom") throw new Error("should not instantiate AST_Atom");
},
}, AST_Constant);
var AST_Null = DEFNODE("Null", null, {
$documentation: "The `null` atom",
value: null,
}, AST_Atom);
var AST_NaN = DEFNODE("NaN", null, {
$documentation: "The impossible value",
value: 0/0,
}, AST_Atom);
var AST_Undefined = DEFNODE("Undefined", null, {
$documentation: "The `undefined` value",
value: function(){}(),
}, AST_Atom);
var AST_Hole = DEFNODE("Hole", null, {
$documentation: "A hole in an array",
value: function(){}(),
}, AST_Atom);
var AST_Infinity = DEFNODE("Infinity", null, {
$documentation: "The `Infinity` value",
value: 1/0,
}, AST_Atom);
var AST_Boolean = DEFNODE("Boolean", null, {
$documentation: "Base class for booleans",
_validate: function() {
if (this.TYPE == "Boolean") throw new Error("should not instantiate AST_Boolean");
},
}, AST_Atom);
var AST_False = DEFNODE("False", null, {
$documentation: "The `false` atom",
value: false,
}, AST_Boolean);
var AST_True = DEFNODE("True", null, {
$documentation: "The `true` atom",
value: true,
}, AST_Boolean);
/* -----[ TreeWalker ]----- */
function TreeWalker(callback) {
this.callback = callback;
this.directives = Object.create(null);
this.stack = [];
}
TreeWalker.prototype = {
visit: function(node, descend) {
this.push(node);
var done = this.callback(node, descend || noop);
if (!done && descend) descend();
this.pop();
},
parent: function(n) {
return this.stack[this.stack.length - 2 - (n || 0)];
},
push: function(node) {
var value;
if (node instanceof AST_Class) {
this.directives = Object.create(this.directives);
value = "use strict";
} else if (node instanceof AST_Directive) {
value = node.value;
} else if (node instanceof AST_Lambda) {
this.directives = Object.create(this.directives);
}
if (value && !this.directives[value]) this.directives[value] = node;
this.stack.push(node);
},
pop: function() {
var node = this.stack.pop();
if (node instanceof AST_Class || node instanceof AST_Lambda) {
this.directives = Object.getPrototypeOf(this.directives);
}
},
self: function() {
return this.stack[this.stack.length - 1];
},
find_parent: function(type) {
var stack = this.stack;
for (var i = stack.length - 1; --i >= 0;) {
var x = stack[i];
if (x instanceof type) return x;
}
},
has_directive: function(type) {
var dir = this.directives[type];
if (dir) return dir;
var node = this.stack[this.stack.length - 1];
if (node instanceof AST_Scope) {
for (var i = 0; i < node.body.length; ++i) {
var st = node.body[i];
if (!(st instanceof AST_Directive)) break;
if (st.value == type) return st;
}
}
},
loopcontrol_target: function(node) {
var stack = this.stack;
if (node.label) for (var i = stack.length; --i >= 0;) {
var x = stack[i];
if (x instanceof AST_LabeledStatement && x.label.name == node.label.name)
return x.body;
} else for (var i = stack.length; --i >= 0;) {
var x = stack[i];
if (x instanceof AST_IterationStatement
|| node instanceof AST_Break && x instanceof AST_Switch)
return x;
}
},
in_boolean_context: function() {
for (var drop = true, level = 0, parent, self = this.self(); parent = this.parent(level++); self = parent) {
if (parent instanceof AST_Binary) switch (parent.operator) {
case "&&":
case "||":
if (parent.left === self) drop = false;
continue;
default:
return false;
}
if (parent instanceof AST_Conditional) {
if (parent.condition === self) return true;
continue;
}
if (parent instanceof AST_DWLoop) return parent.condition === self;
if (parent instanceof AST_For) return parent.condition === self;
if (parent instanceof AST_If) return parent.condition === self;
if (parent instanceof AST_Return) {
if (parent.in_bool) return true;
while (parent = this.parent(level++)) {
if (parent instanceof AST_Lambda) {
if (parent.name) return false;
parent = this.parent(level++);
if (parent.TYPE != "Call") return false;
break;
}
}
}
if (parent instanceof AST_Sequence) {
if (parent.tail_node() === self) continue;
return drop ? "d" : true;
}
if (parent instanceof AST_SimpleStatement) return drop ? "d" : true;
if (parent instanceof AST_UnaryPrefix) return parent.operator == "!";
return false;
}
}
};
================================================
FILE: lib/compress.js
================================================
/***********************************************************************
A JavaScript tokenizer / parser / beautifier / compressor.
https://github.com/mishoo/UglifyJS
-------------------------------- (C) ---------------------------------
Author: Mihai Bazon
<mihai.bazon@gmail.com>
http://mihai.bazon.net/blog
Distributed under the BSD license:
Copyright 2012 (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
are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials
provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
***********************************************************************/
"use strict";
function Compressor(options, false_by_default) {
if (!(this instanceof Compressor))
return new Compressor(options, false_by_default);
TreeTransformer.call(this, this.before, this.after);
this.options = defaults(options, {
annotations : !false_by_default,
arguments : !false_by_default,
arrows : !false_by_default,
assignments : !false_by_default,
awaits : !false_by_default,
booleans : !false_by_default,
collapse_vars : !false_by_default,
comparisons : !false_by_default,
conditionals : !false_by_default,
dead_code : !false_by_default,
default_values : !false_by_default,
directives : !false_by_default,
drop_console : false,
drop_debugger : !false_by_default,
evaluate : !false_by_default,
expression : false,
functions : !false_by_default,
global_defs : false,
hoist_exports : !false_by_default,
hoist_funs : false,
hoist_props : !false_by_default,
hoist_vars : false,
ie : false,
if_return : !false_by_default,
imports : !false_by_default,
inline : !false_by_default,
join_vars : !false_by_default,
keep_fargs : false_by_default,
keep_fnames : false,
keep_infinity : false,
loops : !false_by_default,
merge_vars : !false_by_default,
module : false,
negate_iife : !false_by_default,
objects : !false_by_default,
optional_chains : !false_by_default,
passes : 1,
properties : !false_by_default,
pure_funcs : null,
pure_getters : !false_by_default && "strict",
reduce_funcs : !false_by_default,
reduce_vars : !false_by_default,
rests : !false_by_default,
sequences : !false_by_default,
side_effects : !false_by_default,
spreads : !false_by_default,
strings : !false_by_default,
switches : !false_by_default,
templates : !false_by_default,
top_retain : null,
toplevel : !!(options && !options["expression"] && options["top_retain"]),
typeofs : !false_by_default,
unsafe : false,
unsafe_comps : false,
unsafe_Function : false,
unsafe_math : false,
unsafe_proto : false,
unsafe_regexp : false,
unsafe_undefined: false,
unused : !false_by_default,
varify : !false_by_default,
webkit : false,
yields : !false_by_default,
}, true);
var evaluate = this.options["evaluate"];
this.eval_threshold = /eager/.test(evaluate) ? 1 / 0 : +evaluate;
var global_defs = this.options["global_defs"];
if (typeof global_defs == "object") for (var key in global_defs) {
if (/^@/.test(key) && HOP(global_defs, key)) {
global_defs[key.slice(1)] = parse(global_defs[key], { expression: true });
}
}
if (this.options["inline"] === true) this.options["inline"] = 4;
this.drop_fargs = this.options["keep_fargs"] ? return_false : function(lambda, parent) {
if (lambda.length_read) return false;
var name = lambda.name;
if (!name) return parent && parent.TYPE == "Call" && parent.expression === lambda;
if (name.fixed_value() !== lambda) return false;
var def = name.definition();
if (def.direct_access) return false;
var escaped = def.escaped;
return escaped && escaped.depth != 1;
};
if (this.options["module"]) this.directives["use strict"] = true;
var pure_funcs = this.options["pure_funcs"];
if (typeof pure_funcs == "function") {
this.pure_funcs = pure_funcs;
} else if (typeof pure_funcs == "string") {
this.pure_funcs = function(node) {
var expr;
if (node instanceof AST_Call) {
expr = node.expression;
} else if (node instanceof AST_Template) {
expr = node.tag;
}
return !(expr && pure_funcs === expr.print_to_string());
};
} else if (Array.isArray(pure_funcs)) {
this.pure_funcs = function(node) {
var expr;
if (node instanceof AST_Call) {
expr = node.expression;
} else if (node instanceof AST_Template) {
expr = node.tag;
}
return !(expr && member(expr.print_to_string(), pure_funcs));
};
} else {
this.pure_funcs = return_true;
}
var sequences = this.options["sequences"];
this.sequences_limit = sequences == 1 ? 800 : sequences | 0;
var top_retain = this.options["top_retain"];
if (top_retain instanceof RegExp) {
this.top_retain = function(def) {
return top_retain.test(def.name);
};
} else if (typeof top_retain == "function") {
this.top_retain = top_retain;
} else if (top_retain) {
if (typeof top_retain == "string") {
top_retain = top_retain.split(/,/);
}
this.top_retain = function(def) {
return member(def.name, top_retain);
};
}
var toplevel = this.options["toplevel"];
this.toplevel = typeof toplevel == "string" ? {
funcs: /funcs/.test(toplevel),
vars: /vars/.test(toplevel)
} : {
funcs: toplevel,
vars: toplevel
};
}
Compressor.prototype = new TreeTransformer(function(node, descend) {
if (node._squeezed) return node;
var is_scope = node instanceof AST_Scope;
if (is_scope) {
if (this.option("arrows") && is_arrow(node) && node.value) {
node.body = [ node.first_statement() ];
node.value = null;
}
node.hoist_properties(this);
node.hoist_declarations(this);
node.process_returns(this);
}
// Before https://github.com/mishoo/UglifyJS/pull/1602 AST_Node.optimize()
// would call AST_Node.transform() if a different instance of AST_Node is
// produced after OPT().
// This corrupts TreeWalker.stack, which cause AST look-ups to malfunction.
// Migrate and defer all children's AST_Node.transform() to below, which
// will now happen after this parent AST_Node has been properly substituted
// thus gives a consistent AST snapshot.
descend(node, this);
// Existing code relies on how AST_Node.optimize() worked, and omitting the
// following replacement call would result in degraded efficiency of both
// output and performance.
descend(node, this);
var opt = node.optimize(this);
if (is_scope) {
if (opt === node && !this.has_directive("use asm") && !opt.pinned()) {
opt.drop_unused(this);
if (opt.merge_variables(this)) opt.drop_unused(this);
descend(opt, this);
}
if (this.option("arrows") && is_arrow(opt) && opt.body.length == 1) {
var stat = opt.body[0];
if (stat instanceof AST_Return) {
opt.body.length = 0;
opt.value = stat.value;
}
}
}
if (opt === node) opt._squeezed = true;
return opt;
});
Compressor.prototype.option = function(key) {
return this.options[key];
};
Compressor.prototype.exposed = function(def) {
if (def.exported) return true;
if (def.undeclared) return true;
if (!(def.global || def.scope.resolve() instanceof AST_Toplevel)) return false;
var toplevel = this.toplevel;
return !all(def.orig, function(sym) {
return toplevel[sym instanceof AST_SymbolDefun ? "funcs" : "vars"];
});
};
Compressor.prototype.compress = function(node) {
node = node.resolve_defines(this);
node.hoist_exports(this);
if (this.option("expression")) node.process_expression(true);
var merge_vars = this.options.merge_vars;
var passes = +this.options.passes || 1;
var min_count = 1 / 0;
var stopping = false;
var mangle = { ie: this.option("ie") };
for (var pass = 0; pass < passes; pass++) {
node.figure_out_scope(mangle);
if (pass > 0 || this.option("reduce_vars"))
node.reset_opt_flags(this);
this.options.merge_vars = merge_vars && (stopping || pass == passes - 1);
node = node.transform(this);
if (passes > 1) {
var count = 0;
node.walk(new TreeWalker(function() {
count++;
}));
AST_Node.info("pass {pass}: last_count: {min_count}, count: {count}", {
pass: pass,
min_count: min_count,
count: count,
});
if (count < min_count) {
min_count = count;
stopping = false;
} else if (stopping) {
break;
} else {
stopping = true;
}
}
}
if (this.option("expression")) node.process_expression(false);
return node;
};
(function(OPT) {
OPT(AST_Node, function(self) {
return self;
});
AST_Toplevel.DEFMETHOD("hoist_exports", function(compressor) {
if (!compressor.option("hoist_exports")) return;
var body = this.body, props = [];
for (var i = 0; i < body.length; i++) {
var stat = body[i];
if (stat instanceof AST_ExportDeclaration) {
body[i] = stat = stat.body;
if (stat instanceof AST_Definitions) {
stat.definitions.forEach(function(defn) {
defn.name.match_symbol(export_symbol, true);
});
} else {
export_symbol(stat.name);
}
} else if (stat instanceof AST_ExportReferences) {
body.splice(i--, 1);
[].push.apply(props, stat.properties);
}
}
if (props.length) body.push(make_node(AST_ExportReferences, this, { properties: props }));
function export_symbol(sym) {
if (!(sym instanceof AST_SymbolDeclaration)) return;
var node = make_node(AST_SymbolExport, sym);
node.alias = make_node(AST_String, node, { value: node.name });
props.push(node);
}
});
AST_Scope.DEFMETHOD("process_expression", function(insert, transform) {
var self = this;
var tt = new TreeTransformer(function(node) {
if (insert) {
if (node instanceof AST_Directive) node = make_node(AST_SimpleStatement, node, {
body: make_node(AST_String, node),
});
if (node instanceof AST_SimpleStatement) {
return transform ? transform(node) : make_node(AST_Return, node, { value: node.body });
}
} else if (node instanceof AST_Return) {
if (transform) return transform(node);
var value = node.value;
if (value instanceof AST_String) return make_node(AST_Directive, value);
return make_node(AST_SimpleStatement, node, {
body: value || make_node(AST_UnaryPrefix, node, {
operator: "void",
expression: make_node(AST_Number, node, { value: 0 }),
}),
});
}
if (node instanceof AST_Block) {
if (node instanceof AST_Lambda) {
if (node !== self) return node;
} else if (insert === "awaits" && node instanceof AST_Try) {
if (node.bfinally) return node;
}
for (var index = node.body.length; --index >= 0;) {
var stat = node.body[index];
if (!is_declaration(stat, true)) {
node.body[index] = stat.transform(tt);
break;
}
}
} else if (node instanceof AST_If) {
node.body = node.body.transform(tt);
if (node.alternative) node.alternative = node.alternative.transform(tt);
} else if (node instanceof AST_With) {
node.body = node.body.transform(tt);
}
return node;
});
self.transform(tt);
});
AST_Toplevel.DEFMETHOD("unwrap_expression", function() {
var self = this;
switch (self.body.length) {
case 0:
return make_node(AST_UnaryPrefix, self, {
operator: "void",
expression: make_node(AST_Number, self, { value: 0 }),
});
case 1:
var stat = self.body[0];
if (stat instanceof AST_Directive) return make_node(AST_String, stat);
if (stat instanceof AST_SimpleStatement) return stat.body;
default:
return make_node(AST_Call, self, {
expression: make_node(AST_Function, self, {
argnames: [],
body: self.body,
}).init_vars(self, self),
args: [],
});
}
});
AST_Node.DEFMETHOD("wrap_expression", function() {
var self = this;
if (!is_statement(self)) self = make_node(AST_SimpleStatement, self, { body: self });
if (!(self instanceof AST_Toplevel)) self = make_node(AST_Toplevel, self, { body: [ self ] });
return self;
});
function read_property(obj, node) {
var key = node.get_property();
if (key instanceof AST_Node) return;
var value;
if (obj instanceof AST_Array) {
var elements = obj.elements;
if (key == "length") return make_node_from_constant(elements.length, obj);
if (typeof key == "number" && key in elements) value = elements[key];
} else if (obj instanceof AST_Lambda) {
if (key == "length") {
obj.length_read = true;
return make_node_from_constant(obj.argnames.length, obj);
}
} else if (obj instanceof AST_Object) {
key = "" + key;
var props = obj.properties;
for (var i = props.length; --i >= 0;) {
var prop = props[i];
if (!can_hoist_property(prop)) return;
if (!value && props[i].key === key) value = props[i].value;
}
}
return value instanceof AST_SymbolRef && value.fixed_value() || value;
}
function is_read_only_fn(value, name) {
if (value instanceof AST_Boolean) return native_fns.Boolean[name];
if (value instanceof AST_Number) return native_fns.Number[name];
if (value instanceof AST_String) return native_fns.String[name];
if (name == "valueOf") return false;
if (value instanceof AST_Array) return native_fns.Array[name];
if (value instanceof AST_Lambda) return native_fns.Function[name];
if (value instanceof AST_Object) return native_fns.Object[name];
if (value instanceof AST_RegExp) return native_fns.RegExp[name] && !value.value.global;
}
function is_modified(compressor, tw, node, value, level, immutable, recursive) {
var parent = tw.parent(level);
if (compressor.option("unsafe") && parent instanceof AST_Dot && is_read_only_fn(value, parent.property)) {
return;
}
var lhs = is_lhs(node, parent);
if (lhs) return lhs;
if (level == 0 && value && value.is_constant()) return;
if (parent instanceof AST_Array) return is_modified(compressor, tw, parent, parent, level + 1);
if (parent instanceof AST_Assign) switch (parent.operator) {
case "=":
return is_modified(compressor, tw, parent, value, level + 1, immutable, recursive);
case "&&=":
case "||=":
case "??=":
return is_modified(compressor, tw, parent, parent, level + 1);
default:
return;
}
if (parent instanceof AST_Binary) {
if (!lazy_op[parent.operator]) return;
return is_modified(compressor, tw, parent, parent, level + 1);
}
if (parent instanceof AST_Call) {
return !immutable
&& parent.expression === node
&& !parent.is_expr_pure(compressor)
&& (!(value instanceof AST_LambdaExpression) || !(parent instanceof AST_New) && value.contains_this());
}
if (parent instanceof AST_Conditional) {
if (parent.condition === node) return;
return is_modified(compressor, tw, parent, parent, level + 1);
}
if (parent instanceof AST_ForEnumeration) return parent.init === node;
if (parent instanceof AST_ObjectKeyVal) {
if (parent.value !== node) return;
var obj = tw.parent(level + 1);
return is_modified(compressor, tw, obj, obj, level + 2);
}
if (parent instanceof AST_PropAccess) {
if (parent.expression !== node) return;
var prop = read_property(value, parent);
return (!immutable || recursive) && is_modified(compressor, tw, parent, prop, level + 1);
}
if (parent instanceof AST_Sequence) {
if (parent.tail_node() !== node) return;
return is_modified(compressor, tw, parent, value, level + 1, immutable, recursive);
}
}
function is_lambda(node) {
return node instanceof AST_Class || node instanceof AST_Lambda;
}
function safe_for_extends(node) {
return node instanceof AST_Class || node instanceof AST_Defun || node instanceof AST_Function;
}
function is_arguments(def) {
return def.name == "arguments" && def.scope.uses_arguments;
}
function cross_scope(def, sym) {
do {
if (def === sym) return false;
if (sym instanceof AST_Scope) return true;
} while (sym = sym.parent_scope);
}
function can_drop_symbol(ref, compressor, keep_lambda) {
var def = ref.redef || ref.definition();
if (ref.in_arg && is_funarg(def)) return false;
return all(def.orig, function(sym) {
if (sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet) {
if (sym instanceof AST_SymbolImport) return true;
return compressor && safe_from_tdz(compressor, sym);
}
return !(keep_lambda && sym instanceof AST_SymbolLambda);
});
}
function has_escaped(d, scope, node, parent) {
if (parent instanceof AST_Assign) return parent.operator == "=" && parent.right === node;
if (parent instanceof AST_Call) return parent.expression !== node || parent instanceof AST_New;
if (parent instanceof AST_ClassField) return parent.value === node && !parent.static;
if (parent instanceof AST_Exit) return parent.value === node && scope.resolve() !== d.scope.resolve();
if (parent instanceof AST_VarDef) return parent.value === node;
}
function make_ref(ref, fixed) {
var node = make_node(AST_SymbolRef, ref);
node.fixed = fixed || make_node(AST_Undefined, ref);
return node;
}
function replace_ref(resolve, fixed) {
return function(node) {
var ref = resolve(node);
var node = make_ref(ref, fixed);
var def = ref.definition();
def.references.push(node);
def.replaced++;
return node;
};
}
var RE_POSITIVE_INTEGER = /^(0|[1-9][0-9]*)$/;
(function(def) {
def(AST_Node, noop);
function reset_def(tw, compressor, def) {
def.assignments = 0;
def.bool_return = 0;
def.cross_loop = false;
def.direct_access = false;
def.drop_return = 0;
def.escaped = [];
def.first_decl = null;
def.fixed = !def.const_redefs
&& !def.scope.pinned()
&& !compressor.exposed(def)
&& !(def.init instanceof AST_LambdaExpression && def.init !== def.scope)
&& def.init;
def.reassigned = 0;
def.recursive_refs = 0;
def.references = [];
def.single_use = undefined;
}
function reset_block_variables(tw, compressor, scope) {
scope.variables.each(function(def) {
reset_def(tw, compressor, def);
});
}
function reset_variables(tw, compressor, scope) {
scope.fn_defs = [];
scope.variables.each(function(def) {
reset_def(tw, compressor, def);
var init = def.init;
if (init instanceof AST_LambdaDefinition) {
scope.fn_defs.push(init);
init.safe_ids = null;
}
if (def.fixed === null) {
def.safe_ids = tw.safe_ids;
mark(tw, def);
} else if (def.fixed) {
tw.loop_ids[def.id] = tw.in_loop;
gitextract_fobklhdg/
├── .gitattributes
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ └── bug_report.md
│ └── workflows/
│ ├── build.yml
│ ├── ci.yml
│ ├── moz.yml
│ └── ufuzz.yml
├── .gitignore
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── bin/
│ └── uglifyjs
├── lib/
│ ├── ast.js
│ ├── compress.js
│ ├── minify.js
│ ├── mozilla-ast.js
│ ├── output.js
│ ├── parse.js
│ ├── propmangle.js
│ ├── scope.js
│ ├── sourcemap.js
│ ├── transform.js
│ └── utils.js
├── package.json
├── test/
│ ├── benchmark.js
│ ├── compress/
│ │ ├── annotations.js
│ │ ├── arguments.js
│ │ ├── arrays.js
│ │ ├── arrows.js
│ │ ├── asm.js
│ │ ├── assignments.js
│ │ ├── awaits.js
│ │ ├── bigint.js
│ │ ├── blocks.js
│ │ ├── booleans.js
│ │ ├── classes.js
│ │ ├── collapse_vars.js
│ │ ├── comparisons.js
│ │ ├── concat-strings.js
│ │ ├── conditionals.js
│ │ ├── const.js
│ │ ├── dead-code.js
│ │ ├── debugger.js
│ │ ├── default-values.js
│ │ ├── destructured.js
│ │ ├── directives.js
│ │ ├── drop-console.js
│ │ ├── drop-unused.js
│ │ ├── evaluate.js
│ │ ├── exponentiation.js
│ │ ├── exports.js
│ │ ├── functions.js
│ │ ├── global_defs.js
│ │ ├── hoist_props.js
│ │ ├── hoist_vars.js
│ │ ├── html_comments.js
│ │ ├── ie.js
│ │ ├── if_return.js
│ │ ├── imports.js
│ │ ├── indentation.js
│ │ ├── issue-1034.js
│ │ ├── issue-1041.js
│ │ ├── issue-1052.js
│ │ ├── issue-1105.js
│ │ ├── issue-12.js
│ │ ├── issue-1202.js
│ │ ├── issue-126.js
│ │ ├── issue-1261.js
│ │ ├── issue-1275.js
│ │ ├── issue-1321.js
│ │ ├── issue-143.js
│ │ ├── issue-1431.js
│ │ ├── issue-1443.js
│ │ ├── issue-1446.js
│ │ ├── issue-1447.js
│ │ ├── issue-1569.js
│ │ ├── issue-1588.js
│ │ ├── issue-1609.js
│ │ ├── issue-1639.js
│ │ ├── issue-1656.js
│ │ ├── issue-1673.js
│ │ ├── issue-1704.js
│ │ ├── issue-1733.js
│ │ ├── issue-1750.js
│ │ ├── issue-1770.js
│ │ ├── issue-1787.js
│ │ ├── issue-1833.js
│ │ ├── issue-1943.js
│ │ ├── issue-208.js
│ │ ├── issue-22.js
│ │ ├── issue-2652.js
│ │ ├── issue-267.js
│ │ ├── issue-269.js
│ │ ├── issue-2719.js
│ │ ├── issue-281.js
│ │ ├── issue-2871.js
│ │ ├── issue-2989.js
│ │ ├── issue-368.js
│ │ ├── issue-3768.js
│ │ ├── issue-44.js
│ │ ├── issue-5614.js
│ │ ├── issue-59.js
│ │ ├── issue-597.js
│ │ ├── issue-611.js
│ │ ├── issue-637.js
│ │ ├── issue-640.js
│ │ ├── issue-747.js
│ │ ├── issue-751.js
│ │ ├── issue-782.js
│ │ ├── issue-892.js
│ │ ├── issue-913.js
│ │ ├── issue-973.js
│ │ ├── issue-976.js
│ │ ├── issue-979.js
│ │ ├── join_vars.js
│ │ ├── keep_fargs.js
│ │ ├── labels.js
│ │ ├── let.js
│ │ ├── loops.js
│ │ ├── max_line_len.js
│ │ ├── merge_vars.js
│ │ ├── negate-iife.js
│ │ ├── new.js
│ │ ├── node_version.js
│ │ ├── nullish.js
│ │ ├── numbers.js
│ │ ├── objects.js
│ │ ├── optional-chains.js
│ │ ├── preserve_line.js
│ │ ├── properties.js
│ │ ├── pure_funcs.js
│ │ ├── pure_getters.js
│ │ ├── reduce_vars.js
│ │ ├── regexp.js
│ │ ├── rename.js
│ │ ├── rests.js
│ │ ├── return_undefined.js
│ │ ├── sandbox.js
│ │ ├── sequences.js
│ │ ├── side_effects.js
│ │ ├── spreads.js
│ │ ├── string-literal.js
│ │ ├── switches.js
│ │ ├── templates.js
│ │ ├── transform.js
│ │ ├── typeof.js
│ │ ├── unicode.js
│ │ ├── varify.js
│ │ ├── webkit.js
│ │ ├── wrap_iife.js
│ │ └── yields.js
│ ├── compress.js
│ ├── exports.js
│ ├── fetch.js
│ ├── input/
│ │ ├── comments/
│ │ │ └── filter.js
│ │ ├── enclose/
│ │ │ └── input.js
│ │ ├── global_defs/
│ │ │ ├── nested.js
│ │ │ └── simple.js
│ │ ├── invalid/
│ │ │ ├── assign_1.js
│ │ │ ├── assign_2.js
│ │ │ ├── assign_3.js
│ │ │ ├── assign_4.js
│ │ │ ├── assign_5.js
│ │ │ ├── delete.js
│ │ │ ├── destructured_var.js
│ │ │ ├── dot_1.js
│ │ │ ├── dot_2.js
│ │ │ ├── dot_3.js
│ │ │ ├── else.js
│ │ │ ├── eof.js
│ │ │ ├── for-await.js
│ │ │ ├── for-in_1.js
│ │ │ ├── for-in_2.js
│ │ │ ├── for-of_1.js
│ │ │ ├── for-of_2.js
│ │ │ ├── function_1.js
│ │ │ ├── function_2.js
│ │ │ ├── function_3.js
│ │ │ ├── loop-no-body.js
│ │ │ ├── object.js
│ │ │ ├── optional-template.js
│ │ │ ├── return.js
│ │ │ ├── simple.js
│ │ │ ├── switch.js
│ │ │ ├── tab.js
│ │ │ ├── try.js
│ │ │ └── var.js
│ │ ├── issue-1236/
│ │ │ └── simple.js
│ │ ├── issue-1242/
│ │ │ ├── bar.es5
│ │ │ ├── baz.es5
│ │ │ ├── foo.es5
│ │ │ └── qux.js
│ │ ├── issue-1323/
│ │ │ └── sample.js
│ │ ├── issue-1431/
│ │ │ └── sample.js
│ │ ├── issue-1482/
│ │ │ ├── beautify.js
│ │ │ ├── braces.js
│ │ │ ├── default.js
│ │ │ └── input.js
│ │ ├── issue-1632/
│ │ │ └── ^{foo}[bar](baz)+$.js
│ │ ├── issue-2082/
│ │ │ └── sample.js
│ │ ├── issue-2310/
│ │ │ └── input.js
│ │ ├── issue-3040/
│ │ │ ├── expect.js
│ │ │ └── input.js
│ │ ├── issue-3294/
│ │ │ ├── input.js
│ │ │ └── output.js
│ │ ├── issue-3315/
│ │ │ ├── config.json
│ │ │ └── input.js
│ │ ├── issue-3441/
│ │ │ └── input.js
│ │ ├── issue-505/
│ │ │ ├── input.js
│ │ │ └── output.js
│ │ ├── issue-520/
│ │ │ ├── input.js
│ │ │ └── output.js
│ │ ├── module/
│ │ │ ├── expect.js
│ │ │ └── input.js
│ │ ├── reduce/
│ │ │ ├── destructured_assign.js
│ │ │ ├── destructured_assign.reduced.js
│ │ │ ├── destructured_catch.js
│ │ │ ├── destructured_catch.reduced.js
│ │ │ ├── diff_error.js
│ │ │ ├── diff_error.reduced.js
│ │ │ ├── export_default.js
│ │ │ ├── label.js
│ │ │ ├── label.reduced.js
│ │ │ ├── setter.js
│ │ │ ├── setter.reduced.js
│ │ │ ├── unsafe_math.js
│ │ │ └── unsafe_math.reduced.js
│ │ └── rename/
│ │ └── input.js
│ ├── jetstream.js
│ ├── mocha/
│ │ ├── arguments.js
│ │ ├── awaits.js
│ │ ├── bug-report.js
│ │ ├── cli.js
│ │ ├── comments.js
│ │ ├── directives.js
│ │ ├── exports.js
│ │ ├── getter-setter.js
│ │ ├── glob.js
│ │ ├── imports.js
│ │ ├── let.js
│ │ ├── line-endings.js
│ │ ├── minify-file-map.js
│ │ ├── minify.js
│ │ ├── number-literal.js
│ │ ├── operator.js
│ │ ├── parentheses.js
│ │ ├── reduce.js
│ │ ├── sourcemaps.js
│ │ ├── spidermonkey.js
│ │ ├── string-literal.js
│ │ ├── templates.js
│ │ ├── tokens.js
│ │ ├── with.js
│ │ └── yields.js
│ ├── mocha.js
│ ├── mozilla-ast.js
│ ├── node.js
│ ├── reduce.js
│ ├── release/
│ │ ├── acorn.sh
│ │ ├── benchmark.js
│ │ ├── bootstrap.sh
│ │ ├── buble.sh
│ │ ├── butternut.sh
│ │ ├── install.sh
│ │ ├── jetstream.js
│ │ ├── mathjs.sh
│ │ ├── rollup-es.sh
│ │ ├── rollup-ts.sh
│ │ ├── run.js
│ │ ├── sucrase.sh
│ │ └── web-tooling-benchmark.sh
│ ├── sandbox.js
│ └── ufuzz/
│ ├── actions.js
│ ├── index.js
│ ├── job.js
│ └── options.json
└── tools/
├── domprops.html
├── domprops.json
├── exports.js
├── node.js
└── tty.js
Showing preview only (467K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (4236 symbols across 141 files)
FILE: lib/ast.js
function DEFNODE (line 46) | function DEFNODE(type, props, methods, base) {
function log (line 199) | function log(msg) {
function all_equals (line 233) | function all_equals(k, l) {
function list_equals (line 239) | function list_equals(s, t) {
function prop_equals (line 245) | function prop_equals(u, v) {
function is_statement (line 288) | function is_statement(node) {
function validate_expression (line 294) | function validate_expression(value, prop, multiple, allow_spread, allow_...
function must_be_expression (line 307) | function must_be_expression(node, prop) {
function walk_body (line 359) | function walk_body(node, visitor) {
function is_arrow (line 723) | function is_arrow(node) {
function is_async (line 727) | function is_async(node) {
function is_generator (line 735) | function is_generator(node) {
function walk_lambda (line 742) | function walk_lambda(node, tw) {
function must_be_expressions (line 1477) | function must_be_expressions(node, prop, allow_spread, allow_hole) {
function root_expr (line 1542) | function root_expr(prop) {
function validate_destructured (line 1803) | function validate_destructured(node, check, allow_default) {
function TreeWalker (line 2251) | function TreeWalker(callback) {
FILE: lib/compress.js
function Compressor (line 46) | function Compressor(options, false_by_default) {
function export_symbol (line 307) | function export_symbol(sym) {
function read_property (line 388) | function read_property(obj, node) {
function is_read_only_fn (line 413) | function is_read_only_fn(value, name) {
function is_modified (line 424) | function is_modified(compressor, tw, node, value, level, immutable, recu...
function is_lambda (line 474) | function is_lambda(node) {
function safe_for_extends (line 478) | function safe_for_extends(node) {
function is_arguments (line 482) | function is_arguments(def) {
function cross_scope (line 486) | function cross_scope(def, sym) {
function can_drop_symbol (line 493) | function can_drop_symbol(ref, compressor, keep_lambda) {
function has_escaped (line 505) | function has_escaped(d, scope, node, parent) {
function make_ref (line 513) | function make_ref(ref, fixed) {
function replace_ref (line 519) | function replace_ref(resolve, fixed) {
function reset_def (line 534) | function reset_def(tw, compressor, def) {
function reset_block_variables (line 553) | function reset_block_variables(tw, compressor, scope) {
function reset_variables (line 559) | function reset_variables(tw, compressor, scope) {
function safe_to_visit (line 588) | function safe_to_visit(tw, fn) {
function walk_fn_def (line 593) | function walk_fn_def(tw, fn) {
function revisit_fn_def (line 600) | function revisit_fn_def(tw, fn) {
function mark_fn_def (line 621) | function mark_fn_def(tw, def, fn) {
function pop_scope (line 644) | function pop_scope(tw, scope) {
function push (line 658) | function push(tw, sequential, conditional) {
function pop (line 668) | function pop(tw) {
function access (line 673) | function access(tw, def) {
function assign (line 679) | function assign(tw, def) {
function safe_to_access (line 685) | function safe_to_access(tw, def) {
function dot (line 694) | function dot(expr, tw) {
function mark (line 703) | function mark(tw, def) {
function push_ref (line 707) | function push_ref(def, ref) {
function safe_to_read (line 712) | function safe_to_read(tw, def) {
function safe_to_assign (line 738) | function safe_to_assign(tw, def, declare) {
function ref_once (line 773) | function ref_once(compressor, def) {
function is_immutable (line 781) | function is_immutable(value) {
function value_in_use (line 791) | function value_in_use(node, parent) {
function mark_escaped (line 799) | function mark_escaped(tw, d, scope, node, value, level, depth) {
function mark_assignment_to_arguments (line 828) | function mark_assignment_to_arguments(node) {
function make_fixed (line 843) | function make_fixed(save, fn) {
function make_fixed_default (line 855) | function make_fixed_default(compressor, node, save) {
function scan_declaration (line 871) | function scan_declaration(tw, compressor, lhs, fixed, visit) {
function reduce_iife (line 960) | function reduce_iife(tw, descend, compressor) {
function walk_prop (line 1090) | function walk_prop(lhs) {
function walk_assign (line 1113) | function walk_assign() {
function walk_lazy (line 1147) | function walk_lazy() {
function mark_refs (line 1203) | function mark_refs(node, drop) {
function walk_defn (line 1652) | function walk_defn() {
function reset_flags (line 1687) | function reset_flags(node) {
function convert_destructured (line 1742) | function convert_destructured(type, process) {
function convert_symbol (line 1764) | function convert_symbol(type, process) {
function process_to_assign (line 1771) | function process_to_assign(ref) {
function mark_destructured (line 1777) | function mark_destructured(process, tw) {
function mark_symbol (line 1795) | function mark_symbol(process) {
function match_destructured (line 1804) | function match_destructured(predicate, ignore_side_effects) {
function in_async_generator (line 1826) | function in_async_generator(scope) {
function find_scope (line 1830) | function find_scope(compressor) {
function find_try (line 1837) | function find_try(compressor, level, node, scope, may_throw, sync) {
function is_lhs_read_only (line 1851) | function is_lhs_read_only(lhs, compressor) {
function make_node (line 1878) | function make_node(ctor, orig, props) {
function make_sequence (line 1888) | function make_sequence(orig, expressions) {
function make_node_from_constant (line 1893) | function make_node_from_constant(val, orig) {
function needs_unbinding (line 1924) | function needs_unbinding(val) {
function maintain_this_binding (line 1932) | function maintain_this_binding(parent, orig, val) {
function merge_expression (line 1945) | function merge_expression(base, target) {
function merge_sequence (line 1967) | function merge_sequence(array, node) {
function is_direct_assignment (line 1976) | function is_direct_assignment(node, parent) {
function is_lexical_definition (line 1983) | function is_lexical_definition(stat) {
function safe_to_trim (line 1987) | function safe_to_trim(stat) {
function as_statement_array (line 2002) | function as_statement_array(thing) {
function is_empty (line 2010) | function is_empty(thing) {
function has_declarations_only (line 2017) | function has_declarations_only(block) {
function loop_body (line 2025) | function loop_body(x) {
function is_iife_call (line 2032) | function is_iife_call(node) {
function is_iife_single (line 2040) | function is_iife_single(call) {
function is_undeclared_ref (line 2053) | function is_undeclared_ref(node) {
function is_static_field_or_init (line 2064) | function is_static_field_or_init(prop) {
function declarations_only (line 2068) | function declarations_only(node) {
function is_declaration (line 2074) | function is_declaration(stat, lexical) {
function is_last_statement (line 2085) | function is_last_statement(body, stat) {
function patch_for_init (line 2099) | function patch_for_init(node, in_list) {
function tighten_body (line 2119) | function tighten_body(statements, compressor) {
function extract_declarations_from_unreachable_code (line 4589) | function extract_declarations_from_unreachable_code(compressor, stat, ta...
function is_undefined (line 4641) | function is_undefined(node, compressor) {
function binary (line 4700) | function binary(op, left, right) {
function is_strict (line 4756) | function is_strict(compressor, force) {
function is_binary_defined (line 4841) | function is_binary_defined(compressor, op, node) {
function to_node (line 5089) | function to_node(value, orig) {
function warn (line 5109) | function warn(node) {
function best_of_expression (line 5150) | function best_of_expression(ast1, ast2, threshold) {
function best_of_statement (line 5155) | function best_of_statement(ast1, ast2, threshold) {
function best_of (line 5163) | function best_of(compressor, ast1, ast2, threshold) {
function convert_to_predicate (line 5167) | function convert_to_predicate(obj) {
function skip_directives (line 5175) | function skip_directives(body) {
function arrow_first_statement (line 5182) | function arrow_first_statement() {
function try_evaluate (line 5200) | function try_evaluate(compressor, node) {
function is_static_fn (line 5293) | function is_static_fn(node) {
function modified (line 5344) | function modified(node) {
function decimals (line 5584) | function decimals(operand) {
function verify_escaped (line 5596) | function verify_escaped(ref, depth) {
function eval_all (line 5694) | function eval_all(nodes, compressor, ignore_side_effects, cached, depth) {
function assign (line 5796) | function assign(sym, arg) {
function decode (line 5830) | function decode(str) {
function basic_negation (line 5842) | function basic_negation(exp) {
function best (line 5848) | function best(orig, alt, first_in_statement) {
function any (line 6010) | function any(list, compressor, spread) {
function array_spread (line 6017) | function array_spread(node, compressor) {
function any (line 6157) | function any(list, compressor) {
function call_may_throw (line 6164) | function call_may_throw(exp, compressor) {
function all_constant (line 6295) | function all_constant(list, scope) {
function walk_scoped (line 6302) | function walk_scoped(self, scope) {
function aborts (line 6383) | function aborts(thing) {
function block_aborts (line 6389) | function block_aborts() {
function trim_block (line 6457) | function trim_block(node, parent, in_list) {
function drop_rest_farg (line 6475) | function drop_rest_farg(fn, compressor) {
function mark_expression (line 6813) | function mark_expression(exp) {
function walk_cond (line 6819) | function walk_cond(condition, consequent, alternative) {
function scan_branches (line 6835) | function scan_branches(level, condition, consequent, alternative) {
function push (line 6931) | function push() {
function pop (line 6935) | function pop() {
function push_ref (line 6939) | function push_ref(refs, sym) {
function walk_destructured (line 6946) | function walk_destructured(symbol_type, mark, lhs) {
function mark (line 6977) | function mark(sym, read) {
function insert (line 7031) | function insert(target) {
function must_visit (line 7052) | function must_visit(base, segment) {
function mergeable (line 7056) | function mergeable(head, tail) {
function fill_holes (line 7061) | function fill_holes(orig, elements) {
function to_class_expr (line 7067) | function to_class_expr(defcl, drop_name) {
function to_func_expr (line 7073) | function to_func_expr(defun, drop_name) {
function extract_reference (line 7113) | function extract_reference(node, props) {
function compose (line 7137) | function compose(child, level, find) {
function walk_class_prop (line 7289) | function walk_class_prop(value) {
function self_assign (line 7733) | function self_assign(ref) {
function assigned_once (line 7737) | function assigned_once(fn, refs) {
function can_declare_defun (line 7744) | function can_declare_defun(fn) {
function rename_def (line 7753) | function rename_def(fn, name) {
function is_catch (line 7780) | function is_catch(node) {
function flush (line 7785) | function flush() {
function descend_scope (line 7889) | function descend_scope() {
function log (line 7947) | function log(sym, text) {
function log_default (line 7951) | function log_default(node, text) {
function get_rvalue (line 7959) | function get_rvalue(expr) {
function insert_statements (line 7963) | function insert_statements(body, orig, in_list) {
function track_assigns (line 7974) | function track_assigns(def, node) {
function add_assigns (line 7980) | function add_assigns(def, node) {
function indexOf_assign (line 7985) | function indexOf_assign(def, node) {
function unmark_lambda (line 7990) | function unmark_lambda(def) {
function verify_safe_usage (line 7998) | function verify_safe_usage(def, read, modified) {
function can_drop_lhs (line 8009) | function can_drop_lhs(sym, node) {
function get_rhs (line 8017) | function get_rhs(assign) {
function get_init_symbol (line 8030) | function get_init_symbol(for_in) {
function scan_ref_scoped (line 8040) | function scan_ref_scoped(node, descend, init) {
function is_decl (line 8151) | function is_decl(node) {
function trim_decl (line 8155) | function trim_decl(node) {
function trim_default (line 8161) | function trim_default(trimmer, node) {
function trim_destructured (line 8176) | function trim_destructured(node, value, process, drop, root) {
function scan_local_returns (line 8602) | function scan_local_returns(fn, transform) {
function map_self_returns (line 8612) | function map_self_returns(fn) {
function can_trim_returns (line 8625) | function can_trim_returns(def, self_returns, compressor) {
function process_boolean_returns (line 8635) | function process_boolean_returns(fn, compressor) {
function can_trim (line 8718) | function can_trim(def) {
function make_sym (line 8833) | function make_sym(type, sym, key) {
function can_hoist (line 8863) | function can_hoist(sym, right, count) {
function fn_name_unused (line 8884) | function fn_name_unused(fn, compressor) {
function drop_returns (line 8893) | function drop_returns(compressor, exp, ignore_name) {
function trim (line 9015) | function trim(nodes, compressor, first_in_statement, spread) {
function array_spread (line 9034) | function array_spread(node, compressor, first_in_statement) {
function convert_spread (line 9039) | function convert_spread(node) {
function assign_this_only (line 9121) | function assign_this_only(fn, compressor) {
function make_value (line 9245) | function make_value() {
function has_loop_control (line 9432) | function has_loop_control(loop, parent, type) {
function has_block_scope_refs (line 9504) | function has_block_scope_refs(node) {
function if_break_in_loop (line 9517) | function if_break_in_loop(self, compressor) {
function mark_locally_defined (line 9649) | function mark_locally_defined(condition, consequent, alternative) {
function fuzzy_eval (line 9768) | function fuzzy_eval(compressor, node, nullish) {
function mark_duplicate_condition (line 9776) | function mark_duplicate_condition(compressor, node) {
function as_array (line 10065) | function as_array(node) {
function keep_return_void (line 10069) | function keep_return_void() {
function last_index (line 10085) | function last_index(stats) {
function pop_expr (line 10092) | function pop_expr(stats, body, index) {
function sequencesize (line 10103) | function sequencesize(stat, defuns, var_defs, refs) {
function is_break (line 10316) | function is_break(node, tw) {
function no_break (line 10320) | function no_break(node) {
function eliminate_branch (line 10333) | function eliminate_branch(branch, prev) {
function remove_initializers (line 10379) | function remove_initializers(make_value) {
function is_safe_lexical (line 10443) | function is_safe_lexical(def) {
function may_overlap (line 10447) | function may_overlap(compressor, def) {
function to_let (line 10456) | function to_let(stat, scope) {
function to_var (line 10477) | function to_var(stat, scope) {
function safe_from_tdz (line 10533) | function safe_from_tdz(compressor, sym) {
function trim_optional_chain (line 10562) | function trim_optional_chain(node, compressor) {
function lift_sequence_in_expression (line 10578) | function lift_sequence_in_expression(node, compressor) {
function drop_unused_call_args (line 10588) | function drop_unused_call_args(call, compressor, fns_with_marked_args) {
function avoid_await_yield (line 10680) | function avoid_await_yield(compressor, parent_scope) {
function safe_from_await_yield (line 10690) | function safe_from_await_yield(fn, avoid) {
function safe_from_strict_mode (line 10710) | function safe_from_strict_mode(fn, compressor) {
function make_void_lhs (line 11166) | function make_void_lhs(orig) {
function convert_args (line 11173) | function convert_args(value) {
function noop_value (line 11243) | function noop_value() {
function return_value (line 11247) | function return_value(stat) {
function can_flatten_body (line 11258) | function can_flatten_body(stat) {
function resolve_index (line 11291) | function resolve_index(def) {
function can_substitute_directly (line 11297) | function can_substitute_directly() {
function var_exists (line 11370) | function var_exists(defined, name) {
function can_inject_args (line 11374) | function can_inject_args(defined, safe_to_inject) {
function can_inject_vars (line 11386) | function can_inject_vars(defined, safe_to_inject) {
function can_inject_symbols (line 11411) | function can_inject_symbols() {
function append_var (line 11452) | function append_var(decls, expressions, name, value) {
function flatten_args (line 11475) | function flatten_args(decls, expressions) {
function flatten_destructured (line 11528) | function flatten_destructured(decls, expressions) {
function flatten_vars (line 11553) | function flatten_vars(decls, expressions) {
function flatten_fn (line 11602) | function flatten_fn() {
function to_conditional_assignment (line 11645) | function to_conditional_assignment(compressor, def, value, node) {
function filter_for_side_effects (line 11690) | function filter_for_side_effects() {
function trim_right_for_undefined (line 11705) | function trim_right_for_undefined() {
function is_simple_assign (line 11717) | function is_simple_assign(node) {
function merge_assignments (line 11724) | function merge_assignments() {
function may_not_delete (line 11824) | function may_not_delete(node) {
function can_lift (line 11833) | function can_lift() {
function is_object (line 11937) | function is_object(node, plain) {
function can_drop_op (line 11948) | function can_drop_op(node, compressor) {
function needs_enqueuing (line 11963) | function needs_enqueuing(compressor, node) {
function extract_lhs (line 11992) | function extract_lhs(node, compressor) {
function repeatable (line 12001) | function repeatable(compressor, node) {
function swap_chain (line 12010) | function swap_chain(self, compressor) {
function is_modify_array (line 12619) | function is_modify_array(node) {
function align (line 12634) | function align(ref, op) {
function make_binary (line 12645) | function make_binary(op, left, right, orig) {
function is_indexFn (line 12667) | function is_indexFn(node) {
function is_indexOf_match_pattern (line 12674) | function is_indexOf_match_pattern() {
function reversible (line 12694) | function reversible() {
function reverse (line 12701) | function reverse(op) {
function recursive_ref (line 12715) | function recursive_ref(compressor, def, fn) {
function same_scope (line 12723) | function same_scope(def) {
function cross_class (line 12922) | function cross_class(def) {
function has_symbol_ref (line 12930) | function has_symbol_ref(value) {
function is_raw_tag (line 12940) | function is_raw_tag(compressor, tag) {
function decode_template (line 12948) | function decode_template(str) {
function escape_literal (line 13024) | function escape_literal(str) {
function should_join (line 13030) | function should_join(node) {
function is_atomic (line 13040) | function is_atomic(lhs, self) {
function is_reachable (line 13089) | function is_reachable(self, defs) {
function is_tail (line 13222) | function is_tail(node, parent) {
function is_tail_block (line 13253) | function is_tail_block(stat, parent) {
function in_try (line 13261) | function in_try(level, node, sync) {
function make_compound (line 13269) | function make_compound(rhs) {
function strip_assignment (line 13281) | function strip_assignment(def) {
function booleanize (line 13553) | function booleanize(node) {
function is_true (line 13563) | function is_true(node) {
function is_false (line 13574) | function is_false(node) {
function arg_diff (line 13588) | function arg_diff(consequent, alternative) {
function fuse (line 13605) | function fuse(node, tail, prop) {
function is_tail_equivalent (line 13612) | function is_tail_equivalent(consequent, alternative) {
function combine_tail (line 13629) | function combine_tail(consequent, alternative, top) {
function can_shift_lhs_of_tail (line 13648) | function can_shift_lhs_of_tail(node) {
function pop_lhs (line 13654) | function pop_lhs(node) {
function pop_seq (line 13661) | function pop_seq(node) {
function safe_to_flatten (line 13695) | function safe_to_flatten(value, compressor) {
function find_lambda (line 13852) | function find_lambda() {
function has_reassigned (line 13864) | function has_reassigned() {
function can_hoist_property (line 13901) | function can_hoist_property(prop) {
function flush (line 14068) | function flush() {
function process (line 14092) | function process(prop) {
function flatten_var (line 14119) | function flatten_var(name) {
function has_arg_refs (line 14128) | function has_arg_refs(fn, node) {
function insert_assign (line 14139) | function insert_assign(def, assign) {
function init_ref (line 14152) | function init_ref(compressor, name) {
function make_condition (line 14209) | function make_condition(cond) {
function process (line 14457) | function process(sym, argname) {
function make_body (line 14474) | function make_body(value) {
function inline_sequence (line 14552) | function inline_sequence(compressor, scope, no_return, in_loop, in_await...
FILE: lib/minify.js
function read_source_map (line 23) | function read_source_map(name, toplevel) {
function parse_source_map (line 41) | function parse_source_map(content) {
function set_shorthand (line 49) | function set_shorthand(name, options, keys) {
function init_cache (line 59) | function init_cache(cache) {
function to_json (line 68) | function to_json(cache) {
function minify (line 74) | function minify(files, options) {
FILE: lib/mozilla-ast.js
function To_Moz_MethodDefinition (line 732) | function To_Moz_MethodDefinition(kind) {
function To_Moz_ForOfStatement (line 778) | function To_Moz_ForOfStatement(is_await) {
function To_Moz_Literal (line 1079) | function To_Moz_Literal(M) {
function normalize_directives (line 1139) | function normalize_directives(body) {
function raw_token (line 1151) | function raw_token(moznode) {
function my_start_token (line 1157) | function my_start_token(moznode) {
function my_end_token (line 1172) | function my_end_token(moznode) {
function read_name (line 1187) | function read_name(M) {
function map (line 1191) | function map(moztype, mytype, propmap) {
function from_moz (line 1244) | function from_moz(moz) {
function from_moz_alias (line 1255) | function from_moz_alias(moz) {
function set_moz_loc (line 1286) | function set_moz_loc(mynode, moznode) {
function def_to_moz (line 1304) | function def_to_moz(mytype, handler) {
function to_moz (line 1310) | function to_moz(node) {
function to_moz_alias (line 1314) | function to_moz_alias(alias) {
function to_moz_block (line 1321) | function to_moz_block(node) {
function to_moz_scope (line 1328) | function to_moz_scope(type, node) {
FILE: lib/output.js
function is_some_comments (line 46) | function is_some_comments(comment) {
function OutputStream (line 51) | function OutputStream(options) {
function DEFPRINT (line 631) | function DEFPRINT(nodetype, generator) {
function doit (line 647) | function doit() {
function PARENS (line 671) | function PARENS(nodetype, func) {
function needs_parens_function (line 679) | function needs_parens_function(output) {
function needs_parens_obj (line 700) | function needs_parens_obj(output) {
function needs_parens_unary (line 705) | function needs_parens_unary(output) {
function need_chain_parens (line 800) | function need_chain_parens(node, parent) {
function needs_parens_assign_cond (line 858) | function needs_parens_assign_cond(self, output) {
function display_body (line 925) | function display_body(body, is_toplevel, output, allow_directives) {
function print_braced_empty (line 968) | function print_braced_empty(self, output) {
function print_braced (line 975) | function print_braced(self, output, allow_directives) {
function print_for_enum (line 1038) | function print_for_enum(prefix, infix) {
function print_alias (line 1087) | function print_alias(alias, output) {
function print_entry (line 1121) | function print_entry(index) {
function print_funargs (line 1163) | function print_funargs(self, output) {
function print_arrow (line 1176) | function print_arrow(self, output) {
function print_lambda (line 1200) | function print_lambda(self, output) {
function print_async (line 1213) | function print_async(output) {
function print_async_generator (line 1221) | function print_async_generator(output) {
function print_generator (line 1229) | function print_generator(output) {
function print_method (line 1276) | function print_method(self, output) {
function print_jump (line 1301) | function print_jump(kind, prop) {
function make_then (line 1318) | function make_then(self, output) {
function print_branch_body (line 1386) | function print_branch_body(self, output) {
function print_definitions (line 1440) | function print_definitions(type) {
function parenthesize_for_no_in (line 1457) | function parenthesize_for_no_in(node, output, no_in) {
function print_annotation (line 1492) | function print_annotation(self, output) {
function print_call_args (line 1503) | function print_call_args(self, output) {
function print_properties (line 1703) | function print_properties(self, output, no_comma) {
function print_property_key (line 1722) | function print_property_key(self, output) {
function print_accessor (line 1750) | function print_accessor(type) {
function get_symbol_name (line 1765) | function get_symbol_name(sym) {
function force_statement (line 1864) | function force_statement(stat, output) {
function need_constructor_parens (line 1876) | function need_constructor_parens(self, output) {
function best_of (line 1883) | function best_of(a) {
function make_num (line 1894) | function make_num(num) {
function make_block (line 1918) | function make_block(stmt, output) {
function DEFMAP (line 1933) | function DEFMAP(nodetype, generator) {
FILE: lib/parse.js
function is_surrogate_pair_head (line 138) | function is_surrogate_pair_head(code) {
function is_surrogate_pair_tail (line 142) | function is_surrogate_pair_tail(code) {
function is_digit (line 146) | function is_digit(code) {
function is_identifier_char (line 150) | function is_identifier_char(ch) {
function is_identifier_string (line 154) | function is_identifier_string(str) {
function decode_escape_sequence (line 158) | function decode_escape_sequence(seq) {
function parse_js_number (line 195) | function parse_js_number(num) {
function JS_Parse_Error (line 204) | function JS_Parse_Error(message, filename, line, col, pos) {
function js_error (line 219) | function js_error(message, filename, line, col, pos) {
function is_token (line 223) | function is_token(token, type, val) {
function tokenizer (line 229) | function tokenizer($TEXT, filename, html5_comments, shebang) {
function parse (line 686) | function parse($TEXT, options) {
FILE: lib/propmangle.js
function get_builtins (line 46) | function get_builtins() {
function reserve_quoted_keys (line 125) | function reserve_quoted_keys(ast, reserved) {
function addStrings (line 147) | function addStrings(node, add) {
function mangle_properties (line 158) | function mangle_properties(ast, options) {
FILE: lib/scope.js
function SymbolDef (line 46) | function SymbolDef(id, scope, orig, init) {
function is_funarg (line 119) | function is_funarg(def) {
function is_lhs (line 125) | function is_lhs(node, parent) {
function walk_scope (line 244) | function walk_scope(descend) {
function is_arguments (line 398) | function is_arguments(sym) {
function redefine (line 404) | function redefine(node, scope) {
function init_block_vars (line 447) | function init_block_vars(scope, parent, orig) {
function init_scope_vars (line 461) | function init_scope_vars(scope, parent, orig) {
function names_in_use (line 542) | function names_in_use(scope, options) {
function next_mangled_name (line 559) | function next_mangled_name(def, options) {
function _default_mangler_options (line 605) | function _default_mangler_options(options) {
function mangle (line 707) | function mangle(def) {
function defer_redef (line 712) | function defer_redef(def) {
function in_label (line 740) | function in_label(tw) {
function to_avoid (line 759) | function to_avoid(name) {
function add_def (line 763) | function add_def(def) {
function next_name (line 782) | function next_name() {
function rename (line 790) | function rename(def) {
function skip_string (line 832) | function skip_string(node) {
function init (line 846) | function init(chars) {
function reset (line 858) | function reset() {
function compare (line 867) | function compare(a, b) {
function base54 (line 875) | function base54(num) {
FILE: lib/sourcemap.js
function vlq_decode (line 52) | function vlq_decode(indices, str) {
function vlq_encode (line 68) | function vlq_encode(num) {
function create_array_map (line 79) | function create_array_map() {
function SourceMap (line 94) | function SourceMap(options) {
FILE: lib/transform.js
function TreeTransformer (line 46) | function TreeTransformer(before, after) {
function do_list (line 54) | function do_list(list, tw) {
function transform_arrow (line 139) | function transform_arrow(self, tw) {
FILE: lib/utils.js
function characters (line 46) | function characters(str) {
function member (line 50) | function member(name, array) {
function find_if (line 54) | function find_if(func, array) {
function configure_error_stack (line 58) | function configure_error_stack(ex, cause) {
function DefaultsError (line 81) | function DefaultsError(msg, defs) {
function defaults (line 94) | function defaults(args, defs, croak) {
function noop (line 104) | function noop() {}
function return_false (line 105) | function return_false() { return false; }
function return_true (line 106) | function return_true() { return true; }
function return_this (line 107) | function return_this() { return this; }
function return_null (line 108) | function return_null() { return null; }
function List (line 111) | function List(a, f) {
function Splice (line 131) | function Splice(val) {
function push_uniq (line 137) | function push_uniq(array, el) {
function string_template (line 141) | function string_template(text, props) {
function remove (line 150) | function remove(array, el) {
function makePredicate (line 155) | function makePredicate(words) {
function all (line 164) | function all(array, predicate) {
function Dictionary (line 171) | function Dictionary() {
function HOP (line 249) | function HOP(obj, prop) {
function first_in_statement (line 256) | function first_in_statement(stack, arrow, export_default) {
function DEF_BITPROPS (line 284) | function DEF_BITPROPS(ctor, props) {
FILE: test/benchmark.js
function done (line 29) | function done() {
FILE: test/compress.js
function evaluate (line 54) | function evaluate(code) {
function log (line 59) | function log() {
function make_code (line 63) | function make_code(ast, options, expression) {
function parse_test (line 70) | function parse_test(file) {
function reminify (line 193) | function reminify(expression, orig_options, input_code, input_formatted,...
function run_code (line 269) | function run_code(expression, code, toplevel) {
function test_case (line 273) | function test_case(test) {
function tmpl (line 467) | function tmpl() {
function to_toplevel (line 471) | function to_toplevel(input, mangle_options, expression) {
FILE: test/compress/arguments.js
function e (line 511) | function e() {
function e (line 523) | function e() {
function e (line 551) | function e() {
function e (line 563) | function e(argument_0) {
function e (line 592) | function e() {
function e (line 609) | function e() {
function e (line 639) | function e() {
function e (line 656) | function e(argument_0) {
method p (line 836) | get p() {
method p (line 844) | get p() {
FILE: test/compress/arrays.js
function f0 (line 144) | function f0() {
function f1 (line 151) | function f1() {
function f2 (line 158) | function f2() {
function f0 (line 167) | function f0() {
function f1 (line 174) | function f1() {
function f2 (line 181) | function f2() {
FILE: test/compress/arrows.js
function f (line 39) | async function f() {
function f (line 657) | function f() {
function log (line 852) | function log() {
function log (line 861) | function log() {
FILE: test/compress/asm.js
function asm_GeometricMean (line 25) | function asm_GeometricMean(stdlib, foreign, buffer) {
function no_asm_GeometricMean (line 47) | function no_asm_GeometricMean(stdlib, foreign, buffer) {
function asm_GeometricMean (line 70) | function asm_GeometricMean(stdlib, foreign, buffer) {
function no_asm_GeometricMean (line 90) | function no_asm_GeometricMean(stdlib, foreign, buffer) {
function f (line 111) | function f() {
function f (line 130) | function f() {
function a (line 147) | function a() {
function b (line 152) | function b() {
function n (line 172) | function n(stdlib, foreign, buffer) {
function n (line 186) | function n(o, e, u) {
function add (line 207) | function add(x, y) {
function r (line 221) | function r(n, o) {
FILE: test/compress/assignments.js
function f (line 301) | function f(a) {
function g (line 306) | function g(b) {
function f (line 316) | function f(a) {
function g (line 319) | function g(b) {
function p (line 338) | function p(o) {
function p (line 348) | function p(o) {
function p (line 366) | function p(o) {
function p (line 376) | function p(o) {
function f (line 458) | function f() {
function f (line 467) | function f() {
function f (line 485) | function f() {
function f (line 494) | function f() {
function f (line 733) | function f(c) {
FILE: test/compress/awaits.js
method [42] (line 17) | async [42]() {
method then (line 48) | then(resolve) {
method then (line 61) | then(resolve) {
function await (line 77) | async function await() {
function await (line 83) | async function await() {
function await (line 103) | async function await() {
function await (line 125) | async function await() {
function await (line 131) | async function await() {
function f (line 166) | async function f(a) {
function await (line 205) | function await() {
function await (line 215) | function await() {
function f (line 237) | async function f() {
function f (line 265) | async function f() {
function f (line 289) | async function f(a) {
function f (line 317) | async function f(a) {
function f (line 343) | async function f(a, b) {
function f (line 370) | async function f(a, b) {
method f (line 395) | async f() {
method f (line 404) | async f() {
method then (line 461) | then(r) {
method then (line 476) | then(r) {
method then (line 581) | then(r) {
method then (line 596) | then(r) {
method then (line 666) | then(r) {
method then (line 681) | then(r) {
function f (line 706) | function f() {
function f (line 721) | function f() {
function f (line 745) | function f() {
function f (line 760) | function f() {
function f (line 784) | function f() {
function f (line 799) | function f() {
function f (line 850) | function f() {
function f (line 865) | function f() {
method f (line 962) | async f() {
function a (line 1220) | async function a() {
function b (line 1223) | async function b() {
function c (line 1226) | async function c(c) {
function a (line 1278) | async function a() {
function b (line 1281) | async function b() {
function c (line 1284) | async function c(c) {
function await (line 1317) | async function await() {
function await (line 1341) | function await() {
function await (line 1465) | function await() {}
function await (line 1473) | function await() {}
function f (line 1637) | async function f() {
function f (line 1646) | async function f() {
function f (line 1778) | async function f() {}
function f (line 1786) | async function f() {}
function f (line 1851) | function f(a) {
function f (line 1859) | function f(a) {
function f (line 1879) | function f(a) {
function f (line 1887) | function f(a) {
function f (line 1969) | async function f() {}
function f (line 1973) | async function f() {}
function f (line 2018) | async function f() {
method then (line 2050) | then() {
method then (line 2059) | then() {
method then (line 2077) | get then() {
method then (line 2086) | get then() {
function f (line 2131) | async function f() {
method then (line 2159) | then() {
method then (line 2168) | then() {
method then (line 2185) | get then() {
method then (line 2192) | get then() {
method then (line 2209) | then() {
method then (line 2218) | then() {
function f (line 2631) | async function f() {
function f (line 2643) | async function f() {
method p (line 2798) | p(await) {}
method p (line 2807) | p(await) {}
function f (line 2878) | function f() {
function f (line 2889) | function f() {
method then (line 3078) | get then() {
method then (line 3091) | get then() {
method then (line 3274) | then() {
method then (line 3290) | then() {
method then (line 3320) | then(resolve) {
method then (line 3339) | then(resolve) {
method then (line 3372) | then(resolve) {
method then (line 3390) | then(resolve) {
method then (line 3421) | then(resolve) {
method then (line 3440) | then(resolve) {
method then (line 3473) | then(resolve) {
method then (line 3491) | then(resolve) {
method then (line 3522) | then(resolve) {
method then (line 3541) | then(resolve) {
method then (line 3574) | then(resolve) {
method then (line 3592) | then(resolve) {
function f (line 3680) | async function f() {
function g (line 3694) | async function g() {
method then (line 3710) | then(resolve) {
FILE: test/compress/blocks.js
function a (line 55) | function a() {}
function a (line 63) | function a() {}
function a (line 76) | function a() {}
function a (line 85) | function a() {}
FILE: test/compress/booleans.js
function f (line 37) | function f(a) {
function f (line 43) | function f(a) {
function f (line 56) | function f(a) {
function f (line 62) | function f(a) {
function f (line 88) | function f(a) {
function f (line 94) | function f(a) {
function f (line 107) | function f(a) {
function f (line 113) | function f(a) {
function f (line 130) | function f(a, b) {
function f (line 137) | function f(a, b) {
function f (line 155) | function f(a, b) {
function f (line 162) | function f(a, b) {
function f (line 180) | function f(a, b) {
function f (line 187) | function f(a, b) {
function f (line 205) | function f(a, b) {
function f (line 212) | function f(a, b) {
function f (line 231) | function f(a, b) {
function f (line 238) | function f(a, b) {
function f (line 256) | function f(a, b) {
function f (line 263) | function f(a, b) {
function f (line 281) | function f(a, b, c) {
function f (line 288) | function f(a, b, c) {
function f (line 307) | function f(a, b, c) {
function f (line 314) | function f(a, b, c) {
function f (line 333) | function f(a, b, c) {
function f (line 340) | function f(a, b, c) {
function f (line 358) | function f(a, b, c) {
function f (line 365) | function f(a, b, c) {
function f (line 383) | function f(a, b, c) {
function f (line 390) | function f(a, b, c) {
function f (line 409) | function f(a, b, c) {
function f (line 416) | function f(a, b, c) {
function f (line 435) | function f(a, b, c) {
function f (line 442) | function f(a, b, c) {
function f (line 460) | function f(a, b, c) {
function f (line 467) | function f(a, b, c) {
function f (line 486) | function f(a, b) {
function f (line 492) | function f(a, b) {
function f (line 695) | function f(a) {
FILE: test/compress/classes.js
method constructor (line 5) | constructor(a) {
method "constructor" (line 19) | "constructor"(a) {
method ["constructor"] (line 33) | ["constructor"](a) {
class A (line 46) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method q (line 65) | q() {
class A (line 101) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method #f (line 124) | static *#f() {
method #g (line 127) | async #g() {
method #p (line 131) | static get #p() {
method q (line 134) | get q() {
class A (line 191) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class B (line 209) | class B extends A {
method p (line 210) | static get p() {
method q (line 213) | static get q() {
method constructor (line 216) | constructor() {
method p (line 221) | get p() {
method q (line 224) | get q() {
method #g (line 2445) | #g() {
method h (line 2448) | h() {
method #o (line 2465) | #o() {
method e (line 2468) | e() {
class A (line 246) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 263) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 281) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 300) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 320) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 336) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 543) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class B (line 546) | class B {}
method p (line 210) | static get p() {
method q (line 213) | static get q() {
method constructor (line 216) | constructor() {
method p (line 221) | get p() {
method q (line 224) | get q() {
method #g (line 2445) | #g() {
method h (line 2448) | h() {
method #o (line 2465) | #o() {
method e (line 2468) | e() {
class A (line 554) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class B (line 557) | class B {}
method p (line 210) | static get p() {
method q (line 213) | static get q() {
method constructor (line 216) | constructor() {
method p (line 221) | get p() {
method q (line 224) | get q() {
method #g (line 2445) | #g() {
method h (line 2448) | h() {
method #o (line 2465) | #o() {
method e (line 2468) | e() {
class a (line 575) | class a {}
class a (line 587) | class a {}
class A (line 613) | class A extends f {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 643) | class A extends 42 {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 685) | class A extends Function {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 728) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 738) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method p (line 758) | static get p() {
method p (line 766) | static get p() {
method p (line 783) | static set p(v) {
method p (line 791) | static set p(v) {
class A (line 808) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 834) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 858) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 877) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method f (line 887) | f(a) {
class A (line 904) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method f (line 914) | f() {
method f (line 933) | f() {
method f (line 941) | f() {
function f (line 956) | function f() {
class A (line 961) | class A extends f {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function f (line 971) | function f() {
class A (line 976) | class A extends f {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1001) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method [(console.log("foo"), "f")] (line 1002) | [(console.log("foo"), "f")]() {
class A (line 1011) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method [(console.log("foo"), "f")] (line 1012) | [(console.log("foo"), "f")]() {
class A (line 1036) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method foo (line 1045) | static foo() {}
class A (line 1060) | class A extends class B {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method f (line 1070) | f() {
class A (line 1086) | class A extends class B {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method f (line 1095) | f() {
class A (line 1134) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1142) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1159) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1167) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function f (line 1184) | function f(a) {
class A (line 1187) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function f (line 1195) | function f(a) {
method g (line 1199) | g() {
class A (line 1218) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1243) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method [a.log("PASS")] (line 1244) | [a.log("PASS")]() {
class A (line 1269) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method [a.log("PASS")] (line 1270) | static [a.log("PASS")]() {
class A (line 1294) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1320) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1347) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1367) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method [console.log(yield)] (line 1368) | static [console.log(yield)]() {}
class Foo (line 1397) | class Foo {}
class Foo (line 1402) | class Foo {}
class A (line 1434) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1452) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1458) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1474) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1480) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1494) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1500) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function f (line 1517) | function f() {}
class A (line 1518) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function f (line 1525) | function f() {}
class A (line 1526) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function f (line 1544) | function f() {}
function f (line 1552) | function f() {}
class A (line 1571) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class B (line 1572) | class B {
method p (line 210) | static get p() {
method q (line 213) | static get q() {
method constructor (line 216) | constructor() {
method p (line 221) | get p() {
method q (line 224) | get q() {
method #g (line 2445) | #g() {
method h (line 2448) | h() {
method #o (line 2465) | #o() {
method e (line 2468) | e() {
class A (line 1579) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class B (line 1580) | class B {
method p (line 210) | static get p() {
method q (line 213) | static get q() {
method constructor (line 216) | constructor() {
method p (line 221) | get p() {
method q (line 224) | get q() {
method #g (line 2445) | #g() {
method h (line 2448) | h() {
method #o (line 2465) | #o() {
method e (line 2468) | e() {
function f (line 1625) | function f() {}
class A (line 1626) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 1633) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function f (line 1651) | function f() {}
class A (line 1677) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class B (line 1678) | class B {
method p (line 210) | static get p() {
method q (line 213) | static get q() {
method constructor (line 216) | constructor() {
method p (line 221) | get p() {
method q (line 224) | get q() {
method #g (line 2445) | #g() {
method h (line 2448) | h() {
method #o (line 2465) | #o() {
method e (line 2468) | e() {
class B (line 1685) | class B {
method p (line 210) | static get p() {
method q (line 213) | static get q() {
method constructor (line 216) | constructor() {
method p (line 221) | get p() {
method q (line 224) | get q() {
method #g (line 2445) | #g() {
method h (line 2448) | h() {
method #o (line 2465) | #o() {
method e (line 2468) | e() {
class unused (line 1769) | class unused {}
class A (line 1798) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method f (line 1843) | f() {
method f (line 1854) | f() {
method f (line 1874) | f() {
method f (line 1888) | f() {
method f (line 1911) | f() {
method f (line 1921) | f() {
method f (line 1940) | f() {
method f (line 1953) | f() {
class A (line 1976) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method [console.log("PASS")] (line 1983) | [console.log("PASS")]() {}
class A (line 2000) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2021) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2027) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method [a = "bar"] (line 2045) | [a = "bar"]() {}
method [a = "bar"] (line 2056) | [a = "bar"]() {}
method f (line 2145) | f() {
method f (line 2155) | f() {
method f (line 2174) | f() {
method f (line 2184) | f() {
method constructor (line 2196) | constructor() {
method constructor (line 2203) | constructor() {
class A (line 2219) | class A extends 42 {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2250) | class A extends 42 {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2282) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2306) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2329) | class A extends { f() {} }.f {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2337) | class A extends [ () => {} ][0] {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2353) | class A extends {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2365) | class A extends {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2386) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2402) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2436) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class B (line 2443) | class B {
method p (line 210) | static get p() {
method q (line 213) | static get q() {
method constructor (line 216) | constructor() {
method p (line 221) | get p() {
method q (line 224) | get q() {
method #g (line 2445) | #g() {
method h (line 2448) | h() {
method #o (line 2465) | #o() {
method e (line 2468) | e() {
class A (line 2456) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class B (line 2463) | class B {
method p (line 210) | static get p() {
method q (line 213) | static get q() {
method constructor (line 216) | constructor() {
method p (line 221) | get p() {
method q (line 224) | get q() {
method #g (line 2445) | #g() {
method h (line 2448) | h() {
method #o (line 2465) | #o() {
method e (line 2468) | e() {
function f (line 2497) | function f(a) {
function f (line 2517) | function f(a) {
class A (line 2550) | class A {}
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
class A (line 2563) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
method constructor (line 2575) | constructor() {
method #f (line 2578) | async#f() {
function f (line 2598) | function f() {
class A (line 2601) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function f (line 2608) | function f() {
function f (line 2631) | function f() {
class A (line 2634) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function f (line 2658) | function f() {
class A (line 2662) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function h (line 2690) | function h() {
class A (line 2693) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function h (line 2700) | function h() {
function h (line 2723) | function h() {
class A (line 2726) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 1188) | g() {
method [(a++, 0)] (line 1348) | [(a++, 0)]() {}
method f (line 2329) | f() {}
method f (line 2354) | f() {
method f (line 2366) | f() {
method Q (line 2388) | static get Q() {
method #p (line 2391) | #p(n) {
method q (line 2394) | set q(v) {
method t (line 2404) | static get t() {
method #s (line 2407) | #s(t) {
method q (line 2410) | set q(t) {
method f (line 2439) | f() {
method o (line 2459) | o() {
method p (line 2861) | get p() {}
method constructor (line 3134) | constructor() {
method constructor (line 3147) | constructor() {
method q (line 3172) | q() {}
method q (line 3183) | q() {}
method q (line 3206) | q() {}
method q (line 3218) | q() {}
method q (line 3239) | q() {}
method q (line 3250) | q() {}
method q (line 3274) | q() {}
method p (line 3418) | static p() {
method foo (line 3921) | foo() {}
method o (line 3931) | o() {}
method ["foo"] (line 3949) | ["foo"]() {}
method ["o"] (line 3959) | ["o"]() {}
method f (line 4134) | f() {}
method f (line 4142) | f() {}
method instanceof (line 4200) | instanceof() {}
function h (line 2751) | function h() {
class A (line 2755) | class A {
method constructor (line 47) | static constructor(a) {
method f (line 102) | static f() {
method g (line 105) | *g() {
method p (line 192) | static get p() {
method q (line 195) | static get q() {
method constructor (line 198) | constructor() {
method p (line 202) | get p() {
method q (line 205) | get q() {
method p (line 614) | get p() {}
method constructor (line 729) | constructor(v) {
method constructor (line 739) | constructor(v) {
method f (line 878) | f(a) {
method f (line 905) | f() {
method f (line 962) | f() {
method f (line 977) | f() {
method foo (line 1037) | static foo() {}
method f (line 1061) | f() {
method f (line 1087) | f() {
method g (line 11
Condensed preview — 280 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (4,353K chars).
[
{
"path": ".gitattributes",
"chars": 20,
"preview": "*.js text eol=lf\n"
},
{
"path": ".github/ISSUE_TEMPLATE/bug_report.md",
"chars": 1536,
"preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n<!-- Note: sub-o"
},
{
"path": ".github/workflows/build.yml",
"chars": 1474,
"preview": "name: Build testing\non:\n pull_request:\n push:\n branches: [ master ]\njobs:\n ufuzz:\n strategy:\n fail-fast: f"
},
{
"path": ".github/workflows/ci.yml",
"chars": 994,
"preview": "name: CI\non:\n pull_request:\n push:\n branches: [ master ]\njobs:\n test:\n strategy:\n matrix:\n node: [ "
},
{
"path": ".github/workflows/moz.yml",
"chars": 335,
"preview": "name: ESTree\non:\n pull_request:\n push:\n branches: [ master ]\njobs:\n test:\n name: fuzzing\n runs-on: ubuntu-la"
},
{
"path": ".github/workflows/ufuzz.yml",
"chars": 1105,
"preview": "name: Fuzzing\non:\n pull_request:\n schedule:\n - cron: '*/15 * * * *'\n workflow_dispatch:\n workflow_run:\n branch"
},
{
"path": ".gitignore",
"chars": 35,
"preview": "/node_modules/\n/npm-debug.log\ntmp/\n"
},
{
"path": "CONTRIBUTING.md",
"chars": 1553,
"preview": "Contributing\n============\n\n## Documentation\n\nEvery new feature and API change should be accompanied by a README addition"
},
{
"path": "LICENSE",
"chars": 1344,
"preview": "UglifyJS is released under the BSD license:\n\nCopyright 2012-2024 (c) Mihai Bazon <mihai.bazon@gmail.com>\n\nRedistribution"
},
{
"path": "README.md",
"chars": 57831,
"preview": "UglifyJS 3\n==========\n\nUglifyJS is a JavaScript parser, minifier, compressor and beautifier toolkit.\n\n#### Note:\n- `ugli"
},
{
"path": "bin/uglifyjs",
"chars": 24455,
"preview": "#! /usr/bin/env node\n// -*- js -*-\n\n\"use strict\";\n\nrequire(\"../tools/tty\");\n\nvar fs = require(\"fs\");\nvar info = require("
},
{
"path": "lib/ast.js",
"chars": 84295,
"preview": "/***********************************************************************\n\n A JavaScript tokenizer / parser / beautifier"
},
{
"path": "lib/compress.js",
"chars": 655110,
"preview": "/***********************************************************************\n\n A JavaScript tokenizer / parser / beautifier"
},
{
"path": "lib/minify.js",
"chars": 11419,
"preview": "\"use strict\";\n\nvar to_ascii, to_base64;\nif (typeof Buffer == \"undefined\") {\n to_ascii = atob;\n to_base64 = btoa;\n}"
},
{
"path": "lib/mozilla-ast.js",
"chars": 46795,
"preview": "/***********************************************************************\n\n A JavaScript tokenizer / parser / beautifier"
},
{
"path": "lib/output.js",
"chars": 67721,
"preview": "/***********************************************************************\n\n A JavaScript tokenizer / parser / beautifier"
},
{
"path": "lib/parse.js",
"chars": 84305,
"preview": "/***********************************************************************\n\n A JavaScript tokenizer / parser / beautifier"
},
{
"path": "lib/propmangle.js",
"chars": 12276,
"preview": "/***********************************************************************\n\n A JavaScript tokenizer / parser / beautifier"
},
{
"path": "lib/scope.js",
"chars": 31693,
"preview": "/***********************************************************************\n\n A JavaScript tokenizer / parser / beautifier"
},
{
"path": "lib/sourcemap.js",
"chars": 7053,
"preview": "/***********************************************************************\n\n A JavaScript tokenizer / parser / beautifier"
},
{
"path": "lib/transform.js",
"chars": 9624,
"preview": "/***********************************************************************\n\n A JavaScript tokenizer / parser / beautifier"
},
{
"path": "lib/utils.js",
"chars": 9357,
"preview": "/***********************************************************************\n\n A JavaScript tokenizer / parser / beautifier"
},
{
"path": "package.json",
"chars": 1068,
"preview": "{\n \"name\": \"uglify-js\",\n \"description\": \"JavaScript parser, mangler/compressor and beautifier toolkit\",\n \"author\": \"M"
},
{
"path": "test/benchmark.js",
"chars": 3384,
"preview": "#! /usr/bin/env node\n// -*- js -*-\n\n\"use strict\";\n\nrequire(\"../tools/tty\");\nvar createHash = require(\"crypto\").createHas"
},
{
"path": "test/compress/annotations.js",
"chars": 10184,
"preview": "issue_2629_1: {\n options = {\n annotations: true,\n side_effects: true,\n }\n beautify = {\n co"
},
{
"path": "test/compress/arguments.js",
"chars": 23058,
"preview": "replace_index: {\n options = {\n arguments: true,\n evaluate: true,\n properties: true,\n }\n in"
},
{
"path": "test/compress/arrays.js",
"chars": 11122,
"preview": "holes_and_undefined: {\n input: {\n w = [1,,];\n x = [1, 2, undefined];\n y = [1, , 2, ];\n z "
},
{
"path": "test/compress/arrows.js",
"chars": 27455,
"preview": "no_funarg: {\n input: {\n (() => console.log(42))();\n }\n expect_exact: \"(()=>console.log(42))();\"\n expe"
},
{
"path": "test/compress/asm.js",
"chars": 6486,
"preview": "asm_mixed: {\n options = {\n assignments: true,\n booleans: true,\n comparisons: true,\n condi"
},
{
"path": "test/compress/assignments.js",
"chars": 16462,
"preview": "op_equals_left_local_var: {\n options = {\n assignments: true,\n evaluate: true,\n }\n input: {\n "
},
{
"path": "test/compress/awaits.js",
"chars": 79898,
"preview": "async_arrow: {\n input: {\n (async a => console.log(a))(\"PASS\");\n console.log(typeof (async () => 42)());"
},
{
"path": "test/compress/bigint.js",
"chars": 2092,
"preview": "arithmetic: {\n input: {\n console.log(((1n + 0x2n) * (0o3n - -4n)) >> (5n - 6n));\n }\n expect_exact: \"cons"
},
{
"path": "test/compress/blocks.js",
"chars": 1437,
"preview": "remove_blocks: {\n input: {\n {;}\n foo();\n {};\n {\n {};\n };\n bar();"
},
{
"path": "test/compress/booleans.js",
"chars": 19809,
"preview": "iife_boolean_context: {\n options = {\n booleans: true,\n evaluate: true,\n }\n input: {\n conso"
},
{
"path": "test/compress/classes.js",
"chars": 86266,
"preview": "constructor_1: {\n input: {\n \"use strict\";\n console.log(new class {\n constructor(a) {\n "
},
{
"path": "test/compress/collapse_vars.js",
"chars": 220464,
"preview": "collapse_vars_side_effects_1: {\n options = {\n booleans: true,\n collapse_vars: true,\n comparisons"
},
{
"path": "test/compress/comparisons.js",
"chars": 14260,
"preview": "comparisons: {\n options = {\n comparisons: true,\n }\n input: {\n var obj1, obj2;\n var result1"
},
{
"path": "test/compress/concat-strings.js",
"chars": 7170,
"preview": "concat_1: {\n options = {\n evaluate: true,\n }\n input: {\n var a = \"foo\" + \"bar\" + x() + \"moo\" + \"fo"
},
{
"path": "test/compress/conditionals.js",
"chars": 66792,
"preview": "ifs_1: {\n options = {\n conditionals: true,\n }\n input: {\n if (foo) bar();\n if (!foo); else "
},
{
"path": "test/compress/const.js",
"chars": 42698,
"preview": "mangle_block: {\n mangle = {\n toplevel: false,\n }\n input: {\n var o = \"PASS\";\n {\n "
},
{
"path": "test/compress/dead-code.js",
"chars": 35633,
"preview": "dead_code_1: {\n options = {\n dead_code: true,\n }\n input: {\n function f() {\n a();\n "
},
{
"path": "test/compress/debugger.js",
"chars": 319,
"preview": "keep_debugger: {\n options = {\n drop_debugger: false,\n }\n input: {\n debugger;\n }\n expect: {\n"
},
{
"path": "test/compress/default-values.js",
"chars": 62584,
"preview": "arrow_1: {\n input: {\n console.log(((a = \"PASS\") => a)());\n }\n expect_exact: 'console.log(((a=\"PASS\")=>a)"
},
{
"path": "test/compress/destructured.js",
"chars": 83256,
"preview": "redefine_arguments_1: {\n options = {\n toplevel: false,\n unused: true,\n }\n input: {\n functi"
},
{
"path": "test/compress/directives.js",
"chars": 3287,
"preview": "simple_statement_is_not_a_directive: {\n input: {\n \"use strict\"\n .split(\" \")\n .forEach(fu"
},
{
"path": "test/compress/drop-console.js",
"chars": 514,
"preview": "drop_console_1: {\n options = {}\n input: {\n console.log('foo');\n console.log.apply(console, arguments"
},
{
"path": "test/compress/drop-unused.js",
"chars": 75741,
"preview": "unused_funarg_1: {\n options = {\n keep_fargs: false,\n unused: true,\n }\n input: {\n console.l"
},
{
"path": "test/compress/evaluate.js",
"chars": 72590,
"preview": "and: {\n options = {\n evaluate: true,\n side_effects: true,\n }\n input: {\n var a;\n // "
},
{
"path": "test/compress/exponentiation.js",
"chars": 3051,
"preview": "precedence_1: {\n input: {\n console.log(-4 ** 3 ** 2);\n }\n expect_exact: \"console.log((-4)**3**2);\"\n e"
},
{
"path": "test/compress/exports.js",
"chars": 11775,
"preview": "refs: {\n input: {\n export {};\n export { a, b as B, c as case, d as default };\n }\n expect_exact: \""
},
{
"path": "test/compress/functions.js",
"chars": 191471,
"preview": "non_ascii_function_identifier_name: {\n input: {\n function fooλ(δλ) {}\n function λ(δλ) {}\n (funct"
},
{
"path": "test/compress/global_defs.js",
"chars": 4645,
"preview": "must_replace: {\n options = {\n global_defs: {\n D: \"foo bar\",\n },\n }\n input: {\n c"
},
{
"path": "test/compress/hoist_props.js",
"chars": 24284,
"preview": "issue_2377_1: {\n options = {\n evaluate: true,\n hoist_props: true,\n inline: true,\n reduce_"
},
{
"path": "test/compress/hoist_vars.js",
"chars": 16787,
"preview": "statements: {\n options = {\n hoist_funs: false,\n hoist_vars: true,\n join_vars: true,\n unus"
},
{
"path": "test/compress/html_comments.js",
"chars": 2854,
"preview": "html_comment_in_expression: {\n input: {\n (function(a, b) {\n console.log(a < !--b && a-- > b, a, b);"
},
{
"path": "test/compress/ie.js",
"chars": 71815,
"preview": "do_screw: {\n options = {\n ie: false,\n }\n beautify = {\n ie: false,\n ascii_only: true,\n }"
},
{
"path": "test/compress/if_return.js",
"chars": 49547,
"preview": "if_return_1: {\n options = {\n booleans: true,\n comparisons: true,\n conditionals: true,\n de"
},
{
"path": "test/compress/imports.js",
"chars": 5382,
"preview": "nought: {\n input: {\n import \"foo\";\n }\n expect_exact: 'import\"foo\";'\n}\n\ndefault_only: {\n input: {\n "
},
{
"path": "test/compress/indentation.js",
"chars": 1853,
"preview": "numeric: {\n beautify = {\n beautify: true,\n indent_start: 1,\n indent_level: 3,\n }\n input: {"
},
{
"path": "test/compress/issue-1034.js",
"chars": 8719,
"preview": "non_hoisted_function_after_return: {\n options = {\n booleans: true,\n comparisons: true,\n conditio"
},
{
"path": "test/compress/issue-1041.js",
"chars": 480,
"preview": "const_pragma: {\n options = {\n evaluate: true,\n reduce_funcs: true,\n reduce_vars: true,\n }\n\n "
},
{
"path": "test/compress/issue-1052.js",
"chars": 3281,
"preview": "multiple_functions: {\n options = {\n hoist_funs: false,\n if_return: true,\n }\n input: {\n (fu"
},
{
"path": "test/compress/issue-1105.js",
"chars": 7190,
"preview": "with_in_global_scope: {\n options = {\n unused: true,\n }\n input: {\n var o = 42;\n with(o) {\n "
},
{
"path": "test/compress/issue-12.js",
"chars": 1478,
"preview": "keep_name_of_getter: {\n options = {\n unused: true,\n }\n input: {\n a = {\n get foo() {},\n"
},
{
"path": "test/compress/issue-1202.js",
"chars": 981,
"preview": "mangle_keep_fnames_false: {\n options = {\n keep_fargs: true,\n keep_fnames: true,\n }\n mangle = {\n "
},
{
"path": "test/compress/issue-126.js",
"chars": 839,
"preview": "concatenate_rhs_strings: {\n options = {\n evaluate: true,\n unsafe: true,\n }\n input: {\n foo("
},
{
"path": "test/compress/issue-1261.js",
"chars": 7194,
"preview": "pure_function_calls: {\n options = {\n annotations: true,\n booleans: true,\n comparisons: true,\n "
},
{
"path": "test/compress/issue-1275.js",
"chars": 1309,
"preview": "string_plus_optimization: {\n options = {\n booleans: true,\n comparisons: true,\n conditionals: tru"
},
{
"path": "test/compress/issue-1321.js",
"chars": 1253,
"preview": "issue_1321_no_debug: {\n mangle = {\n properties: {\n domprops: true,\n keep_quoted: true,\n "
},
{
"path": "test/compress/issue-143.js",
"chars": 1392,
"preview": "/**\n * There was an incorrect sort behavior documented in issue #143:\n * (x = f(…)) <= x → x >= (x = f(…))\n *\n * For exa"
},
{
"path": "test/compress/issue-1431.js",
"chars": 3264,
"preview": "level_zero: {\n options = {\n keep_fnames: true,\n }\n mangle = {\n keep_fnames: true\n }\n input:"
},
{
"path": "test/compress/issue-1443.js",
"chars": 1282,
"preview": "// tests assume that variable `undefined` not redefined and has `void 0` as value\n\nunsafe_undefined: {\n options = {\n "
},
{
"path": "test/compress/issue-1446.js",
"chars": 1808,
"preview": "typeof_eq_undefined: {\n options = {\n comparisons: true,\n typeofs: true,\n }\n input: {\n var "
},
{
"path": "test/compress/issue-1447.js",
"chars": 910,
"preview": "else_with_empty_block: {\n options = {}\n input: {\n if (x)\n yes();\n else {\n }\n }\n"
},
{
"path": "test/compress/issue-1569.js",
"chars": 345,
"preview": "inner_reference: {\n options = {\n side_effects: true,\n }\n input: {\n !function f(a) {\n r"
},
{
"path": "test/compress/issue-1588.js",
"chars": 1721,
"preview": "screw_ie8: {\n options = {\n ie: false,\n }\n mangle = {\n ie: false,\n }\n input: {\n try {"
},
{
"path": "test/compress/issue-1609.js",
"chars": 1671,
"preview": "chained_evaluation_1: {\n options = {\n collapse_vars: true,\n evaluate: true,\n reduce_funcs: true,"
},
{
"path": "test/compress/issue-1639.js",
"chars": 1695,
"preview": "issue_1639_1: {\n options = {\n booleans: true,\n collapse_vars: true,\n conditionals: true,\n "
},
{
"path": "test/compress/issue-1656.js",
"chars": 932,
"preview": "f7: {\n options = {\n booleans: true,\n collapse_vars: true,\n comparisons: true,\n conditiona"
},
{
"path": "test/compress/issue-1673.js",
"chars": 3258,
"preview": "side_effects_catch: {\n options = {\n reduce_funcs: true,\n reduce_vars: true,\n side_effects: true,"
},
{
"path": "test/compress/issue-1704.js",
"chars": 9275,
"preview": "mangle_catch: {\n options = {\n ie: false,\n toplevel: false,\n }\n mangle = {\n ie: false,\n "
},
{
"path": "test/compress/issue-1733.js",
"chars": 2177,
"preview": "function_iife_catch: {\n mangle = {\n ie: false,\n }\n input: {\n function f(n) {\n !functio"
},
{
"path": "test/compress/issue-1750.js",
"chars": 945,
"preview": "case_1: {\n options = {\n dead_code: true,\n evaluate: true,\n switches: true,\n }\n input: {\n "
},
{
"path": "test/compress/issue-1770.js",
"chars": 5783,
"preview": "mangle_props: {\n mangle = {\n properties: true,\n }\n input: {\n var obj = {\n undefined: 1"
},
{
"path": "test/compress/issue-1787.js",
"chars": 344,
"preview": "unary_prefix: {\n options = {\n evaluate: true,\n inline: true,\n reduce_funcs: true,\n reduce"
},
{
"path": "test/compress/issue-1833.js",
"chars": 2431,
"preview": "iife_for: {\n options = {\n negate_iife: true,\n reduce_funcs: true,\n reduce_vars: true,\n to"
},
{
"path": "test/compress/issue-1943.js",
"chars": 378,
"preview": "operator: {\n input: {\n a. //comment\n typeof\n }\n expect_exact: \"a.typeof;\"\n}\n\nname: {\n input: {"
},
{
"path": "test/compress/issue-208.js",
"chars": 1502,
"preview": "do_not_update_lhs: {\n options = {\n global_defs: {\n DEBUG: 0,\n },\n }\n input: {\n "
},
{
"path": "test/compress/issue-22.js",
"chars": 348,
"preview": "return_with_no_value_in_if_body: {\n options = {\n conditionals: true,\n }\n input: {\n function foo(b"
},
{
"path": "test/compress/issue-2652.js",
"chars": 477,
"preview": "insert_semicolon: {\n beautify = {\n beautify: true,\n comments: \"all\",\n }\n input: {\n var a\n "
},
{
"path": "test/compress/issue-267.js",
"chars": 210,
"preview": "issue_267: {\n options = {\n comparisons: true,\n }\n input: {\n x = a % b / b * c * 2;\n x = a "
},
{
"path": "test/compress/issue-269.js",
"chars": 2028,
"preview": "issue_269_1: {\n options = {\n unsafe: true,\n }\n input: {\n var x = {};\n console.log(\n "
},
{
"path": "test/compress/issue-2719.js",
"chars": 827,
"preview": "warn: {\n options = {\n evaluate: true,\n inline: true,\n passes: 2,\n properties: true,\n "
},
{
"path": "test/compress/issue-281.js",
"chars": 10248,
"preview": "collapse_vars_constants: {\n options = {\n collapse_vars: true,\n evaluate: true,\n inline: true,\n "
},
{
"path": "test/compress/issue-2871.js",
"chars": 651,
"preview": "comparison_with_undefined: {\n options = {\n comparisons: true,\n }\n input: {\n a == undefined;\n "
},
{
"path": "test/compress/issue-2989.js",
"chars": 413,
"preview": "inline_script_off: {\n beautify = {\n inline_script: false,\n }\n input: {\n console.log(\"</sCrIpT>\");"
},
{
"path": "test/compress/issue-368.js",
"chars": 1337,
"preview": "collapse: {\n options = {\n collapse_vars: true,\n sequences: true,\n side_effects: true,\n un"
},
{
"path": "test/compress/issue-3768.js",
"chars": 2862,
"preview": "mangle: {\n mangle = {\n toplevel: true,\n }\n input: {\n var e = eval, x = 42;\n (function() {\n"
},
{
"path": "test/compress/issue-44.js",
"chars": 625,
"preview": "issue_44_valid_ast_1: {\n options = {\n unused: true,\n }\n input: {\n function a(b) {\n for"
},
{
"path": "test/compress/issue-5614.js",
"chars": 4107,
"preview": "record_update: {\n options = {\n loops: true,\n passes: 3,\n pure_getters: \"strict\",\n reduce_"
},
{
"path": "test/compress/issue-59.js",
"chars": 551,
"preview": "keep_continue: {\n options = {\n dead_code: true,\n evaluate: true,\n }\n input: {\n while (a) {"
},
{
"path": "test/compress/issue-597.js",
"chars": 3241,
"preview": "NaN_and_Infinity_must_have_parens: {\n options = {}\n input: {\n Infinity.toString();\n NaN.toString();\n"
},
{
"path": "test/compress/issue-611.js",
"chars": 325,
"preview": "issue_611: {\n options = {\n sequences: true,\n side_effects: true,\n }\n input: {\n define(function() {"
},
{
"path": "test/compress/issue-637.js",
"chars": 355,
"preview": "wrongly_optimized: {\n options = {\n booleans: true,\n conditionals: true,\n evaluate: true,\n }\n "
},
{
"path": "test/compress/issue-640.js",
"chars": 7302,
"preview": "cond_5: {\n options = {\n conditionals: true,\n expression: true,\n }\n input: {\n if (some_cond"
},
{
"path": "test/compress/issue-747.js",
"chars": 1236,
"preview": "dont_reuse_prop: {\n mangle = {\n properties: {\n domprops: true,\n regex: /asd/,\n },"
},
{
"path": "test/compress/issue-751.js",
"chars": 557,
"preview": "negate_booleans_1: {\n options = {\n comparisons: true,\n }\n input: {\n var a = !a || !b || !c || !d "
},
{
"path": "test/compress/issue-782.js",
"chars": 943,
"preview": "remove_sequence: {\n options = {\n side_effects: true,\n }\n input: {\n (0, 1, eval)();\n (0, 1,"
},
{
"path": "test/compress/issue-892.js",
"chars": 807,
"preview": "dont_mangle_arguments: {\n options = {\n booleans: true,\n comparisons: true,\n conditionals: true,\n"
},
{
"path": "test/compress/issue-913.js",
"chars": 400,
"preview": "keep_var_for_in: {\n options = {\n hoist_vars: true,\n join_vars: true,\n unused: true,\n }\n in"
},
{
"path": "test/compress/issue-973.js",
"chars": 3416,
"preview": "this_binding_conditionals: {\n options = {\n conditionals: true,\n evaluate: true,\n side_effects: t"
},
{
"path": "test/compress/issue-976.js",
"chars": 3755,
"preview": "eval_collapse_vars: {\n options = {\n booleans: true,\n collapse_vars: true,\n comparisons: true,\n "
},
{
"path": "test/compress/issue-979.js",
"chars": 2166,
"preview": "reported: {\n options = {\n booleans: true,\n comparisons: true,\n conditionals: true,\n dead_"
},
{
"path": "test/compress/join_vars.js",
"chars": 29903,
"preview": "join_vars_assign: {\n options = {\n join_vars: true,\n unused: true,\n }\n input: {\n var y, x;\n"
},
{
"path": "test/compress/keep_fargs.js",
"chars": 29135,
"preview": "keep_fargs_false: {\n options = {\n keep_fargs: false,\n unused: true,\n }\n input: {\n console."
},
{
"path": "test/compress/labels.js",
"chars": 7981,
"preview": "labels_1: {\n options = {\n conditionals: true,\n dead_code: true,\n if_return: true,\n unused"
},
{
"path": "test/compress/let.js",
"chars": 48574,
"preview": "retain_block_1: {\n options = {}\n input: {\n \"use strict\";\n {\n let a = \"FAIL\";\n }\n "
},
{
"path": "test/compress/loops.js",
"chars": 25438,
"preview": "while_becomes_for: {\n options = {\n loops: true,\n }\n input: {\n while (foo()) bar();\n }\n expe"
},
{
"path": "test/compress/max_line_len.js",
"chars": 1641,
"preview": "too_short: {\n beautify = {\n max_line_len: 10,\n }\n input: {\n function f(a) {\n return { "
},
{
"path": "test/compress/merge_vars.js",
"chars": 75825,
"preview": "merge: {\n options = {\n merge_vars: true,\n toplevel: false,\n }\n input: {\n var a = \"foo\";\n "
},
{
"path": "test/compress/negate-iife.js",
"chars": 9954,
"preview": "negate_iife_1: {\n options = {\n negate_iife: true,\n }\n input: {\n (function(){ stuff() })();\n }\n"
},
{
"path": "test/compress/new.js",
"chars": 3025,
"preview": "new_statement: {\n input: {\n new x(1);\n new x(1)(2);\n new x(1)(2)(3);\n new new x(1);\n "
},
{
"path": "test/compress/node_version.js",
"chars": 728,
"preview": "eval_let_6: {\n input: {\n eval(\"let a;\");\n console.log();\n }\n expect: {\n eval(\"let a;\");\n "
},
{
"path": "test/compress/nullish.js",
"chars": 7568,
"preview": "parentheses: {\n input: {\n (console.log(\"foo\") || console.log(\"bar\") ?? console.log(\"baz\")) && console.log(\"moo"
},
{
"path": "test/compress/numbers.js",
"chars": 31398,
"preview": "literal_infinity: {\n input: {\n console.log(2e308, -1e2345);\n }\n expect_exact: \"console.log(1/0,-(1/0));\""
},
{
"path": "test/compress/objects.js",
"chars": 10678,
"preview": "duplicate_key: {\n options = {\n objects: true,\n side_effects: true,\n }\n input: {\n var o = {"
},
{
"path": "test/compress/optional-chains.js",
"chars": 13683,
"preview": "call: {\n input: {\n console.log?.(undefined?.(console.log(\"FAIL\")));\n }\n expect_exact: 'console.log?.((vo"
},
{
"path": "test/compress/preserve_line.js",
"chars": 3721,
"preview": "return_1: {\n beautify = {\n beautify: false,\n preserve_line: true,\n }\n input: {\n console.lo"
},
{
"path": "test/compress/properties.js",
"chars": 56570,
"preview": "keep_properties: {\n options = {\n evaluate: true,\n properties: false,\n }\n input: {\n a[\"foo\""
},
{
"path": "test/compress/pure_funcs.js",
"chars": 8427,
"preview": "array: {\n options = {\n pure_funcs: [ \"Math.floor\" ],\n side_effects: true,\n }\n input: {\n va"
},
{
"path": "test/compress/pure_getters.js",
"chars": 35837,
"preview": "strict: {\n options = {\n pure_getters: \"strict\",\n reduce_funcs: false,\n reduce_vars: false,\n "
},
{
"path": "test/compress/reduce_vars.js",
"chars": 171964,
"preview": "reduce_vars: {\n options = {\n conditionals: true,\n evaluate: true,\n global_defs: {\n C:"
},
{
"path": "test/compress/regexp.js",
"chars": 10786,
"preview": "regexp_simple: {\n input: {\n /rx/ig\n }\n expect_exact: \"/rx/gi;\"\n}\n\nregexp_slashes: {\n input: {\n "
},
{
"path": "test/compress/rename.js",
"chars": 16400,
"preview": "mangle_catch: {\n rename = true\n options = {\n ie: false,\n toplevel: false,\n }\n mangle = {\n "
},
{
"path": "test/compress/rests.js",
"chars": 32997,
"preview": "arrow_1: {\n input: {\n console.log.apply(console, ((...a) => a)(\"PASS\", 42));\n }\n expect_exact: 'console."
},
{
"path": "test/compress/return_undefined.js",
"chars": 2973,
"preview": "return_undefined: {\n options = {\n booleans: true,\n comparisons: true,\n conditionals: true,\n "
},
{
"path": "test/compress/sandbox.js",
"chars": 4373,
"preview": "console_log: {\n input: {\n console.log(\"%% %s\");\n console.log(\"%% %s\", \"%s\");\n }\n expect: {\n "
},
{
"path": "test/compress/sequences.js",
"chars": 27326,
"preview": "make_sequences_1: {\n options = {\n sequences: true,\n }\n input: {\n foo();\n bar();\n ba"
},
{
"path": "test/compress/side_effects.js",
"chars": 19894,
"preview": "accessor: {\n options = {\n side_effects: true,\n }\n input: {\n ({\n get a() {},\n "
},
{
"path": "test/compress/spreads.js",
"chars": 24191,
"preview": "decimal: {\n input: {\n console.log({... 0.42});\n }\n expect_exact: \"console.log({....42});\"\n expect_std"
},
{
"path": "test/compress/string-literal.js",
"chars": 669,
"preview": "octal_escape_sequence: {\n input: {\n var boundaries = \"\\0\\7\\00\\07\\70\\77\\000\\077\\300\\377\";\n var border_ch"
},
{
"path": "test/compress/switches.js",
"chars": 33688,
"preview": "constant_switch_1: {\n options = {\n conditionals: true,\n dead_code: true,\n evaluate: true,\n "
},
{
"path": "test/compress/templates.js",
"chars": 17584,
"preview": "simple: {\n input: {\n console.log(`foo\n bar\\nbaz`);\n }\n expect_exact: \"console.log(`foo\\n b"
},
{
"path": "test/compress/transform.js",
"chars": 2386,
"preview": "booleans_evaluate: {\n options = {\n booleans: true,\n evaluate: true,\n }\n input: {\n console."
},
{
"path": "test/compress/typeof.js",
"chars": 17454,
"preview": "typeof_evaluation: {\n options = {\n evaluate: true,\n typeofs: true,\n }\n input: {\n a = typeo"
},
{
"path": "test/compress/unicode.js",
"chars": 8043,
"preview": "ascii_only_false: {\n options = {}\n beautify = {\n ascii_only: false,\n }\n input: {\n console.log("
},
{
"path": "test/compress/varify.js",
"chars": 17131,
"preview": "reduce_merge_const: {\n options = {\n merge_vars: true,\n reduce_vars: true,\n toplevel: true,\n "
},
{
"path": "test/compress/webkit.js",
"chars": 6102,
"preview": "lambda_call_dot_assign: {\n beautify = {\n webkit: false,\n }\n input: {\n console.log(function() {\n "
},
{
"path": "test/compress/wrap_iife.js",
"chars": 954,
"preview": "wrap_iife: {\n options = {\n negate_iife: false,\n }\n beautify = {\n wrap_iife: true,\n }\n input"
},
{
"path": "test/compress/yields.js",
"chars": 49763,
"preview": "binary: {\n input: {\n var a = function*() {\n console.log(6 * (yield \"PA\" + \"SS\"));\n }();\n "
},
{
"path": "test/compress.js",
"chars": 17988,
"preview": "\"use strict\";\n\nrequire(\"../tools/tty\");\n\nvar assert = require(\"assert\");\nvar child_process = require(\"child_process\");\nv"
},
{
"path": "test/exports.js",
"chars": 638,
"preview": "exports[\"Compressor\"] = Compressor;\nexports[\"defaults\"] = defaults;\nexports[\"is_statement\"] = is_statement;\nexports[\"JS_"
},
{
"path": "test/fetch.js",
"chars": 885,
"preview": "var fs = require(\"fs\");\nvar parse = require(\"url\").parse;\nvar path = require(\"path\");\n\ntry {\n fs.mkdirSync(\"./tmp\");\n"
},
{
"path": "test/input/comments/filter.js",
"chars": 28,
"preview": "// foo\n/*@preserve*/\n// bar\n"
},
{
"path": "test/input/enclose/input.js",
"chars": 67,
"preview": "function enclose() {\n console.log(\"test enclose\");\n}\nenclose();\n"
},
{
"path": "test/input/global_defs/nested.js",
"chars": 23,
"preview": "console.log(C.V, C.D);\n"
},
{
"path": "test/input/global_defs/simple.js",
"chars": 16,
"preview": "console.log(D);\n"
},
{
"path": "test/input/invalid/assign_1.js",
"chars": 23,
"preview": "console.log(1 || 5--);\n"
},
{
"path": "test/input/invalid/assign_2.js",
"chars": 40,
"preview": "console.log(2 || (Math.random() /= 2));\n"
},
{
"path": "test/input/invalid/assign_3.js",
"chars": 26,
"preview": "console.log(3 || ++this);\n"
},
{
"path": "test/input/invalid/assign_4.js",
"chars": 30,
"preview": "console.log(4 || (null = 4));\n"
},
{
"path": "test/input/invalid/assign_5.js",
"chars": 37,
"preview": "console.log(5 || ([]?.length ^= 5));\n"
},
{
"path": "test/input/invalid/delete.js",
"chars": 185,
"preview": "function f(x) {\n delete 42;\n delete (0, x);\n delete null;\n delete x;\n}\n\nfunction g(x) {\n \"use strict\";\n "
},
{
"path": "test/input/invalid/destructured_var.js",
"chars": 101,
"preview": "function f() {\n var { eval } = null;\n}\n\nfunction g() {\n \"use strict\";\n var { eval } = 42;\n}\n"
},
{
"path": "test/input/invalid/dot_1.js",
"chars": 4,
"preview": "a.=\n"
},
{
"path": "test/input/invalid/dot_2.js",
"chars": 5,
"preview": "%.a;\n"
},
{
"path": "test/input/invalid/dot_3.js",
"chars": 7,
"preview": "a./();\n"
},
{
"path": "test/input/invalid/else.js",
"chars": 15,
"preview": "if (0) else 1;\n"
},
{
"path": "test/input/invalid/eof.js",
"chars": 10,
"preview": "foo, bar(\n"
},
{
"path": "test/input/invalid/for-await.js",
"chars": 32,
"preview": "for await (; console.log(42););\n"
},
{
"path": "test/input/invalid/for-in_1.js",
"chars": 68,
"preview": "var a, b = [1, 2];\nfor (1, 2, a in b) {\n console.log(a, b[a]);\n}\n"
},
{
"path": "test/input/invalid/for-in_2.js",
"chars": 66,
"preview": "var c = [1, 2];\nfor (var a, b in c) {\n console.log(a, c[a]);\n}\n"
},
{
"path": "test/input/invalid/for-of_1.js",
"chars": 55,
"preview": "var a = [ 1 ], b;\nfor (b = 2 of a)\n console.log(b);\n"
},
{
"path": "test/input/invalid/for-of_2.js",
"chars": 56,
"preview": "var a = [ 1 ];\nfor (var b = 2 of a)\n console.log(b);\n"
},
{
"path": "test/input/invalid/function_1.js",
"chars": 71,
"preview": "function f(arguments) {\n}\n\nfunction g(arguments) {\n \"use strict\";\n}\n"
},
{
"path": "test/input/invalid/function_2.js",
"chars": 64,
"preview": "function arguments() {\n}\n\nfunction eval() {\n \"use strict\";\n}\n"
},
{
"path": "test/input/invalid/function_3.js",
"chars": 72,
"preview": "!function eval() {\n}();\n\n!function arguments() {\n \"use strict\";\n}();\n"
},
{
"path": "test/input/invalid/loop-no-body.js",
"chars": 29,
"preview": "for (var i = 0; i < 1; i++) \n"
},
{
"path": "test/input/invalid/object.js",
"chars": 21,
"preview": "console.log({%: 1});\n"
},
{
"path": "test/input/invalid/optional-template.js",
"chars": 16,
"preview": "console?.log``;\n"
},
{
"path": "test/input/invalid/return.js",
"chars": 11,
"preview": "return 42;\n"
},
{
"path": "test/input/invalid/simple.js",
"chars": 15,
"preview": "function f(a{}\n"
},
{
"path": "test/input/invalid/switch.js",
"chars": 37,
"preview": "switch (0) {\n default:\n default:\n}\n"
},
{
"path": "test/input/invalid/tab.js",
"chars": 19,
"preview": "\t\tfoo(\txyz, 0abc);\n"
},
{
"path": "test/input/invalid/try.js",
"chars": 107,
"preview": "function f() {\n try {} catch (eval) {}\n}\n\nfunction g() {\n \"use strict\";\n try {} catch (eval) {}\n}\n"
},
{
"path": "test/input/invalid/var.js",
"chars": 81,
"preview": "function f() {\n var eval;\n}\n\nfunction g() {\n \"use strict\";\n var eval;\n}\n"
},
{
"path": "test/input/issue-1236/simple.js",
"chars": 128,
"preview": "\"use strict\";\n\nvar foo = function foo(x) {\n return \"foo \" + x;\n};\nconsole.log(foo(\"bar\"));\n\n//# sourceMappingURL=simple"
},
{
"path": "test/input/issue-1242/bar.es5",
"chars": 69,
"preview": "function bar(x) {\n var triple = x * (2 + 1);\n return triple;\n}\n"
},
{
"path": "test/input/issue-1242/baz.es5",
"chars": 59,
"preview": "function baz(x) {\n var half = x / 2;\n return half;\n}\n"
},
{
"path": "test/input/issue-1242/foo.es5",
"chars": 108,
"preview": "var print = console.log.bind(console);\nfunction foo(x) {\n var twice = x * 2;\n print('Foo:', twice);\n}\n"
},
{
"path": "test/input/issue-1242/qux.js",
"chars": 76,
"preview": "var x = bar(1+2);\nvar y = baz(3+9);\nprint('q' + 'u' + 'x', x, y);\nfoo(5+6);\n"
},
{
"path": "test/input/issue-1323/sample.js",
"chars": 97,
"preview": "var bar = (function() {\n function foo (bar) {\n return bar;\n }\n\n return foo;\n})();"
},
{
"path": "test/input/issue-1431/sample.js",
"chars": 202,
"preview": "function f(x) {\n return function() {\n function n(a) {\n return a * a;\n }\n return x(n);"
},
{
"path": "test/input/issue-1482/beautify.js",
"chars": 430,
"preview": "if (x) foo();\n\nif (x) foo(); else baz();\n\nif (x) foo(); else if (y) bar(); else baz();\n\nif (x) if (y) foo(); else bar();"
},
{
"path": "test/input/issue-1482/braces.js",
"chars": 798,
"preview": "if (x) {\n foo();\n}\n\nif (x) {\n foo();\n} else {\n baz();\n}\n\nif (x) {\n foo();\n} else if (y) {\n bar();\n} else "
},
{
"path": "test/input/issue-1482/default.js",
"chars": 340,
"preview": "if(x)foo();if(x)foo();else baz();if(x)foo();else if(y)bar();else baz();if(x)if(y)foo();else bar();else baz();if(x)foo();"
},
{
"path": "test/input/issue-1482/input.js",
"chars": 405,
"preview": "if (x) foo();\nif (x) foo(); else baz();\nif (x) foo(); else if (y) bar(); else baz();\nif (x) if (y) foo(); else bar(); el"
},
{
"path": "test/input/issue-1632/^{foo}[bar](baz)+$.js",
"chars": 15,
"preview": "console.log(x);"
},
{
"path": "test/input/issue-2082/sample.js",
"chars": 15,
"preview": "console.log(x);"
},
{
"path": "test/input/issue-2310/input.js",
"chars": 128,
"preview": "function foo() {\n return function() {\n console.log(\"PASS\");\n };\n}\n\n(function() {\n var f = foo();\n f()"
}
]
// ... and 80 more files (download for full content)
About this extraction
This page contains the full source code of the mishoo/UglifyJS GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 280 files (3.9 MB), approximately 1.0M tokens, and a symbol index with 4236 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.