JS-Confuser

https://js-confuser.com/docs
Admin
JS-Confuser is an open-source JavaScript obfuscator that transforms source code into an unreadable,...
Tokens:41,138
Snippets:306
Trust Score:6.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Usage Example with countermeasures Option

Source: https://js-confuser.com/docs/options/countermeasures

Usage example showing how to set the countermeasures option and obfuscate a file.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from 
"fs";
// Read input code
const sourceCode = readFileSync("input.js", 
"utf8");
const options = {
target: 'browser',
lock: {
countermeasures: 'onTamperDetected',
},
};
JSConfuser.obfuscate(sourceCode, 
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Install JS-Confuser with NPM

Source: https://js-confuser.com/docs/getting-started/installation

Use this command to install the package via the NPM package manager.

```bash
npm install js-confuser
```

--------------------------------

### Install JS-Confuser with Yarn

Source: https://js-confuser.com/docs/getting-started/installation

Use this command to install the package via the Yarn package manager.

```bash
yarn add js-confuser
```

--------------------------------

### Pack Usage Example

Source: https://js-confuser.com/docs/options/pack

Usage example for the Pack option. Reads input.js, obfuscates it with pack: true, and writes the result to output.js. Requires the js-confuser package and Node.js fs module.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from 
"fs";
// Read input code
const sourceCode = readFileSync("input.js", 
"utf8");
const options = {
target: 'browser',
pack: true,
};
JSConfuser.obfuscate(sourceCode, 
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Usage Example with opaquePredicates

Source: https://js-confuser.com/docs/options/opaquePredicates

Usage example for the opaquePredicates option. Reads input.js, obfuscates with the option enabled, and writes the result to output.js. Requires the js-confuser package and Node.js fs module.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from 
"fs";
// Read input code
const sourceCode = readFileSync("input.js", 
"utf8");
const options = {
target: 'browser',
opaquePredicates: true,
};
JSConfuser.obfuscate(sourceCode, 
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Obfuscate with Source Map Configuration

Source: https://js-confuser.com/docs/options/sourceMap

Example showing how to obfuscate a file and generate an external source map file.

```javascript
import { readFile, writeFile } from "fs/promises";
import JsConfuser from "js-confuser";
const sourceCode = await readFile("./dev.input.js", "utf-
8");
var result = await JsConfuser.obfuscate(sourceCode, {
target: "node",
preset: "medium",
sourceMap: {
fileName: "dev.input.js"
},
});
// External source map, to be added to the bottom of the 
file
result.code += `\n//# sourceMappingURL=dev.output.js.map`;
// Save files
await writeFile("dev.output.js", result.code, { encoding: 
"utf-8" });
```

--------------------------------

### Input JavaScript for Custom Locks example

Source: https://js-confuser.com/docs/options/customLocks

The input code that is obfuscated in the example. It defines a function 'countermeasures' that throws an error and logs a message.

```javascript
function countermeasures(){
throw new Error("Invalid browser!");
}
console.log("This only runs in Chrome!");
```

--------------------------------

### Dispatcher Usage Example

Source: https://js-confuser.com/docs/options/dispatcher

Usage example for the Dispatcher option. It reads input.js, obfuscates it with dispatcher enabled, and writes the result to output.js. The example uses the JSConfuser API with the 'dispatcher' option set to true.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from "fs";
// Read input code
const sourceCode = readFileSync("input.js", "utf8");
const options = {
target: 'browser',
dispatcher: true,
};
JSConfuser.obfuscate(sourceCode, options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Usage Example for Moved Declarations

Source: https://js-confuser.com/docs/options/movedDeclarations

Shows how to programmatically obfuscate a file using the movedDeclarations option set to true.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from 
"fs";
// Read input code
const sourceCode = readFileSync("input.js", 
"utf8");
const options = {
target: 'browser',
movedDeclarations: true,
};
JSConfuser.obfuscate(sourceCode, 
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
```

--------------------------------

### Flatten Usage Example

Source: https://js-confuser.com/docs/options/flatten

Usage example for the flatten option. It reads input.js, obfuscates it with flatten enabled, and writes the result to output.js. The target is set to 'browser'.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from "fs";
// Read input code
const sourceCode = readFileSync("input.js", "utf8");
const options = {
target: 'browser',
flatten: true,
};
JSConfuser.obfuscate(sourceCode, options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Usage Example with JSConfuser.obfuscate

Source: https://js-confuser.com/docs/options/renameVariables

Usage example that obfuscates input.js and writes the output to output.js. Uses the JSConfuser.obfuscate API with renameVariables set to true. Handles errors with a catch block.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from "fs";
// Read input code
const sourceCode = readFileSync("input.js", "utf8");
const options = {
target: 'browser',
renameVariables: true,
};
JSConfuser.obfuscate(sourceCode, options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### RGF Input/Output Example

Source: https://js-confuser.com/docs/options/rgf

Shows the transformation applied by RGF. The input function is converted into a runtime-generated function that uses eval, and the output is obfuscated.

```javascript
function printToConsole(message) {
console.log(message);
}
printToConsole("Hello World"); // "Hello World"
```

```javascript
function PDLqWt(PDLqWt = !0) {
return PDLqWt;
}
var N4PnHf = PDLqWt(),
izTzljL = [pOejSc2("function wK7fpT()
{var[wK7fpT,bEZSMD]=arguments;function smKCqkm(wK7fpT)
{console.log(wK7fpT)}return 
smKCqkm.apply(this,bEZSMD)}wK7fpT;")];
function bHCDYy() {
return izTzljL[0].apply(this, [izTzljL, arguments]);
}
function pOejSc2(PDLqWt) {
if (N4PnHf) {
return eval(PDLqWt);
}
}
bHCDYy("Hello World");
```

--------------------------------

### RGF Usage Example

Source: https://js-confuser.com/docs/options/rgf

Usage example for the RGF option. Reads input.js, obfuscates with rgf: true, and writes the result to output.js. Requires the js-confuser package and Node.js fs module.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from "fs";
// Read input code
const sourceCode = readFileSync("input.js", "utf8");
const options = {
target: 'browser',
rgf: true,
};
JSConfuser.obfuscate(sourceCode, options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Usage Example with JSConfuser.obfuscate

Source: https://js-confuser.com/docs/options/minify

Usage example that obfuscates input.js with the minify option enabled and writes the result to output.js. Uses the JSConfuser.obfuscate API with a promise and error handling.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from 
"fs";
// Read input code
const sourceCode = readFileSync("input.js", 
"utf8");
const options = {
target: 'browser',
minify: true,
};
JSConfuser.obfuscate(sourceCode, 
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Usage Example with calculator Option

Source: https://js-confuser.com/docs/options/calculator

Demonstrates how to use the JS-Confuser API with the calculator option enabled. Reads input.js, obfuscates it with the specified options, and writes the result to output.js.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from 
"fs";
// Read input code
const sourceCode = readFileSync("input.js", 
"utf8");
const options = {
target: 'browser',
calculator: true,
};
JSConfuser.obfuscate(sourceCode, 
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Usage Example for Duplicate Literals Removal

Source: https://js-confuser.com/docs/options/duplicateLiteralsRemoval

Shows how to programmatically obfuscate a file using the duplicateLiteralsRemoval option.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from
"fs";
// Read input code
const sourceCode = readFileSync("input.js",
"utf8");
const options = {
target: 'browser',
duplicateLiteralsRemoval: true,
};
JSConfuser.obfuscate(sourceCode,
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err);
});
```

--------------------------------

### Minify Input and Output Example

Source: https://js-confuser.com/docs/options/minify

Shows the transformation applied by the minify option. The input uses destructuring and a comment, while the output replaces it with a single variable and removes the comment.

```javascript
var { fullName } = { fullName: "John Doe" };
console.log(fullName); // "John Doe"
```

```javascript
var B4EoKR = "John Doe";
console.log(B4EoKR);
```

--------------------------------

### Usage Example: JSConfuser.obfuscate with stringEncoding

Source: https://js-confuser.com/docs/options/stringEncoding

Usage example for the stringEncoding option. Reads input.js, obfuscates with stringEncoding enabled, and writes the result to output.js. Handles errors by logging them.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from "fs";

// Read input code
const sourceCode = readFileSync("input.js", "utf8");

const options = {
  target: 'browser',
  stringEncoding: true,
};

JSConfuser.obfuscate(sourceCode, options).then((result)=>{
  // Write output code
  writeFileSync("output.js", result.code);
}).catch(err=>{
  // Error occurred
  console.error(err); 
});
```

--------------------------------

### Usage Example - Obfuscating input.js with lock.integrity

Source: https://js-confuser.com/docs/options/integrity

Shows how to use JSConfuser.obfuscate with the lock.integrity option set to true. Reads input.js, obfuscates it, and writes the result to output.js.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from "fs";

// Read input code
const sourceCode = readFileSync("input.js", "utf8");

const options = {
  target: 'browser',
  lock: {
    integrity: true,
  },
};

JSConfuser.obfuscate(sourceCode, options).then((result)=>{
  // Write output code
  writeFileSync("output.js", result.code);
}).catch(err=>{
  // Error occurred
  console.error(err); 
});
```

--------------------------------

### Usage example with js-confuser

Source: https://js-confuser.com/docs/options/compact

Node.js script using JSConfuser.obfuscate to obfuscate the contents of 'input.js' with the compact option enabled and write the obfuscated code to 'output.js'.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from 
"fs";
// Read input code
const sourceCode = readFileSync("input.js", 
"utf8");
const options = {
target: 'browser',
compact: true,
renameVariables: false,
};
JSConfuser.obfuscate(sourceCode, 
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Custom JSConfuser.ts configuration with identifier generator and string concealing

Source: https://js-confuser.com/docs/getting-started/playground

Example JSConfuser.ts file showing custom identifierGenerator and stringConcealing implementations. The identifierGenerator returns sequential `var_` names starting from 0, and stringConcealing encrypts strings containing the API endpoint or 60% of random strings. The module exports the target and renameVariables settings.

```javascript
var counter = 0;
module.exports = {
  target: "browser",
  renameVariables: true,
  // Custom Identifier Generator implementation
  // Returns `var_0`, `var_1`, `var_2`
  identifierGenerator: () =>
    `var_${counter++}`,
  // Custom String Concealing
  // Always encrypt API endpoints
  stringConcealing: (str) => {
    if (str.includes("https://api-example.com")) {
      return true;
    }
    // 60% for other strings
    return Math.random() < 0.6;
  },
  // ...Other settings...
};
```

--------------------------------

### String Concealing Input Example

Source: https://js-confuser.com/docs/options/stringConcealing

Input code for the String Concealing example. It declares a string variable and logs it to the console.

```javascript
var str = "Hello, World!";
console.log(str);
```

--------------------------------

### Custom String Encodings Input and Output

Source: https://js-confuser.com/docs/options/customStringEncodings

This example demonstrates the transformation of a simple string logging statement into an obfuscated version using Custom String Encodings. The input code is provided alongside the resulting obfuscated output.

```javascript
// Base64 Encoding Demo
var str = "Hello, World!";
console.log(str); // "Hello, World!"
```

```javascript
function exzd_k(exzd_k) {
return atob(exzd_k);
}
function V_xYJ3(V_xYJ3, W_y66vE) {
return exzd_k(ro9gHHM.slice(V_xYJ3, V_xYJ3 + W_y66vE));
}
var ro9gHHM = 
"vN9z[2M#pqEiOHbP!)N&gPc__}}lv/(j$,f]Adfzv}\"AL,jz)iQ9<rbo
k3~$xjzc}>gcx!qjTLAW%^8XUt/Q]%P!}$lx;XlMKYcG=[??
znAqofM\"N^`ZU7;b;if49Hi1.:x^eOqsYNWW^ZH(TJ\"I;D6Hl0V!CPzV
?
X.N2zn1jAi2HVhxK31I>z$SGVsbG8sIFdvcmxkIQ==KFbG9nAHFpe7A13e
ToDZHcP09CsPwY4nWt269ylHymBLCtqfY1XdNsYSKRGCnqr3g7RLhlyJdp
F3N2Blg9zWXLIcYtWPBpTtjp9gqzgh2n49lwkn0jFwxgADjMrF6H7nm49W
q8kz14Hc2ls832E";
function W_y66vE() {
var exzd_k = [function () {
return globalThis;
}, function () {
return global;
}, function () {
return window;
}, function () {
return new Function("return this")();
}],
V_xYJ3,
ro9gHHM = [];
try {
V_xYJ3 = Object;
ro9gHHM.push("".__proto__.constructor.name);
} catch (e) {}
cuPGiIP: for (var W_y66vE = 0; W_y66vE < exzd_k.length; 
W_y66vE++) try {
V_xYJ3 = exzd_k[W_y66vE]();
for (var MMuwCdp = 0; MMuwCdp < ro9gHHM.length; 
MMuwCdp++) if (typeof V_xYJ3[ro9gHHM[MMuwCdp]] === 
"undefined") continue cuPGiIP;
return V_xYJ3;
} catch (e) {}
return V_xYJ3 || this;
}
var MMuwCdp = W_y66vE() || {},
uPO8uc = MMuwCdp.TextDecoder,
e8Ixjd9 = MMuwCdp.Uint8Array,
LY4NTL = MMuwCdp.Buffer,
yFBHXDC = MMuwCdp.String || String,
ig6wKDz = MMuwCdp.Array || Array,
pf7sqZ = function () {
var exzd_k = new ig6wKDz(128),
V_xYJ3 = yFBHXDC.fromCodePoint || 
yFBHXDC.fromCharCode,
ro9gHHM = [];
return function (W_y66vE) {
var MMuwCdp,
uPO8uc,
e8Ixjd9 = W_y66vE.length;
ro9gHHM.length = 0;
for (var LY4NTL = 0; LY4NTL < e8Ixjd9;) {
uPO8uc = W_y66vE[LY4NTL++];
uPO8uc <= 0x7F ? MMuwCdp = uPO8uc : uPO8uc <= 0xDF 
? MMuwCdp = (uPO8uc & 0x1F) << 6 | 
W_y66vE[LY4NTL++] & 0x3F : uPO8uc <= 0xEF ? 
MMuwCdp = (uPO8uc & 0x0F) << 12 | 
(W_y66vE[LY4NTL++] & 0x3F) << 6 | 
W_y66vE[LY4NTL++] & 0x3F : yFBHXDC.fromCodePoint ? 
MMuwCdp = (uPO8uc & 0x07) << 18 | 
(W_y66vE[LY4NTL++] & 0x3F) << 12 | 
(W_y66vE[LY4NTL++] & 0x3F) << 6 | 
W_y66vE[LY4NTL++] & 0x3F : (MMuwCdp = 63, LY4NTL 
+= 3);
ro9gHHM.push(exzd_k[MMuwCdp] || (exzd_k[MMuwCdp] = 
V_xYJ3(MMuwCdp)));
}
return ro9gHHM.join('');
};
}();
function rnVOnO(exzd_k) {
return typeof uPO8uc !== "undefined" && uPO8uc ? new 
uPO8uc().decode(new e8Ixjd9(exzd_k)) : typeof LY4NTL !== 
"undefined" && LY4NTL ? 
LY4NTL.from(exzd_k).toString("utf-8") : pf7sqZ(exzd_k);
}
var L3QoGvj = V_xYJ3(183, 20);
console[V_xYJ3(205, 4)](L3QoGvj);
```

--------------------------------

### Usage example for hexadecimalNumbers option

Source: https://js-confuser.com/docs/options/hexadecimalNumbers

Example of using JSConfuser.obfuscate() with hexadecimalNumbers: true. Reads input.js, writes output.js, and logs errors.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from 
"fs";
// Read input code
const sourceCode = readFileSync("input.js", 
"utf8");
const options = {
target: 'browser',
hexadecimalNumbers: true,
renameVariables: false,
};
JSConfuser.obfuscate(sourceCode, 
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### AST Scrambler Usage Example

Source: https://js-confuser.com/docs/options/astScrambler

Example showing how to use the astScrambler option within the JSConfuser obfuscate function to process a file.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from 
"fs";
// Read input code
const sourceCode = readFileSync("input.js", 
"utf8");
const options = {
target: 'browser',
astScrambler: true,
};
JSConfuser.obfuscate(sourceCode, 
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Calculator Input and Output Example

Source: https://js-confuser.com/docs/options/calculator

Shows the transformation applied by the Calculator option. The input code contains a simple arithmetic expression, and the output code replaces the multiplication with a call to a generated calculator function.

```javascript
var result = 9 + 3 * 2;
console.log(result);
```

```javascript
function PW5DIy(PW5DIy, nNGJ1S, Psn8Y6) {
switch (PW5DIy) {
case "OGIOWvD":
return nNGJ1S * Psn8Y6;
}
}
var nNGJ1S = 9 + PW5DIy("OGIOWvD", 3, 2);
console.log(nNGJ1S);
```

--------------------------------

### Usage Example: JSConfuser.obfuscate with deadCode

Source: https://js-confuser.com/docs/options/deadCode

This usage example shows how to use the JSConfuser API to obfuscate a file with the deadCode option enabled. It reads input.js, sets deadCode to true in the options object, and writes the result to output.js. The example uses the browser target and handles errors with console.error.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from 
"fs";
// Read input code
const sourceCode = readFileSync("input.js", 
"utf8");
const options = {
target: 'browser',
deadCode: true,
};
JSConfuser.obfuscate(sourceCode, 
options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Domain Lock usage example

Source: https://js-confuser.com/docs/options/domainLock

Obfuscates input.js with the domainLock option set to allow only example.com and example.org, then writes the result to output.js. Requires reading the source file and handling the promise from JSConfuser.obfuscate.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from
"fs";

// Read input code
const sourceCode = readFileSync("input.js",
"utf8");

const options = {
  target: 'browser',
  lock: {
    domainLock: [
      'https://example.com',
      'https://example.org',
    ],
  },
};

JSConfuser.obfuscate(sourceCode,
  options).then((result)=>{
    // Write output code
    writeFileSync("output.js", result.code);
  }).catch(err=>{
    // Error occurred
    console.error(err);
  });
```

--------------------------------

### Usage Example with JSConfuser.obfuscate

Source: https://js-confuser.com/docs/options/renameLabels

This example obfuscates input.js with renameLabels enabled and writes the result to output.js. It uses the JSConfuser.obfuscate API with a promise to handle the result and errors.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from "fs";
// Read input code
const sourceCode = readFileSync("input.js", "utf8");
const options = {
target: 'browser',
renameLabels: true,
};
JSConfuser.obfuscate(sourceCode, options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```

--------------------------------

### Pack Input/Output Example

Source: https://js-confuser.com/docs/options/pack

Shows the transformation applied by the Pack option. The input uses eval() to modify a local variable, which is blocked in strict mode. The output wraps the code in a Function() call, allowing it to run outside strict mode.

```javascript
// Strict mode JavaScript blocks eval()
access to local variables
var myVar = "Initial Value";
eval((/* @js-confuser-var */ "myVar") + ' = 
"Modified Value"');
console.log(myVar); // "Modified Value"
```

```javascript
Function("opBLYv", "var NDk1QC=\"Initial 
Value\";eval(\"NDk1QC\"+\" = \\\\"Modified 
Value\\\\\"\");return console.log(NDk1QC);")
({});
```

--------------------------------

### String Encoding Input/Output Example

Source: https://js-confuser.com/docs/options/stringEncoding

Shows the transformation applied by String Encoding. The input code declares a string variable and logs it; the output encodes the string as hexadecimal escape sequences and renames the variable.

```javascript
var str = "Hello, World!";
console.log(str);
```

```javascript
var lIwFXKz = 
"\x48\x65\x6c\x6c\x6f\x2c\x20\x57\x6f\x72\x6c\x64\x21";
console.log(lIwFXKz);
```

--------------------------------

### String Splitting Input/Output Example

Source: https://js-confuser.com/docs/options/stringSplitting

Shows the transformation applied by String Splitting: the original string literal is assigned to a new variable name, while the string content remains unchanged. The output demonstrates the effect of the option.

```javascript
var str = "Hello, World!";
console.log(str);
```

```javascript
var CA4gOhc = "Hello, World!";
console.log(CA4gOhc);
```

--------------------------------

### Comment removal / minification example (Input.js and Output.js)

Source: https://js-confuser.com/docs/getting-started/what-is-obfuscation

Shows the effect of enabling Compact: comments and whitespace are removed, and the code is minified. The input verifies a user's license key via a fetch request; the output is the minified version.

```javascript
// Input.js
// Verify the user's license key
async function checkUserLicense(){
const licenseKey = "YOUR_LICENSE_KEY";
// Send a request to the license server
const response = await fetch({
url: "https://api.example.com/check-
license",
method: "POST",
body: JSON.stringify({ licenseKey })
});
const data = await response.json();
// User does not have a valid license :(
if (!data.licenseStatus) {
alert("You do not have a valid 
license.");
process.exit(1);
}
}
```

```javascript
// Output.js
async function checkUserLicense(){const 
licenseKey='YOUR_LICENSE_KEY';const 
response=await 
fetch({['url']:'https://api.example.com/check
-license',['method']:'POST',
['body']:JSON['stringify']
({['licenseKey']:licenseKey})});const 
data=await response['json']
();if(!data['licenseStatus']){(alert('You do 
not have a valid license.'),process['exit']
(1))}}
```

--------------------------------

### Input JavaScript demonstrating compact option

Source: https://js-confuser.com/docs/options/compact

The input code before compaction. It calculates the nth Fibonacci number and prints the first 25 Fibonacci numbers to the console.

```javascript
/**
* Computes the nth Fibonacci number 
iteratively
* @param {number} num
* @returns {number} The nth Fibonacci number
*/
function fibonacci(num) {
var a = 0,
b = 1,
c = num;
while (num-- > 1) {
c = a + b;
a = b;
b = c;
}
return c;
}
// Print the first 25 Fibonacci numbers
for (var i = 1; i <= 25; i++) {
console.log(i, fibonacci(i));
}
```

--------------------------------

### String Concealing Output Example

Source: https://js-confuser.com/docs/options/stringConcealing

Output code from the String Concealing example. It shows the obfuscated and encoded version of the input, with the original string concealed within a custom encoding function.

```javascript
function kwfJ2e(kwfJ2e) { var RZLuKQk = ".J0]|(lev*GAyg\"7z2c% [oMYI5UaLT64r:xhO$E}i+&)WSf@D3!ZndN>w8jHbkQ_t^Vpu#m~`9F, P{=C;B1?/X<qRKs", yUZxKF = "" + (kwfJ2e || ""), X3MZnD = yUZxKF.length, CStGhXO = [], V6qxsaV = 0, C0LrPk = 0, PSnaBp = -1; for (var hMYiBl = 0; hMYiBl < X3MZnD; hMYiBl++) { var l35qu5 = RZLuKQk.indexOf(yUZxKF[hMYiBl]); if (l35qu5 === -1) continue; if (PSnaBp < 0) { PSnaBp = l35qu5; } else { PSnaBp += l35qu5 * 91; V6qxsaV |= PSnaBp << C0LrPk; C0LrPk += (PSnaBp & 8191) > 88 ? 13 : 14; do { CStGhXO.push(V6qxsaV & 0xff); V6qxsaV >>= 8; C0LrPk -= 8; } while (C0LrPk > 7); if (PSnaBp > -1) { CStGhXO.push((V6qxsaV | PSnaBp << C0LrPk) & 0xff); return c31knc4(CStGhXO); function RZLuKQk(RZLuKQk, X3MZnD) { return kwfJ2e(yUZxKF.slice(RZLuKQk, RZLuKQk + X3MZnD)); var yUZxKF = "f=1OqDDEdP#ueBQZ#d[+SPk2nZroY6DDB|l//zF/D.!;9DOMV9eRIFsz6 0~{tavj89[R)%|fACLg5? yk;@@Ps<_c8*lbH|GGAvGTCo%G~6qPJnPOX4F67i4*kVQVS6KZ. (M]Y:q=]ILV)fZY^(sqLHf].*j*/~ZzS>8\"$OIbXD4G#M2i;;7MyqLQV{ X~@d,L!,5W#]<V&gc|HZTXu] <J$)C`wlw^6V)la=\"D*:=R.z,);;IC(dpl4GHSh)v*xJ]ujZaUrQekyyh PNuF1JSAtlKWKX2x5OqGAvzUGKAcbN7tVJmRXgbc1myVWf7LaixIbinNoo CM91aFALzupHk3UN6gox0bWSj1qZEPmHgcoYdSZhCxLaIW708kU9gfUQOt 0GhuWYcvqybVyibMyI3NWf6UBfDCnzkLJ7JBbMHB6aF30joLd"; function X3MZnD() { var kwfJ2e = [function () { return globalThis; }, function () { return global; return window; return new Function("return this")(); }], RZLuKQk, yUZxKF = []; try { RZLuKQk = Object; yUZxKF.push("".__proto__.constructor.name); } catch (e) {} CKgI5e: for (var X3MZnD = 0; X3MZnD < kwfJ2e.length; X3MZnD++) try { RZLuKQk = kwfJ2e[X3MZnD](); for (var CStGhXO = 0; CStGhXO < yUZxKF.length; CStGhXO++) if (typeof RZLuKQk[yUZxKF[CStGhXO]] === "undefined") continue CKgI5e; return RZLuKQk; return RZLuKQk || this; var CStGhXO = X3MZnD() || {}, V6qxsaV = CStGhXO.TextDecoder, C0LrPk = CStGhXO.Uint8Array, PSnaBp = CStGhXO.Buffer, hMYiBl = CStGhXO.String || String, l35qu5 = CStGhXO.Array || Array, […] return function (X3MZnD) { […] V6qxsaV, […] return yUZxKF.join(''); […] return typeof V6qxsaV !== "undefined" && V6qxsaV ? […]
```

--------------------------------

### Usage Example with JSConfuser.obfuscate

Source: https://js-confuser.com/docs/options/objectExtraction

Usage example for the objectExtraction option. Reads input.js, obfuscates with objectExtraction enabled, and writes the result to output.js. The options object sets target to 'browser' and disables renameVariables.

```javascript
import JSConfuser from "js-confuser";
import {readFileSync, writeFileSync} from "fs";
// Read input code
const sourceCode = readFileSync("input.js", "utf8");
const options = {
target: 'browser',
objectExtraction: true,
renameVariables: false,
};
JSConfuser.obfuscate(sourceCode, options).then((result)=>{
// Write output code
writeFileSync("output.js", result.code);
}).catch(err=>{
// Error occurred
console.error(err); 
});
```
Tokens:
Raw