Loading...

Show output


  • Default

  • Low

  • Medium

  • High

  • Custom


Default preset, high performance: Performance will not be affected.

Target

Target (target): Allows to set target environment for obfuscated code.
  • Browser

  • Browser no eval

  • Node

Seed

Seed (seed): This option sets seed for random generator. This is useful for creating repeatable results. If seed is `0` - random generator will work without seed.

Disable console output

Disable console output (disableConsoleOutput): Disables the use of `console.log`, `console.info`, `console.error`, `console.warn`, `console.debug`, `console.exception` and `console.trace` by replacing them with empty functions. This makes the use of the debugger harder.

Self defending

Self defending (selfDefending): This option makes the output code resilient against formatting and variable renaming. If one tries to use a JavaScript beautifier on the obfuscated code, the code won't work anymore, making it harder to understand and modify it. Warning: Don't change obfuscated code in any way after obfuscation with this option, because any change like uglifying of code can trigger self defending and code wont work anymore! This option forcibly sets compact value to true

Debug protection

Debug protection (debugProtection): This option makes it almost impossible to use the `debugger` function of the Developer Tools (both on WebKit-based and Mozilla Firefox). Warning: Can freeze your browser if you open the Developer Tools.

Debug protection interval

Debug protection interval (debugProtectionInterval): If checked, an interval is used to force the debug mode on the Console tab, making it harder to use other features of the Developer Tools. Works if `debugProtection` is enabled. Warning: Can freeze your browser! Use at own risk.

Ignore require imports

Ignore require imports (ignoreRequireImports): Prevents obfuscation of `require` imports. Could be helpful in some cases when for some reason runtime environment requires these imports with static strings only.

Domain lock

Domain lock (domainLock): Allows to run the obfuscated source code only on specific domains and/or sub-domains. This makes really hard for someone to just copy and paste your source code and run it elsewhere. If the source code isn't run on the domains specified by this option, the browser will be redirected to a passed to the `domainLockRedirectUrl` option URL.

Domain lock redirect URL

Domain lock redirect URL (domainLockRedirectUrl): Allows the browser to be redirected to a passed URL if the source code isn't run on the domains specified by `domainLock`.

Enable source map

Enable source map (sourceMap): Enables source map generation for obfuscated code. Source maps can be useful to help you debug your obfuscated JavaScript source code. If you want or need to debug in production, you can upload the separate source map file to a secret location and then point your browser there.

Source map mode

Source map mode (sourceMapMode): Specifies source map generation mode: - `inline` - add source map at the end of each .js files; - `separate` - generates corresponding '.map' file with source map. In case you run obfuscator through CLI - adds link to source map file to the end of file with obfuscated code `//# sourceMappingUrl=file.js.map`.
  • Separate

  • Inline

Source map sources mode

Source map sources mode (sourceMapSourcesMode): Allows to control `sources` and `sourcesContent` fields of the source map: - `sources-content` - adds dummy sources field, adds sourcesContent field with the original source code; - `sources` - adds `sources` field with a valid source description, does not add `sourcesContent` field. When using NodeJS API it's required to define `inputFileName` option that will be used as `sources` field value.
  • Sources content

  • Sources

Source map base URL

Source map base URL (sourceMapBaseUrl): Sets base url to the source map import url when `sourceMapMode: 'separate'`.

Source map file name

Source map file name (sourceMapFileName): Sets file name for output source map when `sourceMapMode: 'separate'.`

String transformations


String array

String array (stringArray): Removes string literals and place them in a special array. For instance, the string `"Hello World"` in `var m = "Hello World";` will be replaced with something like `var m = _0x12c456[0x1];`.

Rotate string array

Rotate string array (rotateStringArray): Shift the `stringArray` array by a fixed and random (generated at the code obfuscation) places. This makes it harder to match the order of the removed strings to their original place.

Shuffle string array

Shuffle string array (shuffleStringArray): Randomly shuffles the `stringArray` array items.

String array threshold

String array threshold (stringArrayThreshold): You can use this setting to adjust the probability (from 0 to 1) that a string literal will be inserted into the `stringArray`. This setting is especially useful for large code size because it repeatedly calls to the `string array` and can slow down your code.

String array index shift

String array index shift (stringArrayIndexShift): Enables additional index shift for all string array calls.

String array indexes type

String array indexes type (stringArrayIndexesType): Allows to control the type of string array call indexes. Each stringArray call index will be transformed by the randomly picked type from the passed list. This makes possible to use multiple types. Available values: - `'hexadecimal-number'` (`default`): transforms string array call indexes as hexadecimal numbers - `'hexadecimal-numeric-string'`: transforms string array call indexes as hexadecimal numeric string
  • Hexadecimal number string

hexadecimal-number

String array wrappers count

String array wrappers count (stringArrayWrappersCount): Sets the count of wrappers for the `string array` inside each root or function scope. The actual count of wrappers inside each scope is limited by a count of `literal` nodes within this scope.

String array wrappers type

String array wrappers type (stringArrayWrappersType): Allows to select a type of the wrappers that are appending by the `stringArrayWrappersCount` option.
  • Variable

  • Function

String array wrappers parameters maximum count

String array wrappers parameters maximum count (stringArrayWrappersParametersMaxCount): Allows to control the maximum number of string array wrappers parameters. Default and minimum value is `2`. Recommended value between `2` and `5`.

String array wrappers chained calls

String array wrappers chained calls (stringArrayWrappersChainedCalls): Enables the chained calls between `string array` wrappers.

String array encoding

String array encoding (stringArrayEncoding): This option can slow down your script. Encode all string literals of the `stringArray` using `base64` or `rc4` and inserts a special code that used to decode it back at runtime. Each `stringArray` value will be encoded by the randomly picked encoding from the passed list. This makes possible to use multiple encodings. Available values: - `'none'` (`boolean`): doesn't encode `stringArray` value - `'base64'` (`string`): encodes `stringArray` value using `base64` - `'rc4'` (`string`): encodes `stringArray` value using `rc4`. *About 30-50% slower than `base64`, but more harder to get initial values*. It's recommended to disable `unicodeEscapeSequence` option when using `rc4` encoding to prevent very large size of obfuscated code.
  • None

  • Base64

  • RC4

Split strings

Split strings (splitStrings): Splits literal strings into chunks with length of `splitStringsChunkLength` option value.

Split strings chunk length

Split strings chunk length (splitStringsChunkLength): Sets chunk length of `splitStrings` option.

Unicode escape sequence

Unicode escape sequence (unicodeEscapeSequence): Allows to enable/disable string conversion to unicode escape sequence. Unicode escape sequence increases code size greatly and strings easily can be reverted to their original view. Recommended to enable this option only for small source code.

Force transform strings

Force transform strings (forceTransformStrings): Enables force transformation of string literals, which being matched by passed RegExp patterns. Warning: This option affects only strings that shouldn't be transformed by `stringArrayThreshold`.

Reserved strings

Reserved strings (reservedStrings): Disables transformation of string literals, which being matched by passed RegExp patterns.

Identifiers transformations


Identifier names generator

Identifier names generator (identifierNamesGenerator): Sets identifier names generator. Available values: - `dictionary`: identifier names from `identifiersDictionary` list - `hexadecimal`: identifier names like `_0xabc123` - `mangled`: short identifier names like `a`, `b`, `c` - `mangled-shuffled`: same as `mangled` but with shuffled alphabet
  • Dictionary

  • Hexadecimal

  • Mangled

  • Mangled shuffled

Identifiers dictionary

Identifiers dictionary (identifiersDictionary): Sets identifiers dictionary for `identifierNamesGenerator`: `dictionary` option. Each identifier from the dictionary will be used in a few variants with a different casing of each character. Thus, the number of identifiers in the dictionary should depend on the identifiers amount at original source code.

Identifiers prefix

Identifiers prefix (identifiersPrefix): Sets prefix for all global identifiers. Use this option when you want to obfuscate multiple files. This option helps to avoid conflicts between global identifiers of these files. Prefix should be different for every file.

Rename globals

This is an unsafe option: Enabling this may result in unexpected results.Rename globals (renameGlobals): Enables obfuscation of global variable and function names *with declaration*.

Rename properties

This is an unsafe option: Enabling this may result in unexpected results.Rename properties (renameProperties): Enables renaming of property names. All built-in DOM properties and properties in core JavaScript classes will be ignored.

Rename properties mode

Rename properties mode (renamePropertiesMode): Specifies renameProperties option mode: - `safe` - Trying to rename properties in a more safe way to prevent runtime errors. With this mode some properties will be excluded from renaming. - `unsafe` - Renames properties in an unsafe way without any restrictions. Warning: Even in `safe` mode, `renameProperties` option MAY break your code.
  • Safe

  • Unsafe

Reserved names

Reserved names (reservedNames): Disables obfuscation and generation of identifiers, which being matched by passed RegExp patterns.

Other transformations


Compact

Compact (compact): Compact code output on one line.

Simplify

Simplify (simplify): Enables additional code obfuscation through simplification.

Transform object keys

Transform object keys (transformObjectKeys): Enables transformation of object keys.

Numbers to expressions

Numbers to expressions (numbersToExpressions): Enables numbers conversion to expressions.

Control flow flattening

Control flow flattening (controlFlowFlattening): Enables code control flow flattening. Control flow flattening is a structure transformation of the source code that hinders program comprehension. Warning: This option greatly affects the performance up to 1.5x slower runtime speed. Use `controlFlowFlatteningThreshold` to set percentage of nodes that will affected by control flow flattening.

Control flow flattening threshold

Control flow flattening threshold (controlFlowFlatteningThreshold): The probability that the controlFlowFlattening transformation will be applied to any given node. This setting is especially useful for large code size because large amounts of control flow transformations can slow down your code and increase code size.

Dead code injection

Dead code injection (deadCodeInjection): With this option, random blocks of dead code will be added to the obfuscated code. Warning: Dramatically increases size of obfuscated code (up to 200%), use only if size of obfuscated code doesn't matter. Use `deadCodeInjectionThreshold` to set percentage of nodes that will affected by dead code injection. This option forcibly enables `stringArray` option.

Dead code injection threshold

Dead code injection threshold (deadCodeInjectionThreshold): Allows to set percentage of nodes that will affected by `deadCodeInjection`.