UglifyJS is a JavaScript parser, minifier, compressor or beautifier toolkit.

This page documents the command line utility. For API and internals documentation see my website. There's also an in-browser online demo (for Firefox, Chrome and probably Safari).

Note:

• uglify-js only supports ECMAScript 5 (ES5).

• Support for const is , and may not be

  transformed properly.

• Those wishing to minify ES2015+ (ES6+) should use the npm package .

Install

First make sure you have installed the latest version of (You may need to restart your computer after this step).

From NPM for use as a command line app:

From NPM for programmatic use:

Usage

UglifyJS2 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 you want to read from STDIN instead, pass a single dash instead of input files.

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:

The available options are:

Specify --output (-o) to declare the output file. Otherwise the output goes to STDOUT.

Source map options

UglifyJS2 can generate a source map file, which is highly useful for debugging your compressed JavaScript. To get a source map, pass --source-map output.js.map (full path to the file where you want the source map dumped).

Additionally you might need --source-map-root to pass the URL where the original files can be found. In case you are passing full paths to input files to UglifyJS, you can use --prefix (-p) to specify the number of directories to drop from the path prefix when declaring files in the source map.

For example:

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 you need to pass --in-source-map /path/to/input/source.map or --in-source-map inline if the source map is included inline with the sources. Normally the input source map should also point to the file containing the generated JS, so if that's correct you can omit input files from the command line.

Mangler options

To enable the mangler you need to pass --mangle (-m). The following (comma-separated) options are supported:

• toplevel — mangle names declared in the toplevel scope (disabled by default).

• eval — mangle names visible in scopes where eval or with are used (disabled by default).

When mangling is enabled but you want to prevent certain names from being mangled, you can declare those names with --reserved (-r) — pass a comma-separated list of names. For example:

to prevent the require, exports and $ names from being changed.

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. It will mangle all properties that are seen in some object literal, or that are assigned to. For example:

In the above code, foo, bar, baz, moo and boo will be replaced with single characters, while something() will be left as is.

In order for this to be of any use, we should avoid mangling standard JS names. For instance, if your code would contain x.length = 10, then length becomes a candidate for mangling and it will be mangled throughout the code, regardless if it's being used as part of your own objects or accessing an array's length. To avoid that, you can use --reserved-file to pass a filename that should contain the names to be excluded from mangling. This file can be used both for excluding variable names and property names. It could look like this, for example:

--reserved-file can be an array of file names (either a single comma-separated argument, or you can pass multiple --reserved-file arguments) — in this case it will exclude names from all those files.

A default exclusion file is provided in tools/domprops.json which should cover most standard JS and DOM properties defined in various browsers. Pass --reserve-domprops to read that in.

You can also use a regular expression to define which property names should be mangled. For example, --mangle-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:

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=unquoted or --mangle-props=2)

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:

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.

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.

Compressor options

You need to pass --compress (-c) to enable the compressor. Optionally you can pass a comma-separated list of 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).

• 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

The unsafe 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() → {}

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:

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:

and build your code like this:

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:

Beautifier 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:

• beautify (default true) -- whether to actually beautify the output.

  Passing -b will set this to true, but you might need to pass -b even

  when you want to generate minified code, in order to specify additional

  arguments, so you can use -b beautify=false

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 '/foo|bar/' will keep only comments that contain "foo" or "bar".

Note, however, that there might be situations where comments are lost. For example:

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.

Support for the SpiderMonkey AST

UglifyJS2 has its own abstract syntax tree format; for 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 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:

The --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 --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.

Using UglifyJS to transform SpiderMonkey AST

Now you can use UglifyJS as any other intermediate tool for transforming JavaScript ASTs in SpiderMonkey format.

Example:

Check out for details.

API Reference

Assuming installation via NPM, you can load UglifyJS in your application like this:

It exports a lot of names, but I'll discuss here the basics that are needed for parsing, mangling and compressing a piece of code. The sequence is (1) parse, (2) compress, (3) mangle, (4) generate output code.

The simple way

There's a single toplevel function which combines all the steps. If you don't need additional customization, you might want to go with minify. Example:

You can also compress multiple files:

To generate a source map:

To generate a source map with the fromString option, you can also use an object:

Note that the source map is not saved in a file, it's just returned in result.map. The value passed for outSourceMap is only used to set //# sourceMappingURL=out.js.map in result.code. The value of outFileName is only used to set file attribute in source map file.

The file attribute in the source map (see ) will use outFileName firstly, if it's falsy, then will be deduced from outSourceMap (by removing '.map').

You can set option sourceMapInline to be true and source map will be appended to code.

You can also specify sourceRoot property to be included in source map:

If you're compressing compiled JavaScript and have a source map for it, you can use the inSourceMap argument:

If your input source map is not in a file, you can pass it in as an object using the inSourceMap argument:

The inSourceMap is only used if you also request outSourceMap (it makes no sense otherwise).

To set the source map url, use the sourceMapUrl option. If you're using the X-SourceMap header instead, you can just set the sourceMapUrl option to false. Defaults to outSourceMap:

Other options:

• warnings (default false) — pass true to display compressor warnings.

• fromString (default false) — if you pass true then you can pass JavaScript source code, rather than file names.

mangle

• except - pass an array of identifiers that should be excluded from mangling

• toplevel — mangle names declared in the toplevel scope (disabled by default).

• eval

mangleProperties options

• regex — Pass a RegExp to only mangle certain names (maps to the --mangle-regex CLI arguments option)

• ignore_quoted – Only mangle unquoted property names (maps to the --mangle-props 2 CLI arguments option)

We could add more options to UglifyJS.minify — if you need additional functionality please suggest!

The hard way

Following there's more detailed API info, in case the minify function is too simple for your needs.

The parser

options is optional and if present it must be an object. The following properties are available:

• strict — disable automatic semicolon insertion and support for trailing

  comma in arrays and objects

• bare_returns — Allow return outside of functions. (maps to the

  --bare-returns

The last two options are useful when you'd like to minify multiple files and get a single file as the output and a proper source map. Our CLI tool does something like this:

After this, we have in toplevel a big AST containing all our files, with each token having proper information about where it came from.

Scope information

UglifyJS contains a scope analyzer that you need to call manually before compressing or mangling. Basically it augments various nodes in the AST with information about where is a name defined, how many times is a name referenced, if it is a global or not, if a function is using eval or the with statement etc. I will discuss this some place else, for now what's important to know is that you need to call the following before doing anything with the tree:

Compression

Like this:

The options can be missing. Available options are discussed above in “Compressor options”. Defaults should lead to best compression in most scripts.

The compressor is destructive, so don't rely that toplevel remains the original tree.

Mangling

After compression it is a good idea to call again figure_out_scope (since the compressor might drop unused variables / unreachable code and this might change the number of identifiers or their position). Optionally, you can call a trick that helps after Gzip (counting character frequency in non-mangleable words). Example:

Generating output

AST nodes have a print method that takes an output stream. Essentially, to generate code you do this:

or, for a shortcut you can do:

As usual, options is optional. The output stream accepts a lot of options, most of them documented above in section “Beautifier options”. The two which we care about here are source_map and comments.

Keeping comments in the output

In order to keep certain comments in the output you need to pass the comments option. Pass a RegExp (as string starting and closing with / or pass a RegExp object), a boolean or a function. Stringified options all and some can be passed too, where some behaves like it's cli equivalent --comments without passing a value. If you pass a RegExp, only those comments whose body matches the RegExp will be kept. Note that body means without the initial // or /*. If you pass a function, it will be called for every comment in the tree and will receive two arguments: the node that the comment is attached to, and the comment token itself.

The comment token has these properties:

• type: "comment1" for single-line comments or "comment2" for multi-line

  comments

• value: the comment body

Your function should return true to keep the comment, or a falsy value otherwise.

Generating a source mapping

You need to pass the source_map argument when calling print. It needs to be a SourceMap object (which is a thin wrapper on top of the library).

Example:

The source_map_options (optional) can contain the following properties:

• file: the name of the JavaScript output file that this mapping refers to

• root: the sourceRoot property (see the )

Support for const

const in uglify-js@2.x has function scope and as such behaves much like var - unlike const in ES2015 (ES6) which has block scope. It is recommended to avoid using const for this reason as it will have undefined behavior when run on an ES2015 compatible browser.

Align the text in a string.

Examples

Align text values in an array:

Or do stuff like this:

Visit the example to see how this works.

Install

Install with

Usage

Params

• text can be a string or array. If a string is passed, a string will be returned. If an array is passed, an array will be returned.

• callback|integer: if an integer, the text will be indented by that amount. If a function, it must return an integer representing the amount of leading indentation to use as align loops over each line.

Example

Would align:

To:

callback

params

The callback is used to determine the indentation of each line and gets the following params:

• len the length of the "current" line

• longest the length of the longest line

• line

return

The callback may return:

• an integer that represents the number of spaces to use for padding,

• or an object with the following properties:

  • indent: {Number} the amount of indentation to use. Default is 0

Integer example:

Object example:

Usage examples

Center align

Using the centerAlign function from above:

Would align this text:

Resulting in this:

Customize

If you wanted to add more padding on the left, just pass the number in the callback.

For example, to add 4 spaces before every line:

Would result in:

Bullets

Would return:

Different indent character

Would return

Related projects

• : Center-align the text in a string.

• : Left or right (or both) justify text using a custom width and character

• : Get the longest item in an array.

Running tests

Install dev dependencies:

Contributing

Pull requests and stars are always welcome. For bugs and feature requests,

Author

Jon Schlinkert

License

Copyright © 2015 Released under the MIT license.

This file was generated by on June 09, 2015.

Repeat the given string n times. Fastest implementation for repeating a string.

Install

Install with npm:

Usage

Repeat the given string the specified number of times.

Example:

Example

Params

• string {String}: The string to repeat

• number {Number}: The number of times to repeat the string

• returns

Benchmarks

Repeat string is significantly faster than the native method (which is itself faster than ):

Run the benchmarks

Install dev dependencies:

About

Related projects

: Create an array by repeating the given value n times. |

Contributing

Pull requests and stars are always welcome. For bugs and feature requests, .

Contributors

Building docs

(This document was generated by (a generator), please don't edit the readme directly. Any changes to the readme must be made in .)

To generate the readme and API documentation with :

Running tests

Install dev dependencies:

Author

Jon Schlinkert

License

Copyright © 2016, . Released under the .

This file was generated by , v0.2.0, on October 23, 2016.

Convert a camelized string into a lowercased one with a custom separator Example: unicornRainbow → unicorn_rainbow

Install

Usage

API

decamelize(input, [separator])

input

Type: string

separator

Type: string Default: _

Related

See for the inverse.

License

MIT ©

This is a library to generate and consume the source map format described here.

Use with Node

Use on the Web

Table of Contents

Examples

Consuming a source map

Generating a source map

In depth guide:

With SourceNode (high level API)

With SourceMapGenerator (low level API)

API

Get a reference to the module:

SourceMapConsumer

A SourceMapConsumer instance represents a parsed source map which we can query for information about the original file positions by giving it a file position in the generated source.

new SourceMapConsumer(rawSourceMap)

The only parameter is the raw source map (either as a string which can be JSON.parse'd, or an object). According to the spec, source maps have the following attributes:

• version: Which version of the source map spec this map is following.

• sources: An array of URLs to the original source files.

• names

SourceMapConsumer.prototype.computeColumnSpans()

Compute the last column for each generated mapping. The last column is inclusive.

SourceMapConsumer.prototype.originalPositionFor(generatedPosition)

Returns the original source, line, and column information for the generated source's line and column positions provided. The only argument is an object with the following properties:

• line: The line number in the generated source.

• column: The column number in the generated source.

• bias

and an object is returned with the following properties:

• source: The original source file, or null if this information is not available.

• line: The line number in the original source, or null if this information is not available.

• column

SourceMapConsumer.prototype.generatedPositionFor(originalPosition)

Returns the generated line and column information for the original source, line, and column positions provided. The only argument is an object with the following properties:

• source: The filename of the original source.

• line: The line number in the original source.

• column

and an object is returned with the following properties:

• line: The line number in the generated source, or null.

• column: The column number in the generated source, or null.

SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)

Returns all generated line and column information for the original source, line, and column provided. If no column is provided, returns all mappings corresponding to a either the line we are searching for or the next closest line that has any mappings. Otherwise, returns all mappings corresponding to the given line and either the column we are searching for or the next closest column that has any offsets.

The only argument is an object with the following properties:

• source: The filename of the original source.

• line: The line number in the original source.

• column

and an array of objects is returned, each with the following properties:

• line: The line number in the generated source, or null.

• column: The column number in the generated source, or null.

SourceMapConsumer.prototype.hasContentsOfAllSources()

Return true if we have the embedded source content for every source listed in the source map, false otherwise.

In other words, if this method returns true, then consumer.sourceContentFor(s) will succeed for every source s in consumer.sources.

SourceMapConsumer.prototype.sourceContentFor(source[, returnNullOnMissing])

Returns the original source content for the source provided. The only argument is the URL of the original source file.

If the source content for the given source is not found, then an error is thrown. Optionally, pass true as the second param to have null returned instead.

SourceMapConsumer.prototype.eachMapping(callback, context, order)

Iterate over each mapping between an original source/line/column and a generated line/column in this source map.

• callback: The function that is called with each mapping. Mappings have the form { source, generatedLine, generatedColumn, originalLine, originalColumn, name }

• context: Optional. If specified, this object will be the value of this every time that callback is called.

SourceMapGenerator

An instance of the SourceMapGenerator represents a source map which is being built incrementally.

new SourceMapGenerator([startOfSourceMap])

You may pass an object with the following properties:

• file: The filename of the generated source that this source map is associated with.

• sourceRoot: A root for all relative URLs in this source map.

• skipValidation

SourceMapGenerator.fromSourceMap(sourceMapConsumer)

Creates a new SourceMapGenerator from an existing SourceMapConsumer instance.

• sourceMapConsumer The SourceMap.

SourceMapGenerator.prototype.addMapping(mapping)

Add a single mapping from original source line and column to the generated source's line and column for this source map being created. The mapping object should have the following properties:

• generated: An object with the generated line and column positions.

• original: An object with the original line and column positions.

• source

SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)

Set the source content for an original source file.

• sourceFile the URL of the original source file.

• sourceContent the content of the source file.

SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])

Applies a SourceMap for a source file to the SourceMap. Each mapping to the supplied source file is rewritten using the supplied SourceMap. Note: The resolution for the resulting mappings is the minimum of this map and the supplied map.

• sourceMapConsumer: The SourceMap to be applied.

• sourceFile: Optional. The filename of the source file. If omitted, sourceMapConsumer.file will be used, if it exists. Otherwise an error will be thrown.

• sourceMapPath

SourceMapGenerator.prototype.toString()

Renders the source map being generated to a string.

SourceNode

SourceNodes provide a way to abstract over interpolating and/or concatenating snippets of generated JavaScript source code, while maintaining the line and column information associated between those snippets and the original source code. This is useful as the final intermediate representation a compiler might use before outputting the generated JS and source map.

new SourceNode([line, column, source[, chunk[, name]]])

• line: The original line number associated with this source node, or null if it isn't associated with an original line.

• column: The original column number associated with this source node, or null if it isn't associated with an original column.

• source

SourceNode.fromStringWithSourceMap(code, sourceMapConsumer[, relativePath])

Creates a SourceNode from generated code and a SourceMapConsumer.

• code: The generated code

• sourceMapConsumer The SourceMap for the generated code

• relativePath

SourceNode.prototype.add(chunk)

Add a chunk of generated JS to this source node.

• chunk: A string snippet of generated JS code, another instance of

  SourceNode, or an array where each member is one of those things.

SourceNode.prototype.prepend(chunk)

Prepend a chunk of generated JS to this source node.

• chunk: A string snippet of generated JS code, another instance of

  SourceNode, or an array where each member is one of those things.

SourceNode.prototype.setSourceContent(sourceFile, sourceContent)

Set the source content for a source file. This will be added to the SourceMap in the sourcesContent field.

• sourceFile: The filename of the source file

• sourceContent: The content of the source file

SourceNode.prototype.walk(fn)

Walk over the tree of JS snippets in this node and its children. The walking function is called once for each snippet of JS and is passed that snippet and the its original associated source's line/column location.

• fn: The traversal function.

SourceNode.prototype.walkSourceContents(fn)

Walk over the tree of SourceNodes. The walking function is called for each source file content and is passed the filename and source content.

• fn: The traversal function.

SourceNode.prototype.join(sep)

Like Array.prototype.join except for SourceNodes. Inserts the separator between each of this source node's children.

• sep: The separator.

SourceNode.prototype.replaceRight(pattern, replacement)

Call String.prototype.replace on the very right-most source snippet. Useful for trimming white space from the end of a source node, etc.

• pattern: The pattern to replace.

• replacement: The thing to replace the pattern with.

SourceNode.prototype.toString()

Return the string representation of this source node. Walks over the tree and concatenates all the various snippets together to one string.

SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])

Returns the string representation of this tree of source nodes, plus a SourceMapGenerator which contains all the mappings between the generated and original sources.

The arguments are the same as those to new SourceMapGenerator.

wordwrap

Wrap your words.

example

made out of meat

meat.js

output:

centered

center.js

output:

methods

var wrap = require('wordwrap');

wrap(stop), wrap(start, stop, params={mode:"soft"})

Returns a function that takes a string and returns a new string.

Pad out lines with spaces out to column start and then wrap until column stop. If a word is longer than stop - start characters it will overflow.

In "soft" mode, split chunks by /(\S+\s+/ and don't break up chunks which are longer than stop - start, in "hard" mode, split chunks with /\b/ and break up chunks longer than stop - start.

wrap.hard(start, stop)

Like wrap() but with params.mode = "hard".

Cache requires to be lazy-loaded when needed.

Install

Install with npm:

If you use webpack and are experiencing issues, try using unlazy-loader, a webpack loader that fixes the bug that prevents webpack from working with native javascript getters.

Usage

Use as a property on lazy

The module is also added as a property to the lazy function so it can be called without having to call a function first.

Use as a function

Aliases

An alias may be passed as the second argument if you don't want to use the automatically camel-cased variable name.

Example

Browserify usage

Example

Kill switch

In certain rare edge cases it may be necessary to unlazy all lazy-cached dependencies (5 reported cases after ~30 million downloads).

To force lazy-cache to immediately invoke all dependencies, do:

Related projects

You might also be interested in these projects:

: CLI tool that tells you when dependencies are missing from package.json and offers you a… |

Contributing

Pull requests and stars are always welcome. For bugs and feature requests, .

Building docs

Generate readme and API documentation with :

Or, if is installed globally:

Running tests

Install dev dependencies:

Author

Jon Schlinkert

License

Copyright © 2016, . Released under the .

This file was generated by , v0.9.0, on April 22, 2016.

0.5.6

• Fix for regression when people were using numbers as names in source maps. See

  236.

Center-align the text in a string.

Install with

Usage

Example

Right-align the text in a string.

Install with

Usage

Example

Get the longest item in an array.

Install with

easily create complex multi-column command-line-interfaces.

Example

Layout DSL

cliui exposes a simple layout DSL:

If you create a single ui.row, passing a string rather than an object:

• \n: characters will be interpreted as new rows.

• \t: characters will be interpreted as new columns.