`bash
jscrambler -a _YOUR_ACCESS_KEY_ -s _YOUR_SECRET_KEY_ -i _YOUR_APPLICATION_ID_ -o output/ "lib/*/.js"
`

Some useful examples:
- lib/*/.js: Matches all .js files in lib and all its subdirectories.
- lib/**/priv_key.js: Matches all pri_key.js files in lib and all its subdirectories.
- scripts/*.js: Matches all .js files in the scripts directory.
- src/*/.{js,html}: Matches all .js and .html files in src and all its subdirectories.
- !(node_modules)/**: Excludes node_modules directory.

For additional patterns, click here.

$3

JavaScript projects usually have a folder structure that must be preserved in order for the application to work properly.
In order to make sure that that structure is preserved, the jscrambler client needs to know what is the path of the root folder of your project's file structure.
We call this path the Current Working Directory (CWD). The folder structure of all the subdirectories of the paths that match the patterns passed to the jscrambler
cli will be replicated in the output folder (specified by the filesDest parameter.)

There are three ways to define this setting:
- If you use relative paths as input patterns, then the CWD is assumed to be the path on which the CLI was executed.
For example, the following command, executed in /home/user (assuming config.js does not define neither filesSrc nor filesDest):
`bash
jscrambler --config config.js -o out/ project/dist/*.js
`
will output the protected files as /home/user/out/project/dist/.js.

- If you use absolute paths as input patterns, then the CWD is assumed to be the root of the filesystem (/).
For example, changing the previous command to use an absolute path:
`bash
jscrambler --config config.js -o out/ /home/user/project/dist/*.js
`
results in the files being output to /home/user/out/home/user/project/dist/.js

- To change this behaviour, you can use the --cwd option to explicitly set the CWD:
`bash
jscrambler --config config.js --cwd /home/user -o out/ /home/user/project/dist/*.js
`
which results in the files being output to /home/user/out/project/dist/.js

$3

By default, Jscrambler will not protect your application when errors occur in some or all of your files. For example: if your app have 5 files and one of them has syntax errors, Jscrambler will not protect any of your files. To override this behavior you must set the werror flag to false.

Any error/warning will make the protection fail.

There are two possible types of errors:
* Syntax errors

Code
` javascript
function a[] {
return
}
`

Output
`
Global protection errors:
- Errors ocurred while parsing

Application sources errors:
[
{
"filename": "index.js",
"message": "SyntaxError: 'return' outside of function (1:0)",
"line": 1,
"column": null,
"fatal": true
}
]

Protection failed. For more information visit: https://app.jscrambler.com.
`

* Errors parsing jscrambler code annotations

Code
` javascript
//@jscrambler define __something
function test() {
return true;
}

test();

//@jscrambler [define xxxxx]
function test1() {
return false;
}

test1();
`

Output
`
Global protection errors:
- Failed to protect any source file

Application sources errors:
[
{
"filename": "index.js",
"message": "[Annotation Error] Expected \" \" or [a-z]i but \"_\" found.",
"line": 1,
"column": 21,
"fatal": true
},
{
"filename": "index.js",
"message": "[Annotation Error] Expected \" \", \"define\", \"disable\", \"enable\", \"global\", \"order\" or \"target\" but \"[\" found.",
"line": 8,
"column": 13,
"fatal": true
},
{
"filename": "index.js",
"message": "Parsing errors on annotations",
"line": null,
"column": null,
"fatal": true
}
]

Protection failed. For more information visit: https://app.jscrambler.com.
`

$3

To enable:
`bash
jscrambler --recommended-order true input1.js -o output/
`

$3

Note: This option was introduced in the version 6.3 and should be used instead of use-profiling-data which is deprecated.

The profiling-data-mode option can be set to three different modes:
* Annotations: considers only the profiling annotations;
* Automatic (default): ignores the existing profiling annotations and only considers the application's profiling data;
* Off: uses neither profiling data nor profiling annotations.

The following behaviour:

`
jscrambler --profiling-data-mode off ...
`

Has the same effect as:

`
jscrambler --use-profiling-data false ...
`


$3

Instrument is used when you want to Profile your application. It is a similar process as protecting your application, but it will just instrument your application so that we can collect some data about how it runs. When you instrument an application, jscrambler will output the instrumented version of that application to the specified file/directory. Check our documentation for more detailed information.

NOTE: When you run this command, the existing profiling information will be deleted (if any).

WARNING: DO NOT SEND THIS CODE TO PRODUCTION AS IT IS NOT PROTECTED

Javascript Appending and Prepending

This option is available in your configuration file and allows for Javascript files to be appended or prepended to specific files before protecting your code.
It allows for multiple files to be affixed or prefixed with another file, without changing the original content of the file and more than one script can act on the same file - you can both append and prepend the same JS file with the desired scripts on the same protection.
The concatenation of files can result in max file size errors - even though the original file may be under the max limit, the result of the concatenation may exceed this threshold.

`json
{
"beforeProtection": [
{
"type": "append-js",
"target": "/path/to/target/file.js",
"source": "/path/to/script/file.js"
},
{
"type": "prepend-js",
"target": "/path/to/target/file.js",
"source": "/path/to/script/file.js"
}
]
}
`

Symbol Table

Jscrambler can import symbol tables to ensure certain global variables and object properties have specific names.
These symbol tables can be passed using the --input-symbol-table option, or with the inputSymbolTable
option in the configuration file.

These files follow the schema used by uglifyjs@^3:

`json
{
"vars": {
"props": {
"$globalName": "transformedName"
}
},
"props": {
"props": {
"$propertyName": "transformedName"
}
}
}
`

Similarly, the resulting symbol table can be obtained using the --output-symbol-table option.

NOTE: It only makes sense to use symbol tables on protections that use the identifiers renaming parameter.

Use Global Names On Modules

When we detect we're protecting an ES module, we may generate top-level single-character identifiers for code size purposes. If, in your use case, you expect to transpile this module into a script using a tool that cannot guarantee ES Module isolation (as it should), this may lead to collisions, especially if you're doing this with multiple obfuscated modules.
To reduce the chance of collisions, you can set the useGlobalNamesOnModules option on your protection request:

// jscrambler.json
{
"useGlobalNamesOnModules": true
}

If you apply the previous configuration, all generated global variable names will follow the same principle as global variables (not on modules), and have at least 5 characters, thus reducing the chance of collisions.

Global Names Prefix

If you need to make separate obfuscation requests for source code that belong to the same application instance, there is a small chance that you will encounter a naming collision on the generate global names.

To prevent global naming collisions, you can set the globalNamesPrefix parameter on each protection request:

`javascript
// jscrambler.json to protect micro-frontend 1
{
"globalNamesPrefix": "p1"
}

// jscrambler.json to protect micro-frontend 2
{
"globalNamesPrefix": "p2"
}
`

If you apply the previous configuration, all generated global variable names will start with the letters p1 for micro-frontend 1 and p2 for micro-frontend 2.

Note: The globalNamesPrefix parameter must be short and unintelligible to avoid code size increase and automated attacks

API

jscrambler.protectAndDownload({
keys: {
accessKey: '_YOUR_ACCESS_KEY_',
secretKey: '_YOUR_SECRET_KEY_'
},
host: 'api4.jscrambler.com',
port: 443,
applicationId: '_YOUR_APPLICATION_ID_',
filesSrc: [
'/path/to/src/*.html',
'/path/to/src/*.js'
],
filesDest: '/path/to/destDir/',
params: [
{
'name': 'whitespaceRemoval'
},
{
'name': 'duplicateLiteralsRemoval'
}
]
})
.then(function () {
console.log('All done!');
})
.catch(function (err) {
console.error(err);
});
``

More detailed informations can be found here.

Jscrambler Parameters

Please refer to docs for more information.