jsarmor 1.0.4 → 1.0.6

package/LICENSE

@@ -0,0 +1,76 @@
+JSArmor License 
+
+Copyright (c) 2026 Swp-dev
+
+This license governs the use of the JSArmor software.
+
+Permission is granted to use, modify, and distribute this software for
+personal, educational, and non-commercial purposes under the following
+conditions.
+
+1. Attribution Required
+
+Any use, modification, or redistribution of this software must clearly
+credit the original author.
+
+Author: Swp-dev
+Project: JSArmor
+
+The credit must appear in:
+
+* documentation
+* repository
+* distributed binaries
+* CLI output (if applicable)
+
+2. Non-Commercial Restriction
+
+This software may NOT be sold, sublicensed, or included in any paid
+software, service, or product without explicit written permission
+from the author.
+
+This includes but is not limited to:
+
+* selling modified versions
+* bundling with commercial software
+* offering it as a paid obfuscation service
+
+3. No Removal of Author Signature
+
+You may not remove or alter:
+
+* author credits
+* runtime signatures
+* watermark identifiers
+* protection markers embedded in the software
+
+4. Redistribution Requirements
+
+If you distribute this software or modified versions, you must:
+
+* include this license
+* clearly indicate that the project is derived from JSArmor
+* provide attribution to the original author
+
+5. No False Representation
+
+You may not claim that you are the original creator of this software.
+
+6. Disclaimer of Warranty
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NONINFRINGEMENT.
+
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES,
+OR OTHER LIABILITY ARISING FROM THE USE OF THIS SOFTWARE.
+
+7. Violations
+
+Any violation of these terms automatically revokes permission to
+use this software.
+
+For commercial licensing inquiries contact:
+
+https://eboy.asia/p.n

package/README.md

@@ -0,0 +1,217 @@
+<p align="center">
+<img src="docs/banner.jpg" width="300">
+</p>
+
+<h1 align="center">JSArmor</h1>
+
+<p align="center">
+Advanced JavaScript Obfuscator for protecting source code.
+</p>
+
+<p align="center">
+
+![npm](https://img.shields.io/npm/v/jsarmor?logo=npm)
+![downloads](https://img.shields.io/npm/dm/jsarmor?logo=npm)
+![stars](https://img.shields.io/github/stars/Swp-dev/JavascriptArmor?logo=github)
+![license](https://img.shields.io/badge/license-JSArmor%20License-blue)
+
+</p>
+
+---
+
+## Overview
+
+**JSArmor** is a lightweight JavaScript obfuscator designed to protect source code from reverse engineering.
+
+It transforms readable JavaScript into a more complex and difficult-to-analyze form while preserving runtime behavior.
+
+The goal of JSArmor is to provide **simple CLI usage with strong code protection techniques.**
+> The idea for this project was taken from  [Pyarmor](https://github.com/dashingsoft/pyarmor)
+
+---
+
+## Features
+
+* String encryption
+* Variable and function renaming
+* Control flow obfuscation
+* Dead code injection
+* Unicode encoding
+* Anti-debugging protection
+* Self-defending runtime
+
+These techniques increase the difficulty of reverse engineering and static analysis.
+
+---
+
+## Installation
+
+Install globally using npm.
+
+```bash
+npm install jsarmor
+```
+
+---
+
+## Quick Start
+
+Obfuscate a JavaScript file:
+
+```bash
+jsarmor gen <main file>
+Ex: jsarmor gen index.js
+```
+
+Output will be generated in:
+
+```
+dist/obf.js
+```
+
+Run the protected file normally with Node.js.
+
+```bash
+node dist/obf.js
+```
+
+---
+
+## Demo
+
+### Before Obfuscation
+
+```javascript
+function greet(name) {
+  const message = "Hello " + name
+  console.log(message)
+}
+
+greet("world")
+```
+
+---
+
+### After Obfuscation
+
+```javascript
+(function(_0x2a41c2,_0x3e8f7a){
+const _0x5f3b=['log','Hello','world']
+(function(_0x11b2c3,_0x58e0f1){
+while(!![]){
+try{
+const _0x12c8d9=parseInt(_0x11b2c3())+parseInt(_0x11b2c3())
+if(_0x12c8d9===_0x58e0f1)break
+else _0x5f3b.push(_0x5f3b.shift())
+}catch(_0x1c7b45){
+_0x5f3b.push(_0x5f3b.shift())
+}}
+})(function(){return _0x5f3b.shift()},0x1234)
+
+console[_0x5f3b[0]](_0x5f3b[1]+' '+_0x5f3b[2])
+})()
+```
+
+---
+
+## Project Structure
+
+```
+jsarmor
+ ├ cli/
+ │  └ index.js
+ ├ core/
+ │  ├ antidebug.js
+ │  ├ beautifyGuard.js
+ │  ├ controlflow.js
+ │  ├ deadcode.js
+ │  ├ junkcode.js
+ │  ├ parser.js
+ │  ├ rc4.js
+ │  ├ renamer.js
+ │  ├ runtime.js
+ │  ├ selfdefend.js
+ │  ├ stringArray.js
+ │  └ unicode.js
+ └ utils/
+    └ random.js
+```
+
+---
+
+## Roadmap
+
+### Version 2 (unlock at ⭐ 15 stars)
+
+Planned features:
+
+* Multiple obfuscation levels (low / medium / high)
+* Stronger string encryption
+* CLI output customization
+* Improved dead code generation
+
+---
+
+### Version 3 (unlock at ⭐ 100 stars)
+
+Planned advanced protection:
+
+* JavaScript VM-based obfuscation
+* Advanced anti-debugging techniques
+* Anti-tamper protection
+* Runtime integrity checks
+* Code virtualization
+* Web Dashboard
+
+---
+
+## Contributing
+
+Contributions are welcome.
+
+You can help by:
+
+* Reporting bugs
+* Suggesting new obfuscation techniques
+* Improving performance
+* Opening pull requests
+
+---
+
+## Support
+
+If you encounter issues or have questions:
+
+Open an issue on GitHub in [here](https://github.com/Swp-dev/JavascriptArmor/issues).
+
+For direct contact:
+
+Link Bio
+
+```
+https://eboy.asia/p.n
+```
+
+GitHub
+
+```
+https://github.com/Swp-dev/JavascriptArmor
+```
+
+Follow me on the tiktok
+
+```
+https://tiktok.com/@niemtinthatxaxi
+```
+
+---
+
+## License
+
+MIT License
+
+---
+
+<p align="center">
+Built for developers who want to protect JavaScript code.
+</p>

package/cli/index.js

@@ -1,177 +1,177 @@
 #!/usr/bin/env node
-
-import fs from "fs";
-import path from "path";
-import chalk from "chalk";
-import gradient from "gradient-string";
-import cliProgress from "cli-progress";
-import generate from "@babel/generator";
-
-import { parseCode } from "../core/parser.js";
-import { renameVariables } from "../core/renamer.js";
-import { encodeStrings } from "../core/stringArray.js";
-import { flattenControlFlow } from "../core/controlflow.js";
-import { unicodeEscape } from "../core/unicode.js";
-import { generateJunk } from "../core/junkcode.js";
-
-import { injectDeadCode, generateDeadRuntime } from "../core/deadcode.js";
-
-import { injectAntiDebug } from "../core/antidebug.js";
-import { antiBeautify } from "../core/beautifyGuard.js";
-import { selfDefend } from "../core/selfdefend.js";
-
-const neon = gradient(["#00ffff","#ff00ff","#00ff9f"]);
-
-try{
-
-const args = process.argv.slice(2);
-
-const command = args[0];
-const file = args[1];
-
-let outputName = "obf.js";
-
-const outIndex = args.indexOf("-o");
-
-if(outIndex !== -1 && args[outIndex+1]){
-outputName = args[outIndex+1];
-}
-
-if(!command || command === "help"){
-
-console.log(neon(`
-JSArmor - JavaScript Obfuscator
-
-Usage:
-
-jsarmor gen input.js
-jsarmor gen input.js -o output.js
-
-`));
-
-process.exit(0);
-
-}
-
-if(command !== "gen"){
-
-console.log(chalk.red("Unknown command"));
-console.log("Use: jsarmor gen input.js");
-
-process.exit(1);
-
-}
-
-if(!file){
-
-console.log(chalk.red("Please provide input file"));
-console.log("Usage: jsarmor gen input.js");
-
-process.exit(1);
-
-}
-
-if(!fs.existsSync(file)){
-console.log(chalk.red(`File not found: ${file}`));
-process.exit(1);
-}
-
-let code = fs.readFileSync(file,"utf8");
-
-let shebang = "";
-
-if(code.startsWith("#!")){
-const end = code.indexOf("\n");
-shebang = code.slice(0,end);
-code = code.slice(end);
-}
-
-console.log(
-neon(`┌──────────────────────────────┐
-│     NodeJS Obfuscator v3     │
-└──────────────────────────────┘`)
-);
-
-const bar = new cliProgress.SingleBar({
-format:"progress [{bar}] {percentage}% | {value}/{total}",
-barCompleteChar:"█",
-barIncompleteChar:"░"
-});
-
-bar.start(6,0);
-
-const ast = parseCode(code);
-bar.increment();
-
-renameVariables(ast);
-bar.increment();
-
-const pool = encodeStrings(ast);
-bar.increment();
-
-/* dead code transform */
-injectDeadCode(ast);
-bar.increment();
-
-flattenControlFlow(ast);
-bar.increment();
-
-unicodeEscape(ast);
-bar.increment();
-
-bar.stop();
-
-const output = generate.default(ast,{
-jsescOption:{
-minimal:true
-}
-}).code;
-
-const runtimeJunk = generateDeadRuntime();
-
-const final =
-(shebang ? shebang + "\n" : "") +
-injectAntiDebug() +
-antiBeautify() +
-selfDefend() +
-`var _STRINGS=${JSON.stringify(pool)};\n` +
-runtimeJunk +
-generateJunk() +
-output;
-
-const distDir = path.join(process.cwd(),"dist");
-
-if(!fs.existsSync(distDir)){
-fs.mkdirSync(distDir,{recursive:true});
-}
-
-const outFile = path.join(distDir,"obf.js");
-
-fs.writeFileSync(outFile,final);
-
-console.log();
-console.log(chalk.green("✔ Parsing AST"));
-console.log(chalk.green("✔ Variables renamed"));
-console.log(chalk.green("✔ Strings encoded"));
-console.log(chalk.green("✔ Dead code injected"));
-console.log(chalk.green("✔ Control flow flattened"));
-console.log(chalk.green("✔ Unicode escape applied"));
-console.log();
-console.log(chalk.bold.green("✔ Obfuscation Complete"));
-console.log(chalk.cyan(`Output: ${outFile}`));
-
-const originalSize = code.length;
-const newSize = final.length;
-
-console.log(
-chalk.yellow(
-`Size: ${(originalSize/1024).toFixed(2)} KB → ${(newSize/1024).toFixed(2)} KB`
-)
-);
-
-}catch(err){
-
-console.log(chalk.red("Obfuscation failed"));
-console.error(err);
-
-}
+
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import gradient from "gradient-string";
+import cliProgress from "cli-progress";
+import generate from "@babel/generator";
+
+import { parseCode } from "../core/parser.js";
+import { renameVariables } from "../core/renamer.js";
+import { encodeStrings } from "../core/stringArray.js";
+import { flattenControlFlow } from "../core/controlflow.js";
+import { unicodeEscape } from "../core/unicode.js";
+import { generateJunk } from "../core/junkcode.js";
+
+import { injectDeadCode, generateDeadRuntime } from "../core/deadcode.js";
+
+import { injectAntiDebug } from "../core/antidebug.js";
+import { antiBeautify } from "../core/beautifyGuard.js";
+import { selfDefend } from "../core/selfdefend.js";
+
+const neon = gradient(["#00ffff","#ff00ff","#00ff9f"]);
+
+try{
+
+const args = process.argv.slice(2);
+
+const command = args[0];
+const file = args[1];
+
+let outputName = "obf.js";
+
+const outIndex = args.indexOf("-o");
+
+if(outIndex !== -1 && args[outIndex+1]){
+outputName = args[outIndex+1];
+}
+
+if(!command || command === "help"){
+
+console.log(neon(`
+JSArmor - JavaScript Obfuscator
+
+Usage:
+
+jsarmor gen input.js
+jsarmor gen input.js -o output.js
+
+`));
+
+process.exit(0);
+
+}
+
+if(command !== "gen"){
+
+console.log(chalk.red("Unknown command"));
+console.log("Use: jsarmor gen input.js");
+
+process.exit(1);
+
+}
+
+if(!file){
+
+console.log(chalk.red("Please provide input file"));
+console.log("Usage: jsarmor gen input.js");
+
+process.exit(1);
+
+}
+
+if(!fs.existsSync(file)){
+console.log(chalk.red(`File not found: ${file}`));
+process.exit(1);
+}
+
+let code = fs.readFileSync(file,"utf8");
+
+let shebang = "";
+
+if(code.startsWith("#!")){
+const end = code.indexOf("\n");
+shebang = code.slice(0,end);
+code = code.slice(end);
+}
+
+console.log(
+neon(`┌──────────────────────────────┐
+│     NodeJS Obfuscator v3     │
+└──────────────────────────────┘`)
+);
+
+const bar = new cliProgress.SingleBar({
+format:"progress [{bar}] {percentage}% | {value}/{total}",
+barCompleteChar:"█",
+barIncompleteChar:"░"
+});
+
+bar.start(6,0);
+
+const ast = parseCode(code);
+bar.increment();
+
+renameVariables(ast);
+bar.increment();
+
+const pool = encodeStrings(ast);
+bar.increment();
+
+/* dead code transform */
+injectDeadCode(ast);
+bar.increment();
+
+flattenControlFlow(ast);
+bar.increment();
+
+unicodeEscape(ast);
+bar.increment();
+
+bar.stop();
+
+const output = generate.default(ast,{
+jsescOption:{
+minimal:true
+}
+}).code;
+
+const runtimeJunk = generateDeadRuntime();
+
+const final =
+(shebang ? shebang + "\n" : "") +
+injectAntiDebug() +
+antiBeautify() +
+selfDefend() +
+`var _STRINGS=${JSON.stringify(pool)};\n` +
+runtimeJunk +
+generateJunk() +
+output;
+
+const distDir = path.join(process.cwd(),"dist");
+
+if(!fs.existsSync(distDir)){
+fs.mkdirSync(distDir,{recursive:true});
+}
+
+const outFile = path.join(distDir,"obf.js");
+
+fs.writeFileSync(outFile,final);
+
+console.log();
+console.log(chalk.green("✔ Parsing AST"));
+console.log(chalk.green("✔ Variables renamed"));
+console.log(chalk.green("✔ Strings encoded"));
+console.log(chalk.green("✔ Dead code injected"));
+console.log(chalk.green("✔ Control flow flattened"));
+console.log(chalk.green("✔ Unicode escape applied"));
+console.log();
+console.log(chalk.bold.green("✔ Obfuscation Complete"));
+console.log(chalk.cyan(`Output: ${outFile}`));
+
+const originalSize = code.length;
+const newSize = final.length;
+
+console.log(
+chalk.yellow(
+`Size: ${(originalSize/1024).toFixed(2)} KB → ${(newSize/1024).toFixed(2)} KB`
+)
+);
+
+}catch(err){
+
+console.log(chalk.red("Obfuscation failed"));
+console.error(err);
+
+}

package/core/antidebug.js

@@ -1,15 +1,15 @@
-export function injectAntiDebug(){
-
-return `
-
-(function(){
-setInterval(function(){
-try{
-(function(){debugger})()
-}catch(e){}
-},2000)
-})();
-
-`;
-
-}
+export function injectAntiDebug(){
+
+return `
+
+(function(){
+setInterval(function(){
+try{
+(function(){debugger})()
+}catch(e){}
+},2000)
+})();
+
+`;
+
+}

package/docs/shitpost

@@ -0,0 +1 @@
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsarmor",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Advanced JavaScript Obfuscator",
   "type": "module",
   "main": "cli/index.js",
@@ -10,27 +10,36 @@
   "scripts": {
     "start": "node cli/index.js"
   },
-  "dependencies": {
-    "@babel/parser": "^7.26.0",
-    "@babel/traverse": "^7.26.0",
-    "@babel/types": "^7.26.0",
-    "@babel/generator": "^7.26.0",
-    "chalk": "^5.3.0",
-    "gradient-string": "^2.0.2",
-    "cli-progress": "^3.12.0"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Swp-dev/JavascriptArmor.git"
+  },
+  "homepage": "https://github.com/Swp-dev/JavascriptArmor",
+  "bugs": {
+    "url": "https://github.com/Swp-dev/JavascriptArmor/issues"
   },
-  "keywords": [
-    "obfuscator",
-    "javascript",
-    "security",
-    "jsarmor"
-  ],
   "files": [
     "cli",
     "core",
     "utils",
     "docs"
   ],
+  "keywords": [
+    "javascript",
+    "obfuscator",
+    "security",
+    "protection",
+    "jsarmor"
+  ],
   "author": "_kingktn",
-  "license": "MIT"
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "@babel/parser": "^7.26.0",
+    "@babel/traverse": "^7.26.0",
+    "@babel/types": "^7.26.0",
+    "@babel/generator": "^7.26.0",
+    "chalk": "^5.3.0",
+    "gradient-string": "^2.0.2",
+    "cli-progress": "^3.12.0"
+  }
 }

package/readme.md

@@ -1,163 +0,0 @@
-<p align="center">
-<img src="docs/banner.jpg" width="300">
-</p>
-
-<h1 align="center">JSArmor</h1>
-
-<p align="center">
-A lightweight JavaScript obfuscator for protecting source code from reverse engineering.
-</p>
-
-<p align="center">
-
-![npm version](https://img.shields.io/npm/v/jsarmor?logo=npm)
-![npm downloads](https://img.shields.io/npm/dm/jsarmor?logo=npm)
-![last commit](https://img.shields.io/github/last-commit/Swp-dev/JavascriptArmor)
-![license](https://img.shields.io/github/license/Swp-dev/JavascriptArmor)
-
-</p>
-
----
-
-## Overview
-
-JSArmor transforms readable JavaScript into a more complex form while preserving runtime behavior.
-
-It is designed for developers who want a **simple CLI tool to protect their code** from reverse engineering.
-
----
-
-# Installation
-
-Install globally using npm
-
-```bash
-npm install -g jsarmor
-```
-
-Or use it inside a project:
-
-```bash
-npm install jsarmor
-```
-
----
-
-# Quick Start
-
-Obfuscate a JavaScript file:
-
-```bash
-jsarmor gen input.js
-```
-
-Output will be generated in:
-
-```
-dist/obf.js
-```
-
-Run it normally:
-
-```bash
-node dist/obf.js
-```
-
----
-
-# Example
-
-## Input
-
-```javascript
-function greet(name) {
-  const message = "Hello " + name
-  console.log(message)
-}
-
-greet("world")
-```
-
----
-
-## Output (obfuscated)
-
-```javascript
-(function(_0x1a2b){
-const _0x3f21=['log','Hello','world'];
-console[_0x3f21[0]](_0x3f21[1]+' '+_0x3f21[2]);
-})();
-```
-
-The output code becomes significantly harder to understand and analyze.
-
----
-
-# Features
-
-* String encryption
-* Variable renaming
-* Control flow obfuscation
-* Dead code injection
-* Unicode encoding
-* Anti-debug protection
-* Self defending runtime
-
----
-
-# CLI
-
-Basic command:
-
-```bash
-jsarmor gen <input.js>
-```
-
-Example:
-
-```bash
-jsarmor gen app.js
-```
-
-Result:
-
-```
-dist/obf.js
-```
-
----
-
-# Use Cases
-
-JSArmor can be used for:
-
-* protecting commercial JavaScript code
-* distributing protected CLI tools
-* hiding business logic
-* making reverse engineering harder
-
----
-
-# Support
-
-If you encounter problems or have questions:
-
-GitHub Issues
-
-```
-https://github.com/Swp-dev/JavascriptArmor
-```
-
-Contact
-
-```
-https://eboy.asia/p.n
-```
-
----
-
-# License
-
-MIT License
-
-This project is licensed under the MIT License – you are free to use, modify and distribute it.