javascript-obfuscator

KO | EN

gitlite — search

#javascript #hacktoberfest #typescript #golang #machine-learning #deep-learning #docker #macos #java #nodejs #awesome #security #openai #open-source

javascript-obfuscator

(★ 16,197)

JavaScript와 Node.js를 위한 강력한 난독화 도구

javascript-obfuscator 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# JavaScript obfuscator
![logo](https://raw.githubusercontent.com/javascript-obfuscator/javascript-obfuscator/master/images/logo.png)
---
### :rocket: VM 난독화가 포함된 Obfuscator.io
[![Obfuscator.io - JavaScript VM Obfuscation](https://raw.githubusercontent.com/javascript-obfuscator/javascript-obfuscator/master/images/obfuscator\_io\_promo.png)](https://obfuscator.io)
\*\*Obfuscator.io\*\*는 이 패키지에 \*\*VM 기반 바이트코드 난독화\*\* 기능을 추가합니다. JavaScript 함수가 임베디드 가상 머신에서 실행되는 커스텀 바이트코드로 컴파일됩니다. 각 빌드마다 고유한 연산 코드(opcode)와 VM 구조가 생성되므로 리버스 엔지니어링과 자동화된 난독화 해제가 극도로 어려워집니다.
| 보호 목표 | 무료 (본 패키지) | [obfuscator.io](https://obfuscator.io) |
| --- |-----------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 식별자 난독화 | ✅ 변수/함수 이름 변경 | ✅ + JavaScript로 노출되지 않는 VM 로컬 심볼 |
| 문자열 난독화 | ✅ 문자열 배열 + base64/rc4 | ✅ + 바이트코드 상수에 내장된 문자열 |
| 제어 흐름 난독화 | ✅ 제어 흐름 평탄화 | ✅ 전체 바이트코드 가상화, [`vmJumpsEncoding`](#vmjumpsencoding) (런타임 연산 점프 타겟), [`vmDeadCodeInjection`](#vmdeadcodeinjection) (가짜 바이트코드 시퀀스) |
| 디컴파일 방지 | ⚠️ 출력이 여전히 JavaScript임 | ✅ 커스텀 연산 코드, [`vmStatefulOpcodes`](#vmstatefulopcodes) (위치 종속 연산 코드 매핑), [`vmMacroOps`](#vmmacroops) (융합된 인스트럭션), [`vmDecoyOpcodes`](#vmdecoyopcodes) (가짜 연산 코드 핸들러) |
| 자동화된 LLM 기반 분석 대응 | ❌ 완전 취약 (LLM 전용 방어 기능 없음) | ✅ 바이트코드 암호화 + [`vmSelfDefending`](#vmselfdefending) 및 [`vmDebugProtection`](#vmdebugProtection)의 LLM 방어 기능 |
| 암호화 | ✅ [`stringArrayEncoding`](#stringarrayencoding) (추출된 문자열에 base64/rc4 적용) | ✅ [`vmBytecodeEncoding`](#vmbytecodeencoding) (인스트럭션별 인코딩), [`vmBytecodeArrayEncoding`](#vmbytecodeArrayEncoding) (단일 블록으로서의 전체 바이트코드 배열) |
| 디버깅 방지 | ✅ `debugProtection` (브라우저 DevTools 동결) | ✅ [`vmDebugProtection`](#vmdebugProtection) (다중 계층 디버깅 및 분석 방지 기능) |
| 변조 탐지 | ✅ `selfDefending` (코드 포맷팅 시 중단) | ✅ [`vmSelfDefending`](#vmselfdefending) (다중 계층 변조 탐지, 후킹 방지, 리버스 엔지니어링 방지 보호) |
| 오프라인 실행, 네트워크 불필요 | ✅ | ❌ obfuscator.io API 사용 (토큰 필요) |
[Obfuscator.io 방문하기](https://obfuscator.io) · [Pro API 메서드](#shield-pro-api-methods-vm-obfuscation)
본 패키지는 CLI와 Node.js API를 통해 Obfuscator.io API에 대한 액세스를 제공합니다.
---
### 회사에서 JavaScript Obfuscator를 사용하고 계신가요?
JavaScript Obfuscator는 \*\*주간 npm 다운로드 수 100만 회\*\*를 돌파했습니다. 저는 현재 \*\*EB-1 이민 케이스\*\*를 준비 중이며, 본 프로젝트의 실제 업무 환경에서의 활용도와 영향력에 대한 독립적인 증거를 수집하고 있습니다.
회사 프로젝트(특히 잘 알려진 기업, 대규모 조직, 또는 널리 사용되는 제품)에서 JavaScript Obfuscator를 사용하고 계시다면, 저에게 연락해 주시면 정말 감사하겠습니다.
유용한 증거에는 간단한 확인서나, 이상적으로는 다음 내용을 다루는 1~2페이지 분량의 추천서가 포함될 수 있습니다:
- 팀이나 회사에서 JavaScript Obfuscator를 사용한 방법;
- 선택한 이유;
- 해결에 도움을 준 문제;
- 프로덕션 또는 중요한 내부 워크플로에서 사용되었는지 여부;
- 본인의 역할 및 사용 경험에 대한 친숙도.
쉽게 작성하실 수 있도록 간단한 초안/템플릿을 제공해 드릴 수 있습니다.
연락처: \*\*referenceletter@obfuscator.io\*\*
프로젝트를 지원해 주셔서 감사합니다.
---
JavaScript Obfuscator는 소스 코드를 보호하는 다양한 기능을 포함한 강력하고 무료인 JavaScript 난독화 도구입니다.
\*\*주요 기

atures:**
- VM 바이트코드 난독화 ([Obfuscator.io](https://obfuscator.io/) 사용)
- 변수 이름 변경
- 문자열 추출 및 암호화
- 데드 코드 삽입
- 제어 흐름 평탄화
- 다양한 코드 변환
- 그리고 [더 보기](#javascript-obfuscator-options)...
난독화된 코드 예시: [github.com](https://github.com/javascript-obfuscator/javascript-obfuscator/blob/master/examples/javascript-obfuscator.js)
#### 온라인 버전:
[obfuscator.io](https://obfuscator.io)
#### 플러그인:
\* Webpack 플러그인: [webpack-obfuscator](https://github.com/javascript-obfuscator/webpack-obfuscator)
\* Webpack 로더: [obfuscator-loader](https://github.com/javascript-obfuscator/obfuscator-loader)
\* Esbuild 플러그인: [esbuild-javascript-obfuscator](https://www.npmjs.com/package/esbuild-javascript-obfuscator)
\* Gulp: [gulp-javascript-obfuscator](https://github.com/javascript-obfuscator/gulp-javascript-obfuscator)
\* Grunt: [grunt-contrib-obfuscator](https://github.com/javascript-obfuscator/grunt-contrib-obfuscator)
\* Rollup: [rollup-plugin-javascript-obfuscator](https://github.com/javascript-obfuscator/rollup-plugin-javascript-obfuscator)
\* Weex: [weex-devtool](https://www.npmjs.com/package/weex-devtool)
\* Malta: [malta-js-obfuscator](https://github.com/fedeghe/malta-js-obfuscator)
\* Netlify 플러그인: [netlify-plugin-js-obfuscator](https://www.npmjs.com/package/netlify-plugin-js-obfuscator)
\* Snowpack 플러그인: [snowpack-javascript-obfuscator](https://www.npmjs.com/package/snowpack-javascript-obfuscator)
\* Vite 플러그인: [vite-plugin-bundle-obfuscator](https://github.com/z0ffy/vite-plugin-bundle-obfuscator)
[![npm version](https://badge.fury.io/js/javascript-obfuscator.svg)](https://badge.fury.io/js/javascript-obfuscator)
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fjavascript-obfuscator%2Fjavascript-obfuscator.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fjavascript-obfuscator%2Fjavascript-obfuscator?ref=badge\_shield)
![Build Status](https://github.com/javascript-obfuscator/javascript-obfuscator/workflows/JavaScript%20Obfuscator%20CI/badge.svg)
[![Coverage Status](https://coveralls.io/repos/github/javascript-obfuscator/javascript-obfuscator/badge.svg)](https://coveralls.io/github/javascript-obfuscator/javascript-obfuscator)
[![Backers on Open Collective](https://opencollective.com/javascript-obfuscator/backers/badge.svg)](https://raw.githubusercontent.com/javascript-obfuscator/javascript-obfuscator/master/)
[![Sponsors on Open Collective](https://opencollective.com/javascript-obfuscator/sponsors/badge.svg)](https://raw.githubusercontent.com/javascript-obfuscator/javascript-obfuscator/master/)
[![xscode](https://img.shields.io/badge/Available%20on-xs%3Acode-blue?style=?style=plastic&logo=appveyor&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAMAAACdt4HsAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAAZQTFRF////////VXz1bAAAAAJ0Uk5T/wDltzBKAAAAlUlEQVR42uzXSwqAMAwE0Mn9L+3Ggtgkk35QwcnSJo9S+yGwM9DCooCbgn4YrJ4CIPUcQF7/XSBbx2TEz4sAZ2q1RAECBAiYBlCtvwN+KiYAlG7UDGj59MViT9hOwEqAhYCtAsUZvL6I6W8c2wcbd+LIWSCHSTeSAAECngN4xxIDSK9f4B9t377Wd7H5Nt7/Xz8eAgwAvesLRjYYPuUAAAAASUVORK5CYII=)](https://xscode.com/sanex3339/javascript-obfuscator)
#### \*참고! master 브랜치의 README는 최신 안정 버전의 README와 일치하지 않을 수 있습니다!\*
#### 질문이 있으신 경우, 먼저 이 섹션을 확인하세요: [FAQ](#frequently-asked-questions)
## :warning: 중요
##### 본인이 소유한 코드만 난독화하세요.
난독화된 코드는 (옵션에 따라) 15~80% 느려지고 파일 크기가 훨씬 커지므로, 벤더 스크립트와 폴리필은 난독화하지 않는 것을 권장합니다.
## 설치 (Installation)
#### Yarn 또는 NPM 사용
Yarn 또는 NPM을 사용하여 패키지를 설치하고 `dependencies` 또는 `devDependencies`에 추가하세요:
```sh
$ yarn add --dev javascript-obfuscator
```
또는
```sh
$ npm install --save-dev javascript-obfuscator
```
#### 브라우저에서 사용
CDN 이용:
```html
```
`node\_modules` 이용:
```html
```
## 사용법 (Usage)
```javascript

```javascript
var JavaScriptObfuscator = require('javascript-obfuscator');
var obfuscationResult = JavaScriptObfuscator.obfuscate(
`
(function(){
var variable1 = '5' - 3;
var variable2 = '5' + 3;
var variable3 = '5' + - '2';
var variable4 = ['10','10','10','10','10'].map(parseInt);
var variable5 = 'foo ' + 1 + 1;
console.log(variable1);
console.log(variable2);
console.log(variable3);
console.log(variable4);
console.log(variable5);
})();
`,
{
compact: false,
controlFlowFlattening: true,
controlFlowFlatteningThreshold: 1,
numbersToExpressions: true,
simplify: true,
stringArrayShuffle: true,
splitStrings: true,
stringArrayThreshold: 1
}
);
console.log(obfuscationResult.getObfuscatedCode());
/\*
var \_0x9947 = [
'map',
'log',
'foo\x20',
'bvmqO',
'133039ViRMWR',
'xPfLC',
'ytpdx',
'1243717qSZCyh',
'2|7|4|6|9|',
'1ErtbCr',
'1608314VKvthn',
'1ZRaFKN',
'XBoAA',
'423266kQOYHV',
'3|0|5|8|1',
'235064xPNdKe',
'13RUDZfG',
'157gNPQGm',
'1639212MvnHZL',
'rDjOa',
'iBHph',
'9926iRHoRl',
'split'
];
function \_0x33e4(\_0x1809b5, \_0x37ef6e) {
return \_0x33e4 = function (\_0x338a69, \_0x39ad79) {
\_0x338a69 = \_0x338a69 - (0x1939 + -0xf \* 0x1f3 + 0x1 \* 0x469);
var \_0x2b223a = \_0x9947[\_0x338a69];
return \_0x2b223a;
}, \_0x33e4(\_0x1809b5, \_0x37ef6e);
}
(function (\_0x431d87, \_0x156c7f) {
var \_0x10cf6e = \_0x33e4;
while (!![]) {
try {
var \_0x330ad1 = -parseInt(\_0x10cf6e(0x6c)) \* -parseInt(\_0x10cf6e(0x6d)) + -parseInt(\_0x10cf6e(0x74)) \* -parseInt(\_0x10cf6e(0x78)) + parseInt(\_0x10cf6e(0x6a)) + -parseInt(\_0x10cf6e(0x70)) + parseInt(\_0x10cf6e(0x6e)) \* -parseInt(\_0x10cf6e(0x75)) + parseInt(\_0x10cf6e(0x72)) + -parseInt(\_0x10cf6e(0x67)) \* parseInt(\_0x10cf6e(0x73));
if (\_0x330ad1 === \_0x156c7f)
break;
else
\_0x431d87['push'](\_0x431d87['shift']());
} catch (\_0x9f878) {
\_0x431d87['push'](\_0x431d87['shift']());
}
}
}(\_0x9947, -0xb6270 + 0x4dfd2 \* 0x2 + 0x75460 \* 0x2), function () {
var \_0x1f346d = \_0x33e4, \_0x860db8 = {
'ytpdx': \_0x1f346d(0x6b) + \_0x1f346d(0x71),
'bvmqO': function (\_0x560787, \_0x519b9e) {
return \_0x560787 - \_0x519b9e;
},
'rDjOa': function (\_0x4501fe, \_0x2b07a3) {
return \_0x4501fe + \_0x2b07a3;
},
'xPfLC': function (\_0x5f3c9b, \_0x434936) {
return \_0x5f3c9b + \_0x434936;
},
'XBoAA': function (\_0x535b8a, \_0x42eef4) {
return \_0x535b8a + \_0x42eef4;
},
'iBHph': \_0x1f346d(0x65)
}, \_0x346c55 = \_0x860db8[\_0x1f346d(0x69)][\_0x1f346d(0x79)]('|'), \_0x3bf817 = 0x4bb \* 0x1 + 0x801 + -0xcbc;
while (!![]) {
switch (\_0x346c55[\_0x3bf817++]) {
case '0':
console[\_0x1f346d(0x7b)](\_0x4c96d8);
continue;
case '1':
console[\_0x1f346d(0x7b)](\_0x101028);
continue;
case '2':
var \_0x65977d = \_0x860db8[\_0x1f346d(0x66)]('5', -0x586 + -0x2195 + -0x6 \* -0x685);
continue;
case '3':
console[\_0x1f346d(0x7b)](\_0x65977d);
continue;
case '4':
var \_0x56d39b = \_0x860db8[\_0x1f346d(0x76)]('5', -'2');
continue;
case '5':
console[\_0x1f346d(0x7b)](\_0x56d39b);
continue;
case '6':
var \_0x544285 = [
'10',
'10',
'10',
'10',
'10'
][\_0x1f346d(0x7a)](parseInt);
continue;
case '7':
var \_0x4c96d8 = \_0x860db8[\_0x1f346d(0x68)]('5', 0x622 \* -0x6 + 0x4a \* 0x3 + 0x1 \* 0x23f1);
continue;
case '8':
console[\_0x1f346d(0x7b)](\_0x544285);
continue;
case '9':
var \_0x101028 = \_0x860db8[\_0x1f346d(0x6f)](\_0x860db8[\_0x1f346d(0x6f)](\_0x860db8[\_0x1f346d(0x77)], 0x6fb \* 0x5 + 0x1ebf \* 0x1 + -0x41a5), 0x209 \* 0xa + 0x1314 + -0x276d);
continue;
}
break;
}
}());
\*/
```
### `obfuscate(sourceCode, options)`
두 개의 퍼블릭 메서드를 포함하는 `ObfuscationResult` 객체를 반환합니다:
\* `getObfuscatedCode()` - 난독화된 코드가 담긴 `string`을 반환합니다;
\* `getSourceMap()` - [`sourceMap`](#sourcemap) 옵션이 활성화된 경우 소스 맵이 담긴 `string`을 반환하며, [`sourceMapMode`](#sourcemapmode) 옵션이 `inline`으로 설정된 경우 빈 문자열을 반환합니다;
\* `getIdentifierNamesCache()` - `identifierNamesCache` 옵션이 활성화된 경우 식별자 이름 캐시가 포함된 객체를 반환하고, 그렇지 않으면 `null`을 반환합니다.
`ObfuscationResult` 객체에 대해 `toString()`을 호출하면 난독

난독화된 코드입니다.
이 메서드는 `sourceCode`와 `options`라는 두 개의 매개변수를 받으며, 각각 소스 코드와 옵션을 나타냅니다:
\* `sourceCode` (`string`, 기본값: `null`) – 문자열로 전달되는 유효한 소스 코드;
\* `options` (`Object`, 기본값: `null`) – 옵션을 담고 있는 객체.
사용 가능한 옵션은 [options](#options)를 참조하세요.
### `obfuscateMultiple(sourceCodesObject, options)`
키가 소스 코드의 식별자이고 값이 소스 코드인 맵 형태의 `sourceCodesObject`를 허용합니다:
```
{
foo: 'var foo = 1;',
bar: 'var bar = 2;'
}
```
키가 소스 코드의 식별자이고 값이 `ObfuscationResult` 객체인 맵 객체를 반환합니다.
### `getOptionsByPreset(optionsPreset)`
전달된 옵션 프리셋 이름에 해당하는 옵션 객체를 반환합니다.
---
## :shield: Pro API 메서드 (VM 난독화)
Pro API 메서드는 [obfuscator.io](https://obfuscator.io) 클라우드 서비스를 통해 \*\*VM 기반 바이트코드 난독화\*\*에 대한 액세스 권한을 제공합니다. VM 난독화는 사용 가능한 가장 진보되고 안전한 형태의 코드 보호 기능으로, JavaScript 함수를 임베디드 가상 머신에서 실행되는 커스텀 바이트코드로 변환합니다.
\*\*VM 난독화가 필요한 이유:\*\*
- \*\*가장 강력한 보호\*\*: 코드가 직접 이해할 수 없는 바이트코드로 변환됨
- \*\*역컴파일 방지\*\*: 리버스 엔지니어링할 수 있는 표준 JavaScript가 존재하지 않음
- \*\*커스텀 가능한 VM\*\*: 각 난독화는 고유한 연산 코드(opcode)와 VM 구조를 생성함
- \*\*계층화된 보안\*\*: 심층 방어를 위해 다른 난독화 옵션과 결합 가능
### API 토큰 발급받기
Pro API 메서드를 사용하려면 [obfuscator.io](https://obfuscator.io)에서 발급받은 유효한 API 토큰이 필요합니다:
1. [obfuscator.io](https://obfuscator.io)에서 계정을 생성합니다.
2. API 액세스가 포함된 Pro, Team 또는 Business 플랜을 구독합니다.
3. [obfuscator.io/dashboard](https://obfuscator.io/dashboard)에서 API 토큰을 생성합니다.
### `obfuscatePro(sourceCode, options, proApiConfig, onProgress?)` :new:
Pro API와 VM 기반 바이트코드 난독화를 사용하여 코드를 난독화하는 \*\*비동기(Async) 메서드\*\*입니다.
```javascript
const JavaScriptObfuscator = require('javascript-obfuscator');
const result = await JavaScriptObfuscator.obfuscatePro(
`function hello() { console.log("Hello World"); }`,
{
vmObfuscation: true, // 필수!
compact: true
},
{
apiToken: 'your\_javascript\_obfuscator\_pro\_api\_token'
}
);
console.log(result.getObfuscatedCode());
```
\*\*매개변수:\*\*
\* `sourceCode` (`string`) – 난독화할 소스 코드
\* `options` (`Object`) – 난독화 옵션. \*\*최소한 하나의 Pro 기능(`vmObfuscation: true` 또는 `parseHtml: true`)을 포함해야 합니다.\*\*
\* `apiConfig` (`Object`) – Pro API 설정:
\* `apiToken` (`string`, 필수) – obfuscator.io에서 발급받은 API 토큰
\* `timeout` (`number`, 선택사항) – 요청 타임아웃 (ms 단위, 기본값: `300000` - 5분)
\* `version` (`string`, 선택사항) – 사용할 Obfuscator.io 버전 (예: `'5.0.3'`). 지정하지 않으면 최신 버전이 기본으로 사용됩니다.
\* `onProgress` (`function`, 선택사항) – 난독화 중 진행 상황 업데이트를 위한 콜백
\*\*반환값:\*\* `Promise`
\*\*예외 발생:\*\* 다음과 같은 경우 `ApiError` 발생:
- 옵션에서 Pro 기능(`vmObfuscation` 또는 `parseHtml`)이 활성화되지 않은 경우
- API 토큰이 유효하지 않거나 만료된 경우
- API 요청이 실패한 경우
### 특정 버전을 사용하는 Pro API
`version` 옵션을 통해 사용할 난독화 버전을 지정할 수 있습니다:
```javascript
const result = await JavaScriptObfuscator.obfuscatePro(
sourceCode,
{
vmObfuscation: true
},
{
apiToken: 'your\_javascript\_obfuscator\_pro\_api\_token',
version: '5.0.3' // 특정 버전 사용
}
);
```
### 진행 상황 업데이트가 포함된 Pro API
API는 스트리밍 모드를 사용하여 난독화 중 실시간 진행 상황 업데이트를 제공합니다:
```javascript
const result = await JavaScriptObfuscator.obfuscatePro(
sourceCode,
{
vmObfuscation: true
},
{
apiToken: 'your\_javascript\_obfuscator\_pro\_api\_token'
},
(message) => {
console.log('Progress:', message);
// 출력: "Validating request...", "Authenticating...", "Obfuscating..." 등
}
);
```
### Pro 기능 확인하기
`ProApiClient.hasProFeatu

res()`를 사용하여 옵션에 Pro API가 필요한지 확인합니다:
```javascript
const { ProApiClient } = require('javascript-obfuscator');
const options = { vmObfuscation: true, compact: true };
if (ProApiClient.hasProFeatures(options)) {
// Use obfuscatePro() - requires API token
const result = await JavaScriptObfuscator.obfuscatePro(sourceCode, options, { apiToken });
} else {
// Use regular obfuscate() - no API token needed
const result = JavaScriptObfuscator.obfuscate(sourceCode, options);
}
```
Pro 기능에는 다음이 포함됩니다:
- `vmObfuscation: true` – VM 기반 바이트코드 난독화
- `parseHtml: true` – 인라인 JavaScript 난독화가 포함된 HTML 파싱
### 에러 처리 (Error Handling)
```javascript
const { ApiError } = require('javascript-obfuscator');
try {
const result = await JavaScriptObfuscator.obfuscatePro(sourceCode, options, config);
} catch (error) {
if (error instanceof ApiError) {
console.error(`API Error (${error.statusCode}): ${error.message}`);
} else {
throw error;
}
}
```
### Pro API를 사용하는 CLI 사용법
API 토큰을 제공하여 CLI에서 직접 Pro API 기능을 사용할 수도 있습니다:
```sh
javascript-obfuscator input.js --pro-api-token YOUR\_API\_TOKEN --vm-obfuscation true -o output.js
```
특정 난독화 버전 사용:
```sh
javascript-obfuscator input.js --pro-api-token YOUR\_API\_TOKEN --pro-api-version 5.0.3 --vm-obfuscation true -o output.js
```
\*\*CLI 옵션:\*\*
- `--pro-api-token ` – [obfuscator.io](https://obfuscator.io)에서 발급받은 API 토큰
- `--pro-api-version ` – 사용할 Obfuscator.io 버전 (선택사항, 기본값은 최신 버전)
CLI는 Pro 기능(`vmObfuscation` 또는 `parseHtml`)이 활성화된 경우 이를 자동으로 감지하고 Pro API를 통해 요청을 라우팅합니다.
### 대용량 파일 업로드
약 4MB보다 큰 파일의 경우, Pro API는 Vercel Blob 스토리지로의 클라이언트 측 업로드를 사용합니다. 이 기능을 활성화하려면 선택적 패키지인 `@vercel/blob`을 설치하세요:
```sh
npm install @vercel/blob
```
이 패키지가 없으면 대용량 파일 난독화가 실패하며 설치를 안내하는 에러 메시지가 표시됩니다.
---
## CLI 사용법
[CLI 옵션](#cli-options)을 참조하세요.
#### 단일 파일 난독화
사용법:
```sh
javascript-obfuscator input\_file\_name.js [options]
javascript-obfuscator input\_file\_name.js --output output\_file\_name.js [options]
javascript-obfuscator input\_file\_name.js --output output\_folder\_name [options]
javascript-obfuscator input\_folder\_name --output output\_folder\_name [options]
```
`.js` 확장자를 가진 단일 입력 파일의 난독화.
`--output` 옵션으로 대상 경로를 지정하지 않으면, 난독화된 파일은 입력 파일 디렉터리에 `INPUT\_FILE\_NAME-obfuscated.js` 이름으로 저장됩니다.
예시:
```sh
javascript-obfuscator samples/sample.js --compact true --self-defending false
// creates a new file samples/sample-obfuscated.js
javascript-obfuscator samples/sample.js --output output/output.js --compact true --self-defending false
// creates a new file output/output.js
```
#### 디렉터리 재귀적 난독화
사용법:
```sh
javascript-obfuscator ./dist [options]
// creates a new obfuscated files under `./dist` directory near the input files with `obfuscated` postfix
javascript-obfuscator ./dist --output ./dist/obfuscated [options]
// creates a folder structure with obfuscated files under `./dist/obfuscated` path
```
입력 디렉터리 아래의 모든 `.js` 파일 난독화. 이 디렉터리에 `-obfuscated` 접미사가 붙은 이미 난독화된 파일이 포함되어 있는 경우, 해당 파일들은 무시됩니다.
난독화된 파일은 입력 디렉터리 내에 `INPUT\_FILE\_NAME-obfuscated.js` 이름으로 저장됩니다.
## 조건부 주석 (Conditional comments)
다음 주석을 추가하여 코드의 특정 부분에 대한 난독화를 비활성화하거나 활성화할 수 있습니다:
\* 비활성화: `// javascript-obfuscator:disable` 또는 `/\* javascript-obfuscator:disable \*/`;
\* 활성화: `// javascript-obfuscator:enable` 또는 `/\* javascript-obfuscator:enable \*/`.
예시:
```javascript
// input
var foo = 1;
// javascript-obfuscator:disable
var bar = 2;
// output
var \_0xabc123 = 0x1;
var bar = 2;
```
조건부 주석은

AST 트리 노드의 직접적인 변환에만 영향을 줍니다. 모든 하위 변환은 여전히 AST 트리 노드에 적용됩니다.
예를 들면:
\* 변수 선언 시 해당 이름의 난독화를 직접 변환이라고 합니다;
\* 선언부를 제외한 변수 이름의 난독화를 하위 변환이라고 합니다.
## 변수 종류
삽입된 노드의 변수 종류는 소스 코드에서 가장 많이 사용되는 변수 종류를 바탕으로 자동 감지됩니다.
## 서로 다른 파일 간의 식별자 이름 충돌
서로 다른 파일을 난독화하는 동안, 이 파일들 간의 전역 식별자에 대해 동일한 이름이 생성될 수 있습니다.
이를 방지하려면 [`identifiersPrefix`](#identifiersprefix) 옵션을 사용하여 난독화된 각 파일의 모든 전역 식별자에 고유한 접두사를 설정하세요.
CLI를 사용할 때 이 접두사는 자동으로 추가됩니다.
## JavaScript Obfuscator Options
> :shield: \*\*VM 난독화를 찾고 계신가요?\*\* `vmObfuscation`, `parseHtml`, 그리고 모든 `vm\*` 옵션은 Pro 전용이며 [obfuscator.io](https://obfuscator.io)의 API 토큰이 필요합니다. [`obfuscatePro()`](#shield-pro-api-methods-vm-obfuscation) 메서드나 `--pro-api-token` CLI 플래그를 통해 사용하세요. [Pro API Methods](#shield-pro-api-methods-vm-obfuscation)를 참조하세요.
JS Obfuscator에서는 다음과 같은 옵션을 사용할 수 있습니다:
#### options:
```javascript
{
compact: true,
controlFlowFlattening: false,
controlFlowFlatteningThreshold: 0.75,
deadCodeInjection: false,
deadCodeInjectionThreshold: 0.4,
debugProtection: false,
debugProtectionInterval: 0,
disableConsoleOutput: false,
domainLock: [],
domainLockRedirectUrl: 'about:blank',
forceTransformStrings: [],
identifierNamesCache: null,
identifierNamesGenerator: 'hexadecimal',
identifiersDictionary: [],
identifiersPrefix: '',
ignoreImports: false,
inputFileName: '',
log: false,
numbersToExpressions: false,
optionsPreset: 'default',
renameGlobals: false,
renameProperties: false,
renamePropertiesMode: 'safe',
reservedNames: [],
reservedStrings: [],
seed: 0,
selfDefending: false,
simplify: true,
sourceMap: false,
sourceMapBaseUrl: '',
sourceMapFileName: '',
sourceMapMode: 'separate',
sourceMapSourcesMode: 'sources-content',
splitStrings: false,
splitStringsChunkLength: 10,
stringArray: true,
stringArrayCallsTransform: true,
stringArrayCallsTransformThreshold: 0.5,
stringArrayEncoding: [],
stringArrayIndexesType: [
'hexadecimal-number'
],
stringArrayIndexShift: true,
stringArrayRotate: true,
stringArrayShuffle: true,
stringArrayWrappersCount: 1,
stringArrayWrappersChainedCalls: true,
stringArrayWrappersParametersMaxCount: 2,
stringArrayWrappersType: 'variable',
stringArrayThreshold: 0.75,
target: 'browser',
transformObjectKeys: false,
unicodeEscapeSequence: false
}
```
#### CLI options:
```sh
-v, --version
-h, --help
-o, --output
--compact 
--config 
--control-flow-flattening 
--control-flow-flattening-threshold 
--dead-code-injection 
--dead-code-injection-threshold 
--debug-protection 
--debug-protection-interval 
--disable-console-output 
--domain-lock '

' (쉼표로 구분)
--domain-lock-redirect-url 
--exclude '

' (쉼표로 구분)
--force-transform-strings '

' (쉼표로 구분)
--identifier-names-cache-path 
--identifier-names-generator  [dictionary, hexadecimal, mangled, mangled-shuffled]
--identifiers-dictionary '

' (쉼표로 구분)
--identifiers-prefix 
--ignore-imports 
--log 
--numbers-to-expressions 
--options-preset  [default, low-obfuscation, medium-obfuscation, high-obfuscation]
--rename-globals 
--rename-properties 
--rename-properties-mode  [safe, unsafe]
--reserved-names '

' (쉼표로 구분)
--reserved-strings '

' (쉼표로 구분)
--seed 
--self-defending 
--simplify 
--source-map 
--source-map-base-url 
--source-map-file-name 
--source-map-mode  [inline, separate]
--source-map-sources-mode  [sources, sources-content]
--split-strings 
--split-strings-chunk-length 
--string-array 
--string-array-calls-transform 
--string-array-calls-transform-threshold 
--string-array-encoding '

' (쉼표로 구분) [none, base64, rc4]
--string-array-indexes-type '

' (쉼표로 구분) [hexadecimal-number, hexadecimal-numeric-string]
--string-array-index-shift 
--string-array-rotate 
--string-array-shuffle 
--string-array-wrappers-count 
--string-array-wrappers-chained-calls 
--string-array-wrappers-parameters-max-count 
--string-array-wrappers-type  [variable, function]
--string-array-threshold 
--target  [browser, browser-no-eval, node]
--transform-object-keys 
--unicode-escape-sequence 
--pro-api-token 
--pro-api-version 
--vm-obfuscation 
--vm-obfuscation-threshold 
--vm-preprocess-identifiers 
--vm-dynamic-opcodes 
--vm-target-functions '

' (쉼표로 구분)
--vm-exclude-functions '

' (쉼표로 구분)
--vm-target-functions-mode  [root, comment]
--vm-wrap-top-level-initializers 
--vm-opcode-shuffle 
--vm-bytecode-encoding 
--vm-bytecode-array-encoding 
--vm-bytecode-array-encoding-key 
--vm-bytecode-array-encoding-key-getter 
--vm-instruction-shuffle 
--vm-jumps-encoding 
--vm-decoy-opcodes 
--vm-dead-code-injection 
--vm-split-dispatcher 
--vm-macro-ops 
--vm-debug-protection 
--vm-runtime-opcode-derivation 
--vm-stateful-opcodes 
--vm-stack-encoding 
--vm-randomize-keys 
--vm-indirect-dispatch 
--vm-compact-dispatcher 
--vm-bytecode-format  [binary, json]
--parse-html 
--strict-mode 
```
### `compact`
Type: `boolean` Default: `true`
코드 출력을 한 줄로 압축합니다.
### `config`
Type: `string` Default: ``
난독화 옵션이 포함된 JS/JSON 설정 파일의 이름입니다. 이 옵션들은 CLI에 직접 전달된 옵션에 의해 재정의됩니다.
### `controlFlowFlattening`
Type: `boolean` Default: `false`
##### :warning: 이 옵션은 런타임 속도를 최대 1.5배 느리게 만들 정도로 성능에 큰 영향을 미칩니다. 제어 흐름 난독화의 영향을 받을 노드의 백분율을 설정하려면 [`controlFlowFlatteningThreshold`](#controlflowflatteningthreshold)를 사용하세요.
코드 제어 흐름 평탄화를 활성화합니다. 제어 흐름 평탄화는 프로그램 이해를 방해하는 소스 코드의 구조 변환입니다.
예시:
```ts
// input
(function(){
function foo () {
return function () {
var sum = 1 + 2;
console.log(1);
console.log(2);
console.log(3);
console.log(4);
console.log(5);
console.log(6);
}
}
foo()();
})();
// output
(function () {
function \_0x3bfc5c() {
return function () {
var \_0x3260a5 = {
'WtABe': '4|0|6|5|3|2|1',
'GokKo': function \_0xf87260(\_0x427a8e, \_0x43354c) {
return \_0x427a8e + \_0x43354c;
}
};
var \_0x1ad4d6 = \_0x3260a5['WtABe']['split']('|'), \_0x1a7b12 = 0x0;
while (!![]) {
switch (\_0x1ad4d6[\_0x1a7b12++]) {
case '0':
console['log'](0x1);
continue;
case '1':
console['log'](0x6);
continue;
case '2':
console['log'](0x5);
continue;
case '3':
console['log'](0x4);
continue;
case '4':
var \_0x1f2f2f = \_0x3260a5['GokKo'](0x1, 0x2);
continue;
case '5':
console['log'](0x3);
continue;
case '6':
console['log'](0x2);
continue;
}
break;
}
};
}
\_0x3bfc5c()();
}());
```
### `controlFlowFlatteningThreshold`
Type: `number` Default: `0.75` Min: `0` Max: `1`
임의의 노드에 [`controlFlowFlattening`](#controlflowflattening) 변환이 적용될 확률입니다.
이 설정은 대규모 제어 흐름 변환이 코드를 느리게 만들고 코드 크기를 증가시킬 수 있으므로 대용량 코드 크기에서 특히 유용합니다.
`controlFlowFlatteningThreshold: 0`은 `controlFlowFlattening: false`와 같습니다.
### `deadCodeInjection`
Type: `boolean` Default: `false`
##### :warning: 난독화된 코드의 크기가 크게 증가하므로(최대 200%), 난독화된 코드의 크기가 상관없는 경우에만 사용하세요. 죽은 코드 주입의 영향을 받을 노드의 백분율을 설정하려면 [`deadCodeInjectionThreshold`](#deadcodeinjectionthreshold)를 사용하세요.
##### :warning: 이 옵션은 `stringArray` 옵션을 강제로 활성화합니다.
이 옵션을 사용하면 무작위 죽은 코드 블록이 난독화된 코드에 추가됩니다.
예시:
```ts
// input
(function(){
if (true) {
var foo = function () {
console.log('abc');
};
var bar = function () {
console.log('def');
};
var baz = function () {
console.log('ghi');
};
var bark = function () {
console.log('jkl');
};
var hawk = function () {
console.log('mno');
};
foo();
bar();
baz();
bark();
hawk();
}
})();
// output
var \_0x37b8 = [
'YBCtz',
'GlrkA',
'urPbb',
'abc',
'NMIhC',
'yZgAj',
'zrAId',
'EtyJA',
'log',
'mno',
'jkl',
'def',
'Quzya',
'IWbBa',
'ghi'
];
function \_0x43a7(\_0x12cf56, \_0x587376) {
\_0x43a7 = function (\_0x2f87a8, \_0x47eac2) {
\_0x2f87a8 = \_0x2f87a8 - (0x16a7 \* 0x1 + 0x5 \* 0x151 + -0x1c92);
var \_0x341e03 = \_0x37b8[\_0x2f87a8];
return \_0x341e03;
};
return \_0x43a7(\_0x12cf56, \_0x587376);
}
(function () {
if (!![]) {
var \_0xbbe28f = function () {
var \_0x2fc85f = \_0x43a7;
if (\_0x2fc85f(0xaf) === \_0x2fc85f(0xae)) {
\_0x1dd94f

[\_0x2fc85f(0xb2)](\_0x2fc85f(0xb5));
} else {
console[\_0x2fc85f(0xb2)](\_0x2fc85f(0xad));
}
};
var \_0x5e46bc = function () {
var \_0x15b472 = \_0x43a7;
if (\_0x15b472(0xb6) !== \_0x15b472(0xaa)) {
console[\_0x15b472(0xb2)](\_0x15b472(0xb5));
} else {
\_0x47eac2[\_0x15b472(0xb2)](\_0x15b472(0xad));
}
};
var \_0x3669e8 = function () {
var \_0x47a442 = \_0x43a7;
if (\_0x47a442(0xb7) !== \_0x47a442(0xb0)) {
console[\_0x47a442(0xb2)](\_0x47a442(0xb8));
} else {
\_0x24e0bf[\_0x47a442(0xb2)](\_0x47a442(0xb3));
}
};
var \_0x28b05a = function () {
var \_0x497902 = \_0x43a7;
if (\_0x497902(0xb1) === \_0x497902(0xb1)) {
console[\_0x497902(0xb2)](\_0x497902(0xb4));
} else {
\_0x59c9c6[\_0x497902(0xb2)](\_0x497902(0xb4));
}
};
var \_0x402a54 = function () {
var \_0x1906b7 = \_0x43a7;
if (\_0x1906b7(0xab) === \_0x1906b7(0xac)) {
\_0xb89cd0[\_0x1906b7(0xb2)](\_0x1906b7(0xb8));
} else {
console[\_0x1906b7(0xb2)](\_0x1906b7(0xb3));
}
};
\_0xbbe28f();
\_0x5e46bc();
\_0x3669e8();
\_0x28b05a();
\_0x402a54();
}
}());
```
### `deadCodeInjectionThreshold`
타입: `number` 기본값: `0.4` 최솟값: `0` 최댓값: `1`
`deadCodeInjection`의 영향을 받을 노드의 백분율을 설정할 수 있습니다.
### `debugProtection`
타입: `boolean` 기본값: `false`
##### :warning: 개발자 도구를 열면 브라우저가 정지될 수 있습니다.
이 옵션은 개발자 도구(WebKit 기반 및 Mozilla Firefox 모두)의 `debugger` 함수 사용을 거의 불가능하게 만듭니다.
### `debugProtectionInterval`
타입: `number` 기본값: `0`
##### :warning: 브라우저가 멈출 수 있습니다! 사용자 책임 하에 사용하세요.
설정된 경우, 밀리초 단위의 간격을 사용하여 콘솔 탭에서 디버그 모드를 강제로 유지하므로 개발자 도구의 다른 기능을 사용하기 어려워집니다. [`debugProtection`](#debugprotection)이 활성화된 경우에 작동합니다. 권장 값은 `2000`에서 `4000` 밀리초 사이입니다.
### `disableConsoleOutput`
타입: `boolean` 기본값: `false`
##### :warning: 이 옵션은 모든 스크립트에 대해 전역적으로 `console` 호출을 비활성화합니다.
`console.log`, `console.info`, `console.error`, `console.warn`, `console.debug`, `console.exception`, `console.trace`를 빈 함수로 교체하여 사용을 비활성화합니다. 이를 통해 디버거 사용을 더 어렵게 만듭니다.
### `domainLock`
타입: `string[]` 기본값: `[]`
##### :warning: 이 옵션은 `target: 'node'`와 함께 작동하지 않습니다.
난독화된 소스 코드가 특정 도메인 및/또는 서브도메인에서만 실행되도록 허용합니다. 이를 통해 다른 사람이 단순히 소스 코드를 복사하여 붙여넣고 다른 곳에서 실행하는 것을 매우 어렵게 만듭니다.
소스 코드가 이 옵션에 지정된 도메인에서 실행되지 않는 경우, 브라우저는 [`domainLockRedirectUrl`](#domainlockredirecturl) 옵션에 전달된 URL로 리디렉션됩니다.
##### 다중 도메인 및 서브도메인
코드를 둘 이상의 도메인 또는 서브도메인에 잠그는 것이 가능합니다. 예를 들어, 코드가 \*\*www.example.com\*\*에서만 실행되도록 잠그려면 `www.example.com`을 추가하세요. 하위 도메인(`example.com`, `sub.example.com`)을 포함한 루트 도메인에서 작동하게 하려면 `.example.com`을 사용하세요.
### `domainLockRedirectUrl`
타입: `string` 기본값: `about:blank`
##### :warning: 이 옵션은 `target: 'node'`와 함께 작동하지 않습니다.
소스 코드가 [`domainLock`](#domainlock)에 지정된 도메인에서 실행되지 않을 경우 브라우저가 지정된 URL로 리디렉션되도록 허용합니다.
### `exclude`
타입: `string[]` 기본값: `[]`
난독화에서 제외할 파일을 나타내는 파일 이름 또는 글로브(glob) 패턴입니다.
### `forceTransformStrings`
타입: `string[]` 기본값: `[]`
지정된 RegExp 패턴과 일치하는 문자열 리터럴의 강제 변환을 활성화합니다.
##### :warning: 이 옵션은 [`stringArrayThreshold`](#stringarraythreshold)(또는 향후 다른 임계값)에 의해 변환되지 않아야 하는 문자열에만 영향을 줍니다.
이 옵션은 `reservedStrings` 옵션보다 우선순위가 높지만 `conditional comments`(조건부 주석)보다 우선순위가 높지는 않습니다.
예시:
```ts
{
forceTransformStrings: [
'some-important-value',
'some-string\_\d'
]
}
```
### `identifierNamesCache`
타입: `Object | null` 기본값: `null`
이 옵션의 주요 목적은

는 여러 소스/파일을 난독화하는 동안 동일한 식별자 이름을 사용할 수 있는 기능입니다.
현재 두 가지 유형의 식별자가 지원됩니다:
- 전역 식별자:
\* 모든 전역 식별자가 캐시에 기록됩니다.
\* 일치하는 모든 **선언되지 않은** 전역 식별자가 캐시의 값으로 대체됩니다.
- 속성 식별자 (`renameProperties` 옵션이 활성화된 경우에만):
\* 모든 속성 식별자가 캐시에 기록됩니다.
\* 일치하는 모든 속성 식별자가 캐시의 값으로 대체됩니다.
#### Node.js API
`null` 값이 전달되면 캐시가 완전히 비활성화됩니다.
빈 객체 (`{}`)가 전달되면 캐시 객체(`TIdentifierNamesCache` 타입)에 식별자 이름 쓰기가 활성화됩니다. 이 캐시 객체는 `ObfuscationResult` 객체의 `getIdentifierNamesCache` 메서드 호출을 통해 액세스할 수 있습니다.
결과 캐시 객체는 다음 소스의 일치하는 모든 식별자 이름을 난독화할 때 이 이름을 사용하기 위한 `identifierNamesGenerator` 옵션 값으로 다음에 사용할 수 있습니다.
예시:
```ts
const source1ObfuscationResult = JavaScriptObfuscator.obfuscate(
`
function foo(arg) {
console.log(arg)
}
function bar() {
var bark = 2;
}
`,
{
compact: false,
identifierNamesCache: {},
renameGlobals: true
}
)
console.log(source1ObfuscationResult.getIdentifierNamesCache());
/\*
{
globalIdentifiers: {
foo: '\_0x5de86d',
bar: '\_0x2a943b'
}
}
\*/
const source2ObfuscationResult = JavaScriptObfuscator.obfuscate(
`
// Expecting that these global functions are defined in another obfuscated file
foo(1);
bar();
// Expecting that this global function is defined in third-party package
baz();
`,
{
compact: false,
identifierNamesCache: source1ObfuscationResult.getIdentifierNamesCache(),
renameGlobals: true
}
)
console.log(source2ObfuscationResult.getObfuscatedCode());
/\*
\_0x5de86d(0x1);
\_0x2a943b();
baz();
\*/
```
#### CLI
CLI에는 식별자 이름 캐시를 읽고 쓰는 데 사용할 기존 `.json` 파일의 경로를 정의할 수 있는 `--identifier-names-cache-path` 옵션이 따로 있습니다.
빈 파일의 경로가 전달되면 해당 파일에 식별자 이름 캐시가 기록됩니다.
기존 캐시가 포함된 이 파일은 다음 파일의 일치하는 모든 식별자 이름을 난독화하는 동안 이 이름을 사용하기 위한 `--identifier-names-cache-path` 옵션 값으로 다시 사용할 수 있습니다.
### `identifierNamesGenerator`
타입: `string` 기본값: `hexadecimal`
식별자 이름 생성기를 설정합니다.
사용 가능한 값:
\* `dictionary`: [`identifiersDictionary`](#identifiersdictionary) 목록의 식별자 이름
\* `hexadecimal`: `\_0xabc123`과 같은 식별자 이름
\* `mangled`: `a`, `b`, `c`와 같은 짧은 식별자 이름
\* `mangled-shuffled`: 알파벳이 무작위로 섞인 것을 제외하면 `mangled`와 동일함
### `identifiersDictionary`
타입: `string[]` 기본값: `[]`
[`identifierNamesGenerator`](#identifiernamesgenerator): `dictionary` 옵션용 식별자 사전을 설정합니다. 사전의 각 식별자는 각 문자의 대소문자가 다른 여러 가지 변형으로 사용됩니다. 따라서 사전의 식별자 수는 원본 소스 코드의 식별자 양에 따라 달라져야 합니다.
### `identifiersPrefix`
타입: `string` 기본값: `''`
모든 전역 식별자의 접두사를 설정합니다.
여러 파일을 난독화하려는 경우 이 옵션을 사용하세요. 이 옵션은 이러한 파일의 전역 식별자 간의 충돌을 방지하는 데 도움이 됩니다. 접두사는 파일마다 달라야 합니다.
### `ignoreImports`
타입: `boolean` 기본값: `false`
`require` 임포트의 난독화를 방지합니다. 런타임 환경에서 어떤 이유로 인해 이러한 임포트를 정적 문자열로만 요구하는 일부 경우에 유용할 수 있습니다.
### `inputFileName`
타입: `string` 기본값: `''`
소스 코드가 포함된 입력 파일의 이름을 설정할 수 있습니다. 이 이름은 소스 맵 생성에 내부적으로 사용됩니다.
NodeJS API를 사용하고 `sourceMapSourcesMode` 옵션에 `sources` 값이 있는 경우에 필요합니다.
### `log`
타입: `boolean` 기본값: `false`
콘솔에 정보 로깅을 활성화합니다.
### `numbersToExpressions`
타입:

boolean` 기본값: `false`
숫자를 표현식으로 변환하는 기능을 활성화합니다.
예시:
```ts
// input
const foo = 1234;
// output
const foo=-0xd93+-0x10b4+0x41\*0x67+0x84e\*0x3+-0xff8;
```
### `optionsPreset`
타입: `string` 기본값: `default`
[options preset](#preset-options)을 설정할 수 있습니다.
사용 가능한 값:
\* `default`;
\* `low-obfuscation`;
\* `medium-obfuscation`;
\* `high-obfuscation`.
모든 추가 옵션은 선택한 옵션 프리셋과 병합됩니다.
### `renameGlobals`
타입: `boolean` 기본값: `false`
##### :warning: 이 옵션은 코드를 깨뜨릴 수 있습니다. 작동 원리를 정확히 이해하고 있는 경우에만 활성화하세요!
전역 변수 및 함수 이름을 \*\*선언부와 함께\*\* 난독화하는 기능을 활성화합니다.
### `renameProperties`
타입: `boolean` 기본값: `false`
##### :warning: 이 옵션은 코드를 \*\*깨뜨릴 수 있습니다\*\*. 작동 원리를 정확히 이해하고 있는 경우에만 활성화하세요!
프로퍼티 이름 변경 기능을 활성화합니다. 모든 기본 제공 DOM 프로퍼티와 코어 JavaScript 클래스의 프로퍼티는 무시됩니다.
이 옵션의 `safe` 모드와 `unsafe` 모드 사이를 전환하려면 [`renamePropertiesMode`](#renamepropertiesmode) 옵션을 사용하세요.
변경된 프로퍼티 이름의 형식을 설정하려면 [`identifierNamesGenerator`](#identifiernamesgenerator) 옵션을 사용하세요.
어떤 프로퍼티를 변경할지 제어하려면 [`reservedNames`](#reservednames) 옵션을 사용하세요.
예시:
```ts
// input
(function () {
const foo = {
prop1: 1,
prop2: 2,
calc: function () {
return this.prop1 + this.prop2;
}
};
console.log(foo.calc());
})();
// output
(function () {
const \_0x46529b = {
'\_0x10cec7': 0x1,
'\_0xc1c0ca': 0x2,
'\_0x4b961d': function () {
return this['\_0x10cec7'] + this['\_0xc1c0ca'];
}
};
console['log'](\_0x46529b['\_0x4b961d']());
}());
```
### `renamePropertiesMode`
타입: `string` 기본값: `safe`
##### :warning: `safe` 모드에서도 [`renameProperties`](#renameproperties) 옵션은 코드를 \*\*깨뜨릴 수 있습니다\*\*.
`renameProperties` 옵션 모드를 지정합니다:
\* `safe` - `2.11.0` 버전 이후의 기본 동작입니다. 런타임 오류를 방지하기 위해 더 안전한 방식으로 프로퍼티를 변경하려고 시도합니다. 이 모드에서는 일부 프로퍼티가 이름 변경 대상에서 제외됩니다.
\* `unsafe` - `2.11.0` 버전 이전의 기본 동작입니다. 어떤 제한도 없이 안전하지 않은 방식으로 프로퍼티를 변경합니다.
한 파일에서 다른 파일의 프로퍼티를 사용하는 경우, [`identifierNamesCache`](#identifiernamescache) 옵션을 사용하여 이 파일들 간에 동일한 프로퍼티 이름을 유지하세요.
### `reservedNames`
타입: `string[]` 기본값: `[]`
전달된 RegExp 패턴과 일치하는 식별자의 난독화 및 생성을 비활성화합니다.
예시:
```ts
{
reservedNames: [
'^someVariable',
'functionParameter\_\d'
]
}
```
### `reservedStrings`
타입: `string[]` 기본값: `[]`
전달된 RegExp 패턴과 일치하는 문자열 리터럴의 변환을 비활성화합니다.
예시:
```ts
{
reservedStrings: [
'react-native',
'\.\/src\/test',
'some-string\_\d'
]
}
```
### `seed`
타입: `string|number` 기본값: `0`
이 옵션은 난수 생성기의 시드를 설정합니다. 이는 반복 가능한 결과를 만드는 데 유용합니다.
시드가 `0`인 경우 - 난수 생성기가 시드 없이 작동합니다.
### `selfDefending`
타입: `boolean` 기본값: `false`
##### :warning: 이 옵션으로 난독화한 후에는 코드 압축(uglifying) 등의 어떠한 변경도 가하지 마세요. 자체 방어가 발동하여 코드가 더 이상 작동하지 않게 됩니다!
##### :warning: 이 옵션은 강제로 `compact` 값을 `true`로 설정합니다.
이 옵션은 출력된 코드가 포맷팅 및 변환에 견딜 수 있도록 만듭니다. 누군가 난독화된 코드에 JavaScript beautifier를 사용하려고 하면 코드가 더 이상 작동하지 않게 되어, 코드를 이해하고 수정하기 어렵게 만듭니다.
### `simplify`
타입: `boolean` 기본값: `true`
단순화를 통한 추가적인 코드 난독화를 활성화합니다.
##### :warning: 향후 릴리즈에서는 `boolean` 리터럴(`true` => `!![]`)의 난독화가 이 옵션 아래로 이동될 예정입니다.
예시:
```ts
// input
if (condition1) {
const foo = 1;
const bar = 2;
console.log(foo);
return bar;
} else if (condition2) {
console.log(1);
console.log(2);
console.log(3);
return 4;
} else {
return 5;
}
// output
if (condition1

) {
const foo = 0x1, bar = 0x2;
return console['log'](foo), bar;
} else
return condition2 ? (console['log'](0x1), console['log'](0x2), console['log'](0x3), 0x4) : 0x5;
```
### `sourceMap`
Type: `boolean` Default: `false`
난독화된 코드에 대한 소스 맵(source map) 생성을 활성화합니다.
소스 맵은 난독화된 JavaScript 소스 코드를 디버깅하는 데 유용할 수 있습니다. 프로덕션 환경에서 디버깅을 원하거나 해야 하는 경우, 별도의 소스 맵 파일을 비밀스러운 위치에 업로드한 다음 브라우저가 해당 위치를 가리키도록 설정할 수 있습니다.
### `sourceMapBaseUrl`
Type: `string` Default: ``
[`sourceMapMode: 'separate'`](#sourcemapmode) 사용 시 소스 맵 임포트 URL의 베이스 URL을 설정합니다.
CLI 예시:
```
javascript-obfuscator input.js --output out.js --source-map true --source-map-base-url 'http://localhost:9000'
```
결과:
```
//# sourceMappingURL=http://localhost:9000/out.js.map
```
### `sourceMapFileName`
Type: `string` Default: ``
`sourceMapMode: 'separate'` 설정 시 출력될 소스 맵의 파일 이름을 설정합니다.
CLI 예시:
```
javascript-obfuscator input.js --output out.js --source-map true --source-map-base-url 'http://localhost:9000' --source-map-file-name example
```
결과:
```
//# sourceMappingURL=http://localhost:9000/example.js.map
```
### `sourceMapMode`
Type: `string` Default: `separate`
소스 맵 생성 모드를 지정합니다:
\* `inline` - 각 .js 파일의 끝에 소스 맵을 추가합니다.
\* `separate` - 소스 맵과 대응하는 '.map' 파일을 생성합니다. CLI를 통해 난독화기를 실행하는 경우, 난독화된 코드가 포함된 파일의 끝에 소스 맵 파일에 대한 링크(`//# sourceMappingUrl=file.js.map`)를 추가합니다.
### `sourceMapSourcesMode`
Type: `string` Default: `sources-content`
소스 맵의 `sources` 및 `sourcesContent` 필드를 제어할 수 있습니다:
\* `sources-content` - 더미 `sources` 필드를 추가하고, 원본 소스 코드가 포함된 `sourcesContent` 필드를 추가합니다.
\* `sources` - 유효한 소스 설명이 포함된 `sources` 필드를 추가하며, `sourcesContent` 필드는 추가하지 않습니다. NodeJS API를 사용할 때는 `sources` 필드 값으로 사용될 `inputFileName` 옵션을 반드시 정의해야 합니다.
### `splitStrings`
Type: `boolean` Default: `false`
리터럴 문자열을 [`splitStringsChunkLength`](#splitstringschunklength) 옵션 값의 길이를 가진 청크로 분할합니다.
예시:
```ts
// input
(function(){
var test = 'abcdefg';
})();
// output
(function(){
var \_0x5a21 = 'ab' + 'cd' + 'ef' + 'g';
})();
```
### `splitStringsChunkLength`
Type: `number` Default: `10`
[`splitStrings`](#splitstrings) 옵션의 청크 길이를 설정합니다.
### `stringArray`
Type: `boolean` Default: `true`
문자열 리터럴을 제거하고 특정한 배열에 배치합니다. 예를 들어, `var m = "Hello World";` 안의 `"Hello World"` 문자열은 `var m = \_0x12c456[0x1];`과 같은 방식으로 대체됩니다.
### `stringArrayCallsTransform`
Type: `boolean` Default: `false`
##### :warning: [`stringArray`](#stringarray) 옵션이 활성화되어 있어야 합니다.
[`stringArray`](#stringarray)에 대한 호출 변환을 활성화합니다. 이 호출들의 모든 인자는 [`stringArrayCallsTransformThreshold`](#stringarraycallstransformthreshold) 값에 따라 다른 객체로 추출될 수 있습니다.
따라서 문자열 배열에 대한 호출을 자동으로 찾아내기가 더욱 어려워집니다.
예시:
```
function foo() {
var k = {
c: 0x2f2,
d: '0x396',
e: '0x397',
f: '0x39a',
g: '0x39d',
h: 0x398,
l: 0x394,
m: '0x39b',
n: '0x39f',
o: 0x395,
p: 0x395,
q: 0x399,
r: '0x399'
};
var c = i(k.d, k.e);
var d = i(k.f, k.g);
var e = i(k.h, k.l);
var f = i(k.m, k.n);
function i(c, d) {
return b(c - k.c, d);
}
var g = i(k.o, k.p);
var h = i(k.q, k.r);
}
function j(c, d) {
var l = { c: 0x14b };
return b(c - -l.c, d);
}
console[j(-'0xa6', -'0xa6')](foo());
function b(c, d) {
var e = a();
b = function (f, g) {
f = f - 0xa3;
var h = e[f];
return h;
};
return b(c, d);
}
function a() {
var m = [
'string5',
'string1',
'log',
'string3',
'string6',
'string2',
'string4'
];
a = function () {
return m;
};
return a();
}
```
### `stringArrayCallsTransformThreshold`
Type: `number` Default: `0.5`
##### :warning: [`stringArray`](#stringarr

ay) 및 [`stringArrayCallsTransformThreshold`](#stringarraycallstransformthreshold) 옵션이 활성화되어 있어야 합니다.
이 설정을 사용하여 문자열 배열 호출이 변환될 확률(0에서 1 사이)을 조정할 수 있습니다.
### `stringArrayEncoding`
Type: `string[]` Default: `[]`
##### :warning: `stringArray` 옵션이 활성화되어 있어야 합니다.
이 옵션은 스크립트 실행 속도를 저하시킬 수 있습니다.
[`stringArray`](#stringarray)의 모든 문자열 리터럴을 `base64` 또는 `rc4`를 사용하여 인코딩하고, 런타임에 이를 다시 디코딩하는 데 사용되는 특수 코드를 삽입합니다.
각 `stringArray` 값은 전달된 목록에서 무작위로 선택된 인코딩으로 인코딩됩니다. 이를 통해 여러 인코딩을 사용할 수 있습니다.
사용 가능한 값:
\* `'none'` (`boolean`): `stringArray` 값을 인코딩하지 않습니다.
\* `'base64'` (`string`): `base64`를 사용하여 `stringArray` 값을 인코딩합니다.
\* `'rc4'` (`string`): `rc4`를 사용하여 `stringArray` 값을 인코딩합니다. \*\*`base64`보다 약 30-50% 느리지만 초기값을 알아내기 더 어렵습니다.\*\* 난독화된 코드의 크기가 매우 커지는 것을 방지하기 위해 `rc4` 인코딩을 사용할 때는 [`unicodeEscapeSequence`](#unicodeescapesequence) 옵션을 비활성화하는 것이 좋습니다.
예를 들어 다음 옵션 값을 사용하면 일부 `stringArray` 값은 인코딩되지 않고, 일부 값은 `base64` 및 `rc4` 인코딩으로 인코딩됩니다:
```ts
stringArrayEncoding: [
'none',
'base64',
'rc4'
]
```
### `stringArrayIndexesType`
Type: `string[]` Default: `['hexadecimal-number']`
##### :warning: `stringArray` 옵션이 활성화되어 있어야 합니다.
문자열 배열 호출 인덱스의 타입을 제어할 수 있습니다.
각 `stringArray` 호출 인덱스는 전달된 목록에서 무작위로 선택된 타입으로 변환됩니다. 이를 통해 여러 타입을 사용할 수 있습니다.
사용 가능한 값:
\* `'hexadecimal-number'` (`default`): 문자열 배열 호출 인덱스를 1진수로 변환합니다.
\* `'hexadecimal-numeric-string'`: 문자열 배열 호출 인덱스를 16진수 숫자 문자열로 변환합니다.
`2.9.0` 버전 이전에는 `javascript-obfuscator`가 모든 문자열 배열 호출 인덱스를 `hexadecimal-numeric-string` 타입으로 변환했습니다. 이로 인해 수동 난독화 해제는 약간 더 어려워지지만, 자동 난독화 해제 도구는 이러한 호출을 쉽게 감지할 수 있습니다.
새로운 `hexadecimal-number` 타입은 코드 내에서 문자열 배열 호출 패턴을 자동으로 감지하기 더 어렵게 만듭니다.
더 많은 타입이 향후 추가될 예정입니다.
### `stringArrayIndexShift`
Type: `boolean` Default: `true`
##### :warning: `stringArray` 옵션이 활성화되어 있어야 합니다.
모든 문자열 배열 호출에 대해 추가적인 인덱스 시프트를 활성화합니다.
### `stringArrayRotate`
Type: `boolean` Default: `true`
##### :warning: [`stringArray`](#stringarray)가 활성화되어 있어야 합니다.
`stringArray` 배열을 고정되고 무작위적인(코드 난독화 시 생성됨) 위치만큼 시프트합니다. 이로 인해 제거된 문자열의 순서를 원래 위치와 일치시키기 더 어려워집니다.
### `stringArrayShuffle`
Type: `boolean` Default: `true`
##### :warning: [`stringArray`](#stringarray)가 활성화되어 있어야 합니다.
`stringArray` 배열 항목을 무작위로 섞습니다.
### `stringArrayWrappersCount`
Type: `number` Default: `1`
##### :warning: [`stringArray`](#stringarray) 옵션이 활성화되어 있어야 합니다.
각 루트 또는 함수 스코프 내의 `string array`에 대한 래퍼 수를 설정합니다.
각 스코프 내의 실제 래퍼 수는 이 스코프 내의 `literal` 노드 수로 제한됩니다.
예시:
```ts
// Input
const foo = 'foo';
const bar = 'bar';
function test () {
const baz = 'baz';
const bark = 'bark';
const hawk = 'hawk';
}
const eagle = 'eagle';
// Output, stringArrayWrappersCount: 5
const \_0x3f6c = [
'bark',
'bar',
'foo',
'eagle',
'hawk',
'baz'
];
const \_0x48f96e = \_0x2e13;
const \_0x4dfed8 = \_0x2e13;
const \_0x55e970 = \_0x2e13;
function \_0x2e13(\_0x33c4f5, \_0x3f6c62) {
\_0x2e13 = function (\_0x2e1388, \_0x60b1e) {
\_0x2e1388 = \_0x2e1388 - 0xe2;
let \_0x53d475 = \_0x3f6c[\_0x2e1388];
return \_0x53d475;
};
return \_0x2e13(\_0x33c4f5, \_0x3f6c62);
}
const foo = \_0x48f96e(0xe4);
const bar = \_0x4dfed8(0xe3);
function test() {
const \_0x1c262f = \_0x2e13;
const \_0x54d7a4 = \_0x2e13;
const \_0x5142fe = \_0x2e
```

13;
const \_0x1392b0 = \_0x1c262f(0xe7);
const \_0x201a58 = \_0x1c262f(0xe2);
const \_0xd3a7fb = \_0x1c262f(0xe6);
}
const eagle = \_0x48f96e(0xe5);
```
### `stringArrayWrappersChainedCalls`
Type: `boolean` Default: `true`
##### :warning: [`stringArray`](#stringarray) 및 [`stringArrayWrappersCount`](#stringarraywrapperscount) 옵션이 활성화되어 있어야 합니다.
`string array` 래퍼들 간의 체이닝된 호출을 활성화합니다.
예시:
```ts
// Input
const foo = 'foo';
const bar = 'bar';
function test () {
const baz = 'baz';
const bark = 'bark';
function test1() {
const hawk = 'hawk';
const eagle = 'eagle';
}
}
// Output, stringArrayWrappersCount: 5, stringArrayWrappersChainedCalls: true
const \_0x40c2 = [
'bar',
'bark',
'hawk',
'eagle',
'foo',
'baz'
];
const \_0x31c087 = \_0x3280;
const \_0x31759a = \_0x3280;
function \_0x3280(\_0x1f52ee, \_0x40c2a2) {
\_0x3280 = function (\_0x3280a4, \_0xf07b02) {
\_0x3280a4 = \_0x3280a4 - 0x1c4;
let \_0x57a182 = \_0x40c2[\_0x3280a4];
return \_0x57a182;
};
return \_0x3280(\_0x1f52ee, \_0x40c2a2);
}
const foo = \_0x31c087(0x1c8);
const bar = \_0x31c087(0x1c4);
function test() {
const \_0x848719 = \_0x31759a;
const \_0x2693bf = \_0x31c087;
const \_0x2c08e8 = \_0x848719(0x1c9);
const \_0x359365 = \_0x2693bf(0x1c5);
function \_0x175e90() {
const \_0x310023 = \_0x848719;
const \_0x2302ef = \_0x2693bf;
const \_0x237437 = \_0x310023(0x1c6);
const \_0x56145c = \_0x310023(0x1c7);
}
}
```
### `stringArrayWrappersParametersMaxCount`
Type: `number` Default: `2`
##### :warning: [`stringArray`](#stringarray) 옵션이 활성화되어 있어야 합니다.
##### :warning: 현재 이 옵션은 [`stringArrayWrappersType`](#stringarraywrapperstype)이 `function` 옵션 값으로 설정된 경우에 추가되는 래퍼에만 영향을 미칩니다.
문자열 배열 래퍼 매개변수의 최대 개수를 제어할 수 있습니다.
기본값이자 최솟값은 `2`입니다. 권장 값은 `2`에서 `5` 사이입니다.
### `stringArrayWrappersType`
Type: `string` Default: `variable`
##### :warning: [`stringArray`](#stringarray) 및 [`stringArrayWrappersCount`](#stringarraywrapperscount) 옵션이 활성화되어 있어야 합니다.
`stringArrayWrappersCount` 옵션에 의해 추가되는 래퍼의 유형을 선택할 수 있습니다.
사용 가능한 값:
\* `'variable'`: 각 스코프의 상단에 변수 래퍼를 추가합니다. 빠른 성능을 제공합니다.
\* `'function'`: 각 스코프 내부에 무작위 위치로 함수 래퍼를 추가합니다. `variable`에 비해 성능은 느리지만 더 엄격한 난독화를 제공합니다.
성능 저하가 난독화된 애플리케이션에 큰 영향을 미치지 않는 경우, 더 강력한 난독화를 위해 `function` 래퍼를 사용하는 것을 강력히 권장합니다.
`'function'` 옵션 값의 예시:
```ts
// input
const foo = 'foo';
function test () {
const bar = 'bar';
console.log(foo, bar);
}
test();
// output
const a = [
'log',
'bar',
'foo'
];
const foo = d(0x567, 0x568);
function b(c, d) {
b = function (e, f) {
e = e - 0x185;
let g = a[e];
return g;
};
return b(c, d);
}
function test() {
const c = e(0x51c, 0x51b);
function e (c, g) {
return b(c - 0x396, g);
}
console[f(0x51b, 0x51d)](foo, c);
function f (c, g) {
return b(c - 0x396, g);
}
}
function d (c, g) {
return b(g - 0x3e1, c);
}
test();
```
### `stringArrayThreshold`
Type: `number` Default: `0.8` Min: `0` Max: `1`
##### :warning: [`stringArray`](#stringarray) 옵션이 활성화되어 있어야 합니다.
이 설정을 사용하여 문자열 리터럴이 `stringArray`에 삽입될 확률(0에서 1 사이)을 조정할 수 있습니다.
이 설정은 코드 크기가 큰 경우에 특히 유용합니다. `string array`를 반복적으로 호출하여 코드 실행 속도를 저하시킬 수 있기 때문입니다.
`stringArrayThreshold: 0`은 `stringArray: false`와 같습니다.
### `target`
Type: `string` Default: `browser`
난독화된 코드의 대상 환경을 설정할 수 있습니다.
사용 가능한 값:
\* `browser`;
\* `browser-no-eval`;
\* `node`.
현재 `browser` 및 `node` 타겟의 출력 코드는 동일하지만, 일부 브라우저 전용 옵션은 `node` 타겟에서 허용되지 않습니다.
`browser-no-eval` 타겟의 출력 코드는 `eval`을 사용하지 않습니다.
### `transformObjectKeys`
Type: `boolean` Def

ault: `false`
객체 키(object keys)의 변환을 활성화합니다.
예시:
```ts
// input
(function(){
var object = {
foo: 'test1',
bar: {
baz: 'test2'
}
};
})();
// output
var \_0x4735 = [
'foo',
'baz',
'bar',
'test1',
'test2'
];
function \_0x390c(\_0x33d6b6, \_0x4735f4) {
\_0x390c = function (\_0x390c37, \_0x1eed85) {
\_0x390c37 = \_0x390c37 - 0x198;
var \_0x2275f8 = \_0x4735[\_0x390c37];
return \_0x2275f8;
};
return \_0x390c(\_0x33d6b6, \_0x4735f4);
}
(function () {
var \_0x17d1b7 = \_0x390c;
var \_0xc9b6bb = {};
\_0xc9b6bb[\_0x17d1b7(0x199)] = \_0x17d1b7(0x19c);
var \_0x3d959a = {};
\_0x3d959a[\_0x17d1b7(0x198)] = \_0x17d1b7(0x19b);
\_0x3d959a[\_0x17d1b7(0x19a)] = \_0xc9b6bb;
var \_0x41fd86 = \_0x3d959a;
}());
```
### `unicodeEscapeSequence`
Type: `boolean` Default: `false`
문자열을 유니코드 escape 시퀀스로 변환하는 기능을 활성화/비활성화합니다.
유니코드 escape 시퀀스는 코드 크기를 크게 증가시키며, 문자열이 원래 형태로 쉽게 복원될 수 있습니다. 소스 코드가 작은 경우에만 이 옵션을 활성화하는 것을 권장합니다.
## 프리셋 옵션 (Preset Options)
### 높은 난독화, 낮은 성능 (High obfuscation, low performance)
난독화를 하지 않았을 때보다 성능이 훨씬 느려집니다.
```javascript
{
compact: true,
controlFlowFlattening: true,
controlFlowFlatteningThreshold: 1,
deadCodeInjection: true,
deadCodeInjectionThreshold: 1,
debugProtection: true,
debugProtectionInterval: 4000,
disableConsoleOutput: true,
identifierNamesGenerator: 'hexadecimal',
log: false,
numbersToExpressions: true,
renameGlobals: false,
selfDefending: true,
simplify: true,
splitStrings: true,
splitStringsChunkLength: 5,
stringArray: true,
stringArrayCallsTransform: true,
stringArrayEncoding: ['rc4'],
stringArrayIndexShift: true,
stringArrayRotate: true,
stringArrayShuffle: true,
stringArrayWrappersCount: 5,
stringArrayWrappersChainedCalls: true,
stringArrayWrappersParametersMaxCount: 5,
stringArrayWrappersType: 'function',
stringArrayThreshold: 1,
transformObjectKeys: true,
unicodeEscapeSequence: false
}
```
### 중간 난독화, 최적의 성능 (Medium obfuscation, optimal performance)
난독화를 하지 않았을 때보다 성능이 느려집니다.
```javascript
{
compact: true,
controlFlowFlattening: true,
controlFlowFlatteningThreshold: 0.75,
deadCodeInjection: true,
deadCodeInjectionThreshold: 0.4,
debugProtection: false,
debugProtectionInterval: 0,
disableConsoleOutput: true,
identifierNamesGenerator: 'hexadecimal',
log: false,
numbersToExpressions: true,
renameGlobals: false,
selfDefending: true,
simplify: true,
splitStrings: true,
splitStringsChunkLength: 10,
stringArray: true,
stringArrayCallsTransform: true,
stringArrayCallsTransformThreshold: 0.75,
stringArrayEncoding: ['base64'],
stringArrayIndexShift: true,
stringArrayRotate: true,
stringArrayShuffle: true,
stringArrayWrappersCount: 2,
stringArrayWrappersChainedCalls: true,
stringArrayWrappersParametersMaxCount: 4,
stringArrayWrappersType: 'function',
stringArrayThreshold: 0.75,
transformObjectKeys: true,
unicodeEscapeSequence: false
}
```
### 낮은 난독화, 높은 성능 (Low obfuscation, High performance)
성능이 비교적 정상적인 수준을 유지합니다.
```javascript
{
compact: true,
controlFlowFlattening: false,
deadCodeInjection: false,
debugProtection: false,
debugProtectionInterval: 0,
disableConsoleOutput: true,
identifierNamesGenerator: 'hexadecimal',
log: false,
numbersToExpressions: false,
renameGlobals: false,
selfDefending: true,
simplify: true,
splitStrings: false,
stringArray: true,
stringArrayCallsTransform: false,
stringArrayEncoding: [],
stringArrayIndexShift: true,
stringArrayRotate: true,
stringArrayShuffle: true,
stringArrayWrappersCount: 1,
stringArrayWrappersChainedCalls: true,
stringArrayWrappersParametersMaxCount: 2,
stringArrayWrappersType: 'variable',
stringArrayThreshold: 0.75,
unicodeEscapeSequence: false
}
```
### 기본 프리셋, 높은 성능 (Default preset, High performance)
```javascript
{
compact: true,
controlFlowFlattening: false,
deadCodeInjection: false,
debugProtection: false,
debugProtectionInterval: 0,
disableConsoleOutput: false,
identifierNamesGenerator: 'hexadecimal',
log: false,
numbersToExpressions: false,
re

nameGlobals: false,
selfDefending: false,
simplify: true,
splitStrings: false,
stringArray: true,
stringArrayCallsTransform: false,
stringArrayCallsTransformThreshold: 0.5,
stringArrayEncoding: [],
stringArrayIndexShift: true,
stringArrayRotate: true,
stringArrayShuffle: true,
stringArrayWrappersCount: 1,
stringArrayWrappersChainedCalls: true,
stringArrayWrappersParametersMaxCount: 2,
stringArrayWrappersType: 'variable',
stringArrayThreshold: 0.75,
unicodeEscapeSequence: false
}
```
## Obfuscator.io Pro 옵션
> :warning: \*\*다음 VM 난독화/Pro 옵션은 [Obfuscator.io Pro API](https://obfuscator.io/)를 통해서만 사용할 수 있습니다.\*\*
>
> 이 옵션을 사용하려면 [obfuscator.io](https://obfuscator.io)의 Pro API 토큰이 필요하며, `obfuscate()` 대신 `obfuscatePro()` 메서드를 호출해야 합니다. 자세한 내용은 [Pro API Methods](#shield-pro-api-methods-vm-obfuscation) 섹션을 참조하세요.
### `vmObfuscation`
유형: `boolean` 기본값: `false`
VM 기반 바이트코드 난독화를 활성화합니다. 활성화되면 JavaScript 함수가 내장 가상 머신에서 실행되는 커스텀 바이트코드로 컴파일됩니다. 이는 원래 코드 로직이 완전히 변환되므로 가장 높은 수준의 보호 기능을 제공합니다.
\*\*예시:\*\*
`return qty \* price`와 같이 읽기 쉬운 코드가 내장된 VM 인터프리터만 실행할 수 있는 `[0x15,0x03,0x17,...]` 같은 숫자 목록으로 변경됩니다. 원래 로직은 더 이상 JavaScript로 보이지 않습니다.
### `vmTargetFunctions`
유형: `string[]` 기본값: `[]`
이름으로 VM 보호를 적용할 최상위 함수를 정확히 지정합니다.
\*\*예시:\*\*
```javascript
{
vmObfuscation: true,
vmTargetFunctions: ['someFunctionName']
}
```
\*\*결과:\*\* 이 세 가지 함수만 VM 보호를 받습니다. 나머지는 일반적인(하지만 여전히 난독화된) JavaScript로 유지됩니다. 코드의 나머지는 간결하게 유지하면서 민감한 라이선스 검사나 인증 로직을 보호하는 데 완벽합니다.
### `vmExcludeFunctions`
유형: `string[]` 기본값: `[]`
VM 보호를 절대 적용하지 않아야 하는 최상위 함수를 지정합니다. 다른 설정보다 우선합니다.
\*\*예시:\*\*
```javascript
{
vmObfuscation: true,
vmExcludeFunctions: ['someFunctionName']
}
```
\*\*사용 시기:\*\* 성능이 중요한 최상위 함수(애니메이션 루프, 실시간 데이터 처리)는 다른 모든 것을 보호하면서 VM 오버헤드를 피하기 위해 제외할 수 있습니다.
### `vmTargetFunctionsMode`
유형: `string` 기본값: `root`
VM 난독화를 위해 함수/메서드가 선택되는 방식을 제어합니다.
| 모드 | 설명 |
|------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `root` | 기본 동작입니다. 최상위 함수만 VM 난독화 대상으로 고려됩니다. 필터링을 위해 `vmTargetFunctions` 허용 목록(allow-list)과 `vmExcludeFunctions` 거부 목록(deny-list)을 사용합니다. |
| `comment` | `/\* javascript-obfuscator:vm \*/` 주석이 달린 함수/메서드만 VM 난독화됩니다. \*\*모든 중첩 수준\*\*의 함수/메서드에서 작동합니다. |
\*\*예시 - 주석 모드:\*\*
```javascript
// 소스 코드
function regularFunction() {
return 'not virtualized';
}
/\* javascript-obfuscator:vm \*/
function sensitiveFunction() {
return 'this will be VM-protected';
}
function outer() {
/\* javascript-obfuscator:vm \*/
function nestedSensitive() {
return 'nested but still VM-protected';
}
return nestedSensitive();
}
```
```javascript
// 난독화 옵션
{
vmObfuscation: true,
vmTargetFunctionsMode: 'comment'
}
```
\*\*사용 시기:\*\* 민감한 로직이 포함된 중첩 함수를 포함하여 정확히 어떤 함수가 VM 보호를 받을지 세밀하게 제어해야 할 때 사용합니다. 최상위 명명된 함수에서만 작동하는 `vmTargetFunctions`와 달리, 주석 모드를 사용하면 코드 어디에 있는 어떤 함수든 보호할 수 있습니다.
### `vmWrapTopLevelInitializers`
유형: `boolean` 기본값: `false`
일부 최상위 변수 초기화 구문을 IIFE(즉시 실행 함수 표현식)로 감싸서 VM 난독화가 가능하게 합니다.
\*\*동작 방식:

\*\*
이 옵션이 없으면 최상위 상징(constants)과 변수가 출력 결과에 그대로 노출됩니다:
```javascript
// Input
const MY\_STRING = "my-string";
// Output (without vmWrapTopLevelInitializers)
const MY\_STRING = "my-string"; // String is visible!
```
이 옵션을 활성화하면 초기화 코드가 VM 난독화가 적용된 IIFE로 감싸집니다:
```javascript
// Input
const MY\_STRING = "my-string";
// Output (with vmWrapTopLevelInitializers: true)
const MY\_STRING = (() => { return /\* VM bytecode call \*/ })(); // String hidden in bytecode
```
\*\*참고:\*\* 이 옵션은 `vmTargetFunctionsMode`가 기본값인 `'root'`일 때만 작동합니다.
### `vmDynamicOpcodes`
타입: `boolean` 기본값: `false`
VM 인터프리터의 크기를 줄이고 빌드마다 고유한 형태로 만듭니다.
\*\*동작 방식:\*\*
1. \*\*사용되지 않는 명령어 필터링\*\* - 코드에서 클래스를 사용하지 않는 경우, 클래스 관련 명령어가 완전히 제거됩니다.
2. \*\*구조 무작위화\*\* - 빌드할 때마다 명령어 핸들러의 순서가 섞입니다.
그 결과, 출력 파일의 크기가 작아지고 빌드마다 다른 코드가 생성됩니다.
### `vmBytecodeEncoding`
타입: `boolean` 기본값: `false`
각 바이트코드 명령어를 인코딩합니다. 실행 중에 명령어가 하나씩 디코딩됩니다.
### `vmBytecodeArrayEncoding`
타입: `boolean` 기본값: `false`
전체 바이트코드 배열을 단일 블록으로 인코딩합니다. 배열은 실행이 시작되기 전 시작 시점에 한 번 디코딩됩니다. 이중 보호를 위해 `vmBytecodeEncoding`과 함께 사용하세요.
### `vmBytecodeArrayEncodingKey`
타입: `string` 기본값: `''`
바이트코드 배열 인코딩을 위한 사용자 정의 암호화 키입니다. 이 값을 설정하면 기본 환경 파생 키 대신 이 키가 사용됩니다. 키는 런타임에 `vmBytecodeArrayEncodingKeyGetter`를 통해 제공되어야 합니다.
이 옵션은 암호화 키를 외부화하며, 난독화된 코드 내부에 직접 포함되지 않습니다. 키는 런타임에 여전히 접근할 수 있으므로(따라서 진정한 의미의 비밀은 아님) 이 분리를 통해 정적 분석 도구가 코드만 검사하여 키를 찾는 것을 방지할 수 있습니다.
\*\*중요:\*\* 난독화된 코드가 로드될 때 키를 \*\*동기적으로(synchronously)\*\* 사용할 수 있어야 합니다. 쿠키, localStorage, sessionStorage, 전역 변수 또는 DOM 요소(예: 서버에서 주입된 meta 태그)와 같은 동기식 저장소를 사용하세요. `fetch()` 같은 비동기 메서드는 키 getter 표현식에서 직접 사용할 수 없습니다.
### `vmBytecodeArrayEncodingKeyGetter`
타입: `string` 기본값: `''`
런타임에 암호화 키를 \*\*반환하는\*\* \*\*동기식(Synchronous)\*\* JavaScript 표현식입니다. 이 표현식은 난독화된 코드가 로드될 때 평가되며, `vmBytecodeArrayEncodingKey`에 제공된 것과 정확히 동일한 키를 반환해야 합니다.
\*\*난독화된 코드는 키 getter가 난독화 시 사용된 것과 정확히 일치하는 키를 반환할 때만 작동합니다.\*\* 키가 일치하지 않으면 복호화에 실패하고 코드가 쓰레기 값이나 오류를 발생시킵니다. 키 getter가 `undefined`, `null` 또는 빈 문자열을 반환하면 코드는 "VM decryption key not available" 오류를 발생시킵니다.
\*\*중요:\*\* 키는 난독화된 코드와 동일한 JavaScript 파일/스크립트에 정의되어 있으면 안 됩니다. 그렇게 하면 정적 분석으로 여전히 키를 찾을 수 있으므로 키 외부화의 목적이 사라집니다. 서버에서 설정한 쿠키, 다른 스크립트에 의해 채워진 localStorage, 서버에서 주입된 HTML meta 태그, 또는 난독화된 코드보다 먼저 로드되는 다른 스크립트에 의해 설정된 전역 변수와 같은 별도의 소스에 키를 저장하세요.
예시:
```ts
// From cookie
vmBytecodeArrayEncodingKeyGetter: "document.cookie.match(/vmKey=([^;]+)/)?.[1]"
// From localStorage
vmBytecodeArrayEncodingKeyGetter: "localStorage.getItem('vmKey')"
// From global variable
vmBytecodeArrayEncodingKeyGetter: "window.\_\_VM\_KEY\_\_"
// From meta tag (server-injected)
vmBytecodeArrayEncodingKeyGetter: "document.querySelector('meta[name=\"vm-key\"]').content"
// From nested object
vmBytecodeArrayEncodingKeyGetter: "window.config.encryption.key"
```
\*\*사용 예시:\*\*
```ts
// Build time
JavaScriptObfuscator.obfuscate(code, {
vmObfuscation: true,
vmBytecodeArrayEncoding: tr

ue,
vmBytecodeArrayEncodingKey: 'mySecretKey123',
vmBytecodeArrayEncodingKeyGetter: 'window.\_\_VM\_KEY\_\_'
});
// 런타임 - 난독화된 코드가 실행되기 전에 키가 설정되어야 합니다.
window.\_\_VM\_KEY\_\_ = 'mySecretKey123';
```
### `vmJumpsEncoding`
Type: `boolean` Default: `false`
바이트코드의 점프 타겟을 인코딩합니다. 점프 오프셋은 런타임에 계산되며, 정적 분석으로부터 제어 흐름 구조(`if`/`else`, 반복문 등)를 숨깁니다.
### `vmDecoyOpcodes`
Type: `boolean` Default: `false`
결코 호출되지 않는 가짜 연산 코드(opcode) 핸들러를 VM 디스패처에 추가합니다. 예를 들어 VM이 20개의 실제 연산 코드를 사용하는 경우, 30개의 가짜 핸들러를 추가하여 인터프리터가 실제보다 더 복잡해 보이도록 만듭니다.
### `vmDeadCodeInjection`
Type: `boolean` Default: `false`
절대 실행되지 않는 가짜 바이트코드 시퀀스를 주입합니다. 이 시퀀스는 실제 명령어처럼 보이지만 런타임 중에 건너뛰어지므로, 이를 처리하는 분석 도구를 혼란스럽게 만듭니다.
### `vmMacroOps`
Type: `boolean` Default: `false`
일반적인 명령어 시퀀스를 단일 "매크로" 연산 코드로 결합합니다. 예를 들어 `LOAD + ADD + STORE`가 단일 `MACRO\_ADD\_TO\_VAR` 명령어로 바뀔 수 있습니다. 이는 패턴 인식을 깨뜨리고 성능을 향상시킬 수 있습니다.
### `vmDebugProtection`
Type: `boolean` Default: `false`
VM 런타임에 다중 계층 디버깅 방지, 분석 방지, LLM 방어 기능을 추가합니다. 최상의 결과를 위해 Content Security Policy에서 `unsafe-eval`을 허용하세요. `browser`/`browser-no-eval` 타겟과 함께 사용할 때 가장 잘 작동합니다.
### `vmSelfDefending`
Type: `boolean` Default: `false`
VM 런타임에 다중 계층 변조 감지, 후킹 방지, 역엔지니어링 방지 보호 기능을 추가합니다.
> :warning: 이 옵션은 [`vmBytecodeArrayEncoding`](#vmbytecodeArrayEncoding)을 강제로 활성화합니다.
[`vmDebugProtection`](#vmDebugProtection), [`vmBytecodeArrayEncodingKey`](#vmBytecodeArrayEncodingKey), [`vmBytecodeArrayEncodingKeyGetter`](#vmBytecodeArrayEncodingKeyGetter)와 함께 사용하는 것을 강력히 권장합니다.
### `vmStatefulOpcodes`
Type: `boolean` Default: `false`
연산 코드의 의미가 바이트코드 내의 위치에 따라 달라지도록 만듭니다. 각 위치는 시드(seed)에서 파생된 서로 다른 연산 코드-핸들러 매핑을 가지므로, 동일한 연산 코드 번호가 위치에 따라 서로 다른 작업을 수행합니다.
### `vmStackEncoding`
Type: `boolean` Default: `false`
실행 중에 VM 스택의 값을 암호화합니다. 값은 푸시될 때 인코딩되고 팝될 때 디코딩되므로, 메모리 검사 시 실제 값 대신 암호화된 데이터가 표시됩니다.
이 옵션은 성능에 큰 영향을 미칩니다.
### `vmCompactDispatcher`
Type: `boolean` Default: `false`
이중 executor(동기 + 제너레이터) 대신 단일 VM executor를 사용합니다. 난독화된 코드 크기를 줄이지만 재귀가 많은 코드에서 약 20%의 성능 오버헤드를 추가합니다.
- `false` (기본값): 이중 executor — 최적의 성능, 더 큰 출력 결과
- `true`: 단일 executor — 더 작은 출력 결과, 약간 느림
### `vmStringArrayBytecodeOnly`
Type: `boolean` Default: `false`
활성화하면 문자열 배열은 \*\*오직\*\* 바이트코드 데이터에서만 문자열을 추출하며, 코드 내의 다른 문자열은 변환되지 않습니다. 이는 명시적으로 설정되지 않은 경우에도 `stringArray`를 강제로 활성화합니다.
\*\*사용 이유:\*\* 모든 VM 런타임 문자열을 문자열 배열로 추출하는 작업은 느립니다. 이 옵션은 문자열 배열 추출을 바이트코드 콘텐츠로만 타겟팅하여, 바이트코드 상수를 보호하는 동시에 성능을 향상시킵니다.
- `vmBytecodeArrayEncoding: false`인 경우 — 바이트코드 상수 풀(`c` 배열) 내부의 문자열이 추출됩니다.
- `vmBytecodeArrayEncoding: true`인 경우 — 최상위 Base64 인코딩된 바이트코드 문자열이 추출됩니다.
- `stringArrayThreshold`는 해당 바이트코드 문자열 중 몇 퍼센트가 추출될지를 계속 제어합니다.
### `strictMode`
Type: `boolean | null` Default: `null`
난독화 도구가 JavaScript 엄격 모드(strict mode)와 관련하여 코드를 처리하는 방법을 지정할 수 있습니다.
사용 가능한 값:
\* `null` (기본값) - 코드에서 엄격 모드를 자동으로 감지합니다. 코드에 명시적인 `'use strict'` 지시문, ES 모듈 구문 또는 클래스 메서드가 있는 경우 엄격 모드로 취급됩니다. 그렇지 않으면 슬로피 모드(sloppy mode)로 가정됩니다.
\*

* `true` - 명시적인 `'use strict'` 지시문이 없더라도 모든 코드에 대해 엄격 모드(strict mode) 처리를 강제합니다. 코드 가 ES 모듈, 번들러, 최신 프레임워크 등 엄격 모드 컨텍스트에서 실행될 때 이 옵션을 사용하세요.
* `false` - 명시적인 엄격 모드 표시(`'use strict'`, ES 모듈, 클래스 메서드 등)가 있는 경우에만 엄격 모드로 처리됩니다. 상위 스코프 상속은 여전히 JS 스펙에 따라 적용됩니다.

### `parseHtml`
Type: `boolean` Default: `false`
HTML 내의 JavaScript 난독화를 활성화합니다.

```
JavaScriptObfuscator.obfuscate(html, {
parseHtml: true,
stringArray: true
});
// output: HTML with only the marked script obfuscated
```
## 자주 묻는 질문 (FAQ)
### 지원되는 JavaScript 버전은 무엇인가요?
`es3`, `es5`, `es2015`, `es2016`, `es2017`, `es2018`, `es2019` 및 부분적으로 `es2020`을 지원합니다.
### `README.md`에 설명된 기능을 사용하려고 하는데 작동하지 않아요!
master 브랜치의 README는 최신 안정 버전의 README와 일치하지 않을 수 있습니다.
### CLI 명령어가 작동하지 않는 이유는 무엇인가요?
`npm link javascript-obfuscator` 명령어를 실행하거나 `npm i -g javascript-obfuscator`를 사용하여 전역으로 설치해 보세요.
### 온라인 버전이 있나요?
[obfuscator.io](https://obfuscator.io)
### JSX를 지원하나요?
아니요. JSX 지원은 계획되어 있지 않습니다.
### 삽입된 노드의 변수 종류(`var`, `let`, `const`)는 어떻게 변경하나요?
참고: [`Kind of variables`](#kind-of-variables)
### 왜 `BigInt` 숫자 대신 `null` 값이 반환되나요?
`BigInt` 난독화는 `BigInt` 값을 지원하는 환경에서만 정상적으로 작동합니다. [ESTree spec](https://github.com/estree/estree/blob/master/es2020.md#bigintliteral)을 참고하세요.
### `renameProperties` 옵션을 활성화했더니 코드가 깨졌습니다! 어떻게 해야 하나요?
`renamePropertiesMode: 'safe'` 옵션을 시도해 보시고, 그래도 작동하지 않는다면 해당 옵션을 비활성화하세요.
## GitHub 스폰서
[![](https://avatars.githubusercontent.com/u/6154722?s=200&v=4)](https://github.com/microsoft)
## 후원자
월간 기부로 저희를 후원하고 활동을 이어갈 수 있도록 도와주세요. [[후원하기](https://opencollective.com/javascript-obfuscator#backer)]
[![](https://opencollective.com/javascript-obfuscator/backer/0/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/0/website)
[![](https://opencollective.com/javascript-obfuscator/backer/1/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/1/website)
[![](https://opencollective.com/javascript-obfuscator/backer/2/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/2/website)
[![](https://opencollective.com/javascript-obfuscator/backer/3/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/3/website)
[![](https://opencollective.com/javascript-obfuscator/backer/4/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/4/website)
[![](https://opencollective.com/javascript-obfuscator/backer/5/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/5/website)
[![](https://opencollective.com/javascript-obfuscator/backer/6/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/6/website)
[![](https://opencollective.com/javascript-obfuscator/backer/7/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/7/website)
[![](https://opencollective.com/javascript-obfuscator/backer/8/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/8/website)
[![](https://opencollective.com/javascript-obfuscator/backer/9/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/9/website)
[![](https://opencollective.com/javascript-obfuscator/backer/10/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/10/website)
[![](https://opencollective.com/javascript-obfuscator/backer/11/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/11/website)
[![](https://opencollective.com/javascript-obfuscator/backer/12/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/12/website)
[![](https://opencollective.com/javascript-obfuscator/backer/13/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/13/website)
[![](https://opencollective.com/javascript-obfuscator/backer/14/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/14/website)
[![](https://opencollective.com/javascript-obfuscator/backer/15/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/15/website)
[![](https://opencollective.com/javascript-obfuscator/backer/16/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/16/website)
[![](https://opencollective.com/javascrip

t-obfuscator/backer/17/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/17/website)
[![](https://opencollective.com/javascript-obfuscator/backer/18/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/18/website)
[![](https://opencollective.com/javascript-obfuscator/backer/19/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/19/website)
[![](https://opencollective.com/javascript-obfuscator/backer/20/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/20/website)
[![](https://opencollective.com/javascript-obfuscator/backer/21/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/21/website)
[![](https://opencollective.com/javascript-obfuscator/backer/22/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/22/website)
[![](https://opencollective.com/javascript-obfuscator/backer/23/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/23/website)
[![](https://opencollective.com/javascript-obfuscator/backer/24/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/24/website)
[![](https://opencollective.com/javascript-obfuscator/backer/25/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/25/website)
[![](https://opencollective.com/javascript-obfuscator/backer/26/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/26/website)
[![](https://opencollective.com/javascript-obfuscator/backer/27/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/27/website)
[![](https://opencollective.com/javascript-obfuscator/backer/28/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/28/website)
[![](https://opencollective.com/javascript-obfuscator/backer/29/avatar.svg)](https://opencollective.com/javascript-obfuscator/backer/29/website)
## Open Collective 스폰서
스폰서가 되어 Github의 README에 사이트 링크와 함께 로고를 등록해 보세요.
[![](https://opencollective.com/javascript-obfuscator/sponsor/0/avatar.svg)](https://opencollective.com/javascript-obfuscator/sponsor/0/website)
[![](https://opencollective.com/javascript-obfuscator/sponsor/1/avatar.svg)](https://opencollective.com/javascript-obfuscator/sponsor/1/website)
[![](https://opencollective.com/javascript-obfuscator/sponsor/2/avatar.svg)](https://opencollective.com/javascript-obfuscator/sponsor/2/website)
[![](https://opencollective.com/javascript-obfuscator/sponsor/3/avatar.svg)](https://opencollective.com/javascript-obfuscator/sponsor/3/website)
[![](https://opencollective.com/javascript-obfuscator/sponsor/4/avatar.svg)](https://opencollective.com/javascript-obfuscator/sponsor/4/website)
[![](https://opencollective.com/javascript-obfuscator/sponsor/5/avatar.svg)](https://opencollective.com/javascript-obfuscator/sponsor/5/website)
[![](https://opencollective.com/javascript-obfuscator/sponsor/6/avatar.svg)](https://opencollective.com/javascript-obfuscator/sponsor/6/website)
[![](https://opencollective.com/javascript-obfuscator/sponsor/7/avatar.svg)](https://opencollective.com/javascript-obfuscator/sponsor/7/website)
[![](https://opencollective.com/javascript-obfuscator/sponsor/8/avatar.svg)](https://opencollective.com/javascript-obfuscator/sponsor/8/website)
[![](https://opencollective.com/javascript-obfuscator/sponsor/9/avatar.svg)](https://opencollective.com/javascript-obfuscator/sponsor/9/website)
## 라이선스
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fjavascript-obfuscator%2Fjavascript-obfuscator.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fjavascript-obfuscator%2Fjavascript-obfuscator?ref=badge\_large)
Copyright (C) 2016-2026 [Timofei Kachalov](http://github.com/sanex3339).
소스 및 바이너리 형태의 재배포 및 사용은 수정 여부와 관계없이
다음 조건을 충족하는 경우 허용됩니다:
\* 소스 코드의 재배포 시에는 위의 저작권
고지, 본 조건 목록 및 다음 고지 사항을 유지해야 합니다.

laimer.
\* 바이너리 형태의 재배포는 위 저작권 고지, 본 조건 목록 및 아래의 면책 조항을 해당 배포와 함께 제공되는 문서 및/또는 기타 자료에 포함해야 합니다.
본 소프트웨어는 저작권자와 기여자들에 의해 "있는 그대로" 제공되며, 상품성 및 특정 목적에의 적합성에 대한 묵시적 보증을 포함하 어떠한 명시적이나 묵시적인 보증도 하지 않습니다. 어떠한 경우에도 저작권자나 기여자들은 본 소프트웨어의 사용으로 인해 발생한, 직접적, 간접적, 부수적, 특수적, 결과적 또는 징벌적 손해(대체 재화나 용역의 조달, 사용, 데이터 또는 이익의 손실, 또는 영업 중단을 포함하며, 이에 국한되지 않음)에 대해, 계약 책임, 엄격 책임, 불법행위(과실 등을 포함)를 불문하고, 그러한 손해의 발생 가능성이 사전에 고지되었다 할지라도, 어떠한 책임도 지지 않습니다.

javascript-obfuscator

javascript-obfuscator 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

javascript-obfuscator

javascript-obfuscator 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README