compact

Type: boolean Default: true

コードを 1 行に圧縮して出力します。

config

Type: string Default: ``

難読化ツールのオプションを含む JS/JSON 設定ファイルの名前です。これらの設定は、CLI に直接渡されたオプションによって上書きされます。

controlFlowFlattening

Type: boolean Default: false

⚠️ このオプションはパフォーマンスに大きな影響を与え、実行速度が最大 1.5 倍遅くなります。制御フローの平坦化の影響を受けるノードの割合を設定するには、controlFlowFlatteningThreshold を使用してください。

コードの制御フローの平坦化を有効にします。制御フローの平坦化は、ソースコードの構造を変換してプログラムの理解を妨げる手法です。

例:

// 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 変換が任意のノードに適用される確率です。

この設定は、大量の制御フロー変換がコードの速度を低下させ、コードサイズを増大させる可能性があるため、コードサイズが大きい場合に特に有用です。

controlFlowFlatteningThreshold: 0 は controlFlowFlattening: false と同等です。

deadCodeInjection

Type: boolean Default: false

⚠️ 難読化されたコードのサイズが大幅に増加します（最大 200%）。難読化されたコードのサイズが問題にならない場合にのみ使用してください。デッドコード注入の影響を受けるノードの割合を設定するには、deadCodeInjectionThreshold を使用してください。

⚠️ このオプションは stringArray オプションを強制的に有効にします。

⚠️ このオプションは vmObfuscation が有効な場合、暗黙的に無効化されます。

このオプションを使用すると、ランダムなデッドコードのブロックが難読化されたコードに追加されます。

例:

// 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

Type: number Default: 0.4 Min: 0 Max: 1

deadCodeInjection の影響を受けるノードの割合を設定できます。

debugProtection

Type: boolean Default: false

⚠️ 開発者ツールを開くと、ブラウザがフリーズする可能性があります。

⚠️ このオプションは vmObfuscation が有効な場合、暗黙的に無効化されます。代わりに vmDebugProtection を使用してください。

このオプションは、開発者ツールの debugger 機能をほぼ使用不可能にします（WebKit ベースおよび Mozilla Firefox の両方）。

debugProtectionInterval

Type: number Default: 0

⚠️ ブラウザがフリーズする可能性があります！ 自己責任でご使用ください。

⚠️ このオプションは vmObfuscation が有効な場合、暗黙的に無効化されます。代わりに vmDebugProtection を使用してください。

設定すると、ミリ秒単位のインターバルを使用してコンソールタブでデバッグモードを強制し、開発者ツールの他の機能を使いにくくします。debugProtection が有効な場合に機能します。推奨値は 2000～4000 ミリ秒です。

disableConsoleOutput

Type: boolean Default: false

⚠️ このオプションは、すべてのスクリプトで console の呼び出しをグローバルに無効化します

console.log、console.info、console.error、console.warn、console.debug、console.exception、console.trace を空の関数に置き換えることで、それらの使用を無効化します。これにより、デバッガーの使用が困難になります。

domainLock

Type: string[] Default: []

⚠️ このオプションは target: 'node'、target: 'service-worker'、target: 'bytenode' では機能しません

難読化されたソースコードを、特定のドメインやサブドメインでのみ実行できるようにします。これにより、ソースコードを単にコピー＆ペーストして別の場所で実行することが非常に困難になります。

ソースコードがこのオプションで指定されたドメイン上で実行されていない場合、ブラウザは domainLockRedirectUrl オプションに渡された URL にリダイレクトされます。

複数のドメインとサブドメイン

コードを複数のドメインやサブドメインにロックすることも可能です。たとえば、コードが www.example.com でのみ実行されるようにロックするには、www.example.com を追加します。ルートドメインおよびすべてのサブドメイン（example.com、sub.example.com）で機能させるには、.example.com を使用します。

domainLockRedirectUrl

Type: string Default: about:blank

⚠️ このオプションは target: 'node'、target: 'service-worker'、target: 'bytenode' では機能しません

ソースコードが domainLock で指定されたドメイン上で実行されていない場合に、ブラウザを指定した URL にリダイレクトできるようにします。

exclude

Type: string[] Default: []

難読化から除外するファイルを示すファイル名またはグロブです。

forceTransformStrings

Type: string[] Default: []

渡された RegExp パターンに一致する文字列リテラルの変換を強制的に有効にします。

⚠️ このオプションは、stringArrayThreshold（または将来的に追加される可能性のある他のしきい値）によって変換されるべきでない文字列にのみ影響します

このオプションは reservedStrings オプションよりも優先されますが、conditional comments よりは優先されません。

例:

	{
		forceTransformStrings: [
			'some-important-value',
			'some-string_\d'
		]
	}

identifierNamesCache

Type: Object | null Default: null

このオプションの主な目的は、複数のソース／ファイルの難読化中に同じ識別子名を使用できるようにすることです。

現在、2 種類の識別子がサポートされています:

• グローバル識別子:
  • すべてのグローバル識別子がキャッシュに書き込まれます。
  • 一致した未宣言のグローバル識別子は、キャッシュの値で置き換えられます。
• プロパティ識別子（renameProperties オプションが有効な場合のみ）:
  • すべてのプロパティ識別子がキャッシュに書き込まれます。
  • 一致したすべてのプロパティ識別子は、キャッシュの値で置き換えられます。

Node.js API

null 値を渡すと、キャッシュを完全に無効化します。

空のオブジェクト（{}）を渡すと、識別子名のキャッシュオブジェクト（TIdentifierNamesCache 型）への書き込みが有効になります。このキャッシュオブジェクトには、ObfuscationResult オブジェクトの getIdentifierNamesCache メソッドの呼び出しを通じてアクセスできます。

結果として得られたキャッシュオブジェクトは、次に identifierNamesGenerator オプションの値として使用でき、以降のソースで一致するすべての識別子名の難読化時にこれらの名前を使用できます。

例:

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 には別のオプション --identifier-names-cache-path があり、識別子名のキャッシュの読み書きに使用される既存の .json ファイルへのパスを定義できます。

空のファイルへのパスが渡された場合、識別子名のキャッシュがそのファイルに書き込まれます。

既存のキャッシュを含むこのファイルは、次に --identifier-names-cache-path オプションの値として再度使用でき、以降のファイルで一致するすべての識別子名の難読化時にこれらの名前を使用できます。

identifierNamesGenerator

Type: string Default: hexadecimal

識別子名のジェネレーターを設定します。

利用可能な値:

• dictionary: identifiersDictionary リストの識別子名
• hexadecimal: _0xabc123 のような識別子名
• mangled: a、b、c のような短い識別子名
• mangled-shuffled: mangled と同様ですが、アルファベットがシャッフルされます

identifiersDictionary

Type: string[] Default: []

identifierNamesGenerator: dictionary オプション用の識別子辞書を設定します。辞書の各識別子は、各文字の大文字・小文字を変えた複数のバリエーションで使用されます。したがって、辞書内の識別子の数は、元のソースコードの識別子の数に応じて決める必要があります。

identifiersPrefix

Type: string Default: ''

すべてのグローバル識別子にプレフィックスを設定します。

複数のファイルを難読化する場合にこのオプションを使用してください。このオプションは、これらのファイルのグローバル識別子間の競合を回避するのに役立ちます。プレフィックスはファイルごとに異なるものにする必要があります。

randomIdentifiersPrefix

Type: boolean Default: false

すべてのグローバル識別子に、シードから生成されるランダムなプレフィックス（英数字 6 文字）を付加します。このオプションを使用すると、同じグローバルスコープに読み込まれる、個別に難読化されたバンドル間の衝突を回避できます。バンドルごとに一意の identifiersPrefix を手動で選ぶ必要がなくなります。

• ランダムな値は seed オプションとソースコードのハッシュから導出されるため、同じシードによる再現可能なビルドでは同じプレフィックスが生成されます。
• identifiersPrefix と組み合わせた場合、ランダムな文字はユーザーが指定したプレフィックスの後に付加されます（例: myApp + ランダムな aBc123 → myAppaBc123）。
• vmObfuscation と組み合わせた場合、ランダムな値がデフォルトの vm プレフィックスを置き換えます。ランダム性によって一意性がすでに保証されているためです。

ignoreImports

Type: boolean Default: false

require によるインポートの難読化を防ぎます。何らかの理由で実行環境が静的な文字列のみでこれらのインポートを要求する場合に役立つことがあります。

inputFileName

Type: string Default: ''

ソースコードを含む入力ファイルの名前を設定できます。この名前はソースマップ生成のために内部的に使用されます。 NodeJS API を使用し、sourceMapSourcesMode オプションが sources 値を持つ場合に必要です。

log

Type: boolean Default: false

情報のコンソールへのログ出力を有効にします。

numbersToExpressions

Type: boolean Default: false

数値を式に変換する機能を有効にします。

例:

// input
const foo = 1234;

// output
const foo=-0xd93+-0x10b4+0x41*0x67+0x84e*0x3+-0xff8;

optionsPreset

Type: string Default: default

オプションプリセットを設定できます。

利用可能な値:

• vm-default;
• vm-low-obfuscation;
• vm-medium-obfuscation;
• vm-high-obfuscation;
• vm-ultra-high-obfuscation;
• vm-anti-llm;
• default;
• low-obfuscation;
• medium-obfuscation;
• high-obfuscation.

追加のオプションはすべて、選択したオプションプリセットにマージされます。

parseHtml

Type: boolean Default: false

HTML の <script> タグ内の JavaScript の難読化を有効にします。

有効にすると、難読化ツールは次の処理を行います:

• 入力が HTML かどうかを自動検出します（<!DOCTYPE、<html>、<head>、<body>、<script> タグの有無を確認）
• data-javascript-obfuscator 属性が付いた <script> タグから JavaScript を抽出します
• HTML 構造を保持しながら、マークされた各スクリプトを個別に難読化します
• 難読化されたコードを元の位置に注入し直します

重要: data-javascript-obfuscator 属性を持つスクリプトのみが難読化されます。マークされた各スクリプトは個別かつ独立して難読化されます。つまり:

• マークされたスクリプトタグ内のコードは独立している必要があります — 他のマークされたスクリプトタグで定義された変数、関数、クラスを参照してはいけません
• マークされていないスクリプトは、マークされたスクリプトが定義したグローバル（var 宣言や明示的な globalThis への代入経由）に引き続きアクセスできます
• これにより、どのスクリプトを保護するかを明示的に制御できます

難読化される（data-javascript-obfuscator 属性が必要）:

• <script data-javascript-obfuscator> - 通常のスクリプト
• <script type="text/javascript" data-javascript-obfuscator> - 型が明示的に指定されたスクリプト
• 追加の属性（id、class、その他の data-* など）を持つスクリプト

スキップされる（変更されない）:

• data-javascript-obfuscator 属性を持たないスクリプト
• <script type="module"> - ES モジュール（属性が付いていても）
• <script src="..."> - 外部スクリプト（属性が付いていても）
• 空のスクリプトタグ

注意: parseHtml が有効な場合、ソースマップは生成されません。HTML 出力に対して正しくマッピングされないためです。

例:

// input
const html = `<!DOCTYPE html>
<html>
<body>
<!-- This script will NOT be obfuscated -->
<script>
var helper = 'utility';
</script>

<!-- This script WILL be obfuscated -->
<script data-javascript-obfuscator>
var greeting = 'Hello World';
console.log(greeting);
</script>
</body>
</html>`;

JavaScriptObfuscator.obfuscate(html, {
    parseHtml: true,
    stringArray: true
});

// output: HTML with only the marked script obfuscated

renameGlobals

Type: boolean Default: false

⚠️ このオプションはコードを壊す可能性があります。動作を理解している場合にのみ有効にしてください！

グローバル変数名と関数名の宣言を含めた難読化を有効にします。

このオプションが無効で、入力コードがグローバルスコープに関数やクラスを宣言している場合（つまりコードが IIFE でラップされていない場合）、それらの名前は難読化された出力でもそのまま維持されます。他のスクリプトがそれらを名前で参照している可能性があるためです。vmObfuscation の下では、これらの名前を列挙した VMGlobalFunctionNamesNotRenamed 警告が報告されます。関数本体はバイトコードとして隠されますが、読み取り可能なトップレベルの名前がコードの機能を（たとえば LLM に対して）依然として明らかにしてしまうためです。この露出を避けるには、コードを IIFE でラップするか、このオプションを有効にしてください。

renameProperties

Type: boolean Default: false

⚠️ このオプションはコードを壊す可能性があります。動作を理解している場合にのみ有効にしてください！

プロパティ名のリネームを有効にします。すべての組み込み DOM プロパティおよびコア JavaScript クラスのプロパティは無視されます。

このオプションの safe モードと unsafe モードを切り替えるには、renamePropertiesMode オプションを使用してください。

リネームされたプロパティ名の形式を設定するには、identifierNamesGenerator オプションを使用してください。

どのプロパティをリネームするかを制御するには、reservedNames オプションを使用してください。

例:

// 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

Type: string Default: safe

⚠️ safe モードであっても、renameProperties オプションはコードを壊す可能性があります。

renameProperties オプションのモードを指定します:

• safe - 2.11.0 リリース以降のデフォルトの動作です。実行時エラーを防ぐため、より安全な方法でプロパティのリネームを試みます。このモードでは、一部のプロパティがリネームから除外されます。
• unsafe - 2.11.0 リリース以前のデフォルトの動作です。制限なしに安全でない方法でプロパティをリネームします。

あるファイルが別のファイルのプロパティを使用している場合は、identifierNamesCache オプションを使用して、これらのファイル間で同じプロパティ名を維持してください。

reservedNames

Type: string[] Default: []

渡された RegExp パターンに一致する識別子の難読化と生成を無効にします。

例:

	{
		reservedNames: [
			'^someVariable',
			'functionParameter_\d'
		]
	}

reservedStrings

Type: string[] Default: []

渡された RegExp パターンに一致する文字列リテラルの変換を無効にします。一致した文字列は、難読化された出力でも表示されたまま残ります。

VM 難読化を使用する場合、予約された文字列は表示されたままにするため、別の暗号化されていない配列に格納されます。これは、監視用の API エンドポイントやライブラリ識別子など、読み取り可能なまま残す必要がある文字列に役立ちます。

例:

	{
		reservedStrings: [
			'react-native',
			'\.\/src\/test',
			'some-string_\d'
		]
	}

seed

Type: string|number Default: 0

このオプションは乱数ジェネレーターのシードを設定します。これは再現可能な結果を生成する際に役立ちます。

シードが 0 の場合、乱数ジェネレーターはシードなしで動作します。

selfDefending

Type: boolean Default: false

⚠️ このオプションで難読化した後は、コードをいかなる方法でも変更しないでください。コードの整形（uglify）などの変更はセルフディフェンディングを作動させ、コードが動作しなくなる可能性があります！

⚠️ このオプションは compact の値を強制的に true に設定します

⚠️ このオプションは vmObfuscation が有効な場合、暗黙的に無効化されます。代わりに vmSelfDefending を使用してください。

このオプションは、出力コードを整形や変数のリネームに対して耐性のあるものにします。難読化されたコードに JavaScript の整形ツールを使用しようとすると、コードが動作しなくなり、理解や変更がより困難になります。

simplify

Type: boolean Default: true

簡略化による追加のコード難読化を有効にします。

⚠️ 将来のリリースでは、boolean リテラルの難読化（true => !![]）がこのオプションの配下に移されます。

例:

// 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

難読化されたコードのソースマップ生成を有効にします。

ソースマップは、難読化された JavaScript ソースコードのデバッグに役立ちます。本番環境でデバッグしたい場合や必要がある場合は、別のソースマップファイルを秘密の場所にアップロードし、ブラウザをそこに向けることができます。

sourceMapBaseUrl

Type: string Default: ``

sourceMapMode: 'separate' の場合に、ソースマップのインポート 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 オプションの値の長さのチャンクに分割します。

例:

// input
(function(){
    var test = 'abcdefg';
})();

// output
(function(){
    var _0x5a21 = 'ab' + 'cd' + 'ef' + 'g';
})();

splitStringsChunkLength

Type: number Default: 10

splitStrings オプションのチャンク長を設定します。

stringArray

Type: boolean Default: true

文字列リテラルを削除し、専用の配列に配置します。たとえば、var m = "Hello World"; の文字列 "Hello World" は、var m = _0x12c456[0x1]; のようなものに置き換えられます。

stringArrayCallsTransform

Type: boolean Default: false

⚠️ stringArray オプションが有効になっている必要があります

stringArray への呼び出しの変換を有効にします。これらの呼び出しのすべての引数は、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

⚠️ stringArray と stringArrayCallsTransformThreshold オプションが有効になっている必要があります

この設定を使用して、文字列配列への呼び出しが変換される確率（0 から 1）を調整できます。

stringArrayEncoding

Type: string[] Default: []

⚠️ stringArray オプションが有効になっている必要があります

このオプションはスクリプトの速度を低下させる可能性があります。

stringArray のすべての文字列リテラルを base64 または rc4 を使用してエンコードし、実行時にそれをデコードするための特別なコードを挿入します。

各 stringArray の値は、渡されたリストからランダムに選ばれたエンコードでエンコードされます。これにより、複数のエンコードを使用できます。

利用可能な値:

• 'none'（boolean）: stringArray の値をエンコードしません
• 'base64'（string）: base64 を使用して stringArray の値をエンコードします
• 'rc4'（string）: rc4 を使用して stringArray の値をエンコードします。base64 より約 30～50% 遅くなりますが、初期値を取得するのがより困難になります。

たとえば、次のオプション値では、一部の stringArray の値はエンコードされず、一部の値は base64 および rc4 エンコードでエンコードされます:

stringArrayEncoding: [
    'none',
    'base64',
    'rc4'
]

stringArrayIndexesType

Type: string[] Default: ['hexadecimal-number']

⚠️ stringArray オプションが有効になっている必要があります

文字列配列の呼び出しインデックスの型を制御できます。

各 stringArray の呼び出しインデックスは、渡されたリストからランダムに選ばれた型で変換されます。これにより、複数の型を使用できます。

利用可能な値:

• 'hexadecimal-number'（default）: 文字列配列の呼び出しインデックスを 16 進数として変換します
• 'hexadecimal-numeric-string': 文字列配列の呼び出しインデックスを 16 進数の数値文字列として変換します

2.9.0 リリース以前は、javascript-obfuscator はすべての文字列配列の呼び出しインデックスを hexadecimal-numeric-string 型で変換していました。これにより手作業での難読化解除は多少難しくなりますが、自動難読化解除ツールがこれらの呼び出しを容易に検出できてしまいます。

新しい hexadecimal-number 型は、コード内の文字列配列の呼び出しパターンの自動検出をより困難にすることを目指しています。

将来的にはさらに多くの型が追加される予定です。

stringArrayIndexShift

Type: boolean Default: true

⚠️ stringArray オプションが有効になっている必要があります

すべての文字列配列の呼び出しに対して、追加のインデックスシフトを有効にします。

stringArrayRotate

Type: boolean Default: true

⚠️ stringArray が有効になっている必要があります

stringArray 配列を、固定かつランダムな（コードの難読化時に生成される）位置だけシフトします。これにより、削除された文字列の順序を元の位置と対応付けることが困難になります。

stringArrayShuffle

Type: boolean Default: true

⚠️ stringArray が有効になっている必要があります

stringArray 配列の項目をランダムにシャッフルします。

stringArrayWrappersCount

Type: number Default: 1

⚠️ stringArray オプションが有効になっている必要があります

各ルートまたは関数スコープ内の string array 用ラッパーの数を設定します。 各スコープ内のラッパーの実際の数は、そのスコープ内の literal ノードの数によって制限されます。

例:

// 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 = _0x2e13;
    const _0x1392b0 = _0x1c262f(0xe7);
    const _0x201a58 = _0x1c262f(0xe2);
    const _0xd3a7fb = _0x1c262f(0xe6);
}
const eagle = _0x48f96e(0xe5);

stringArrayWrappersChainedCalls

Type: boolean Default: true

⚠️ stringArray と stringArrayWrappersCount オプションが有効になっている必要があります

string array ラッパー間の連鎖呼び出しを有効にします。

例:

// 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

⚠️ stringArray オプションが有効になっている必要があります

⚠️ 現在このオプションは、stringArrayWrappersType の function オプション値によって追加されたラッパーにのみ影響します

文字列配列ラッパーのパラメーターの最大数を制御できます。 デフォルト値および最小値は 2 です。推奨値は 2～5 です。

stringArrayWrappersType

Type: string Default: variable

⚠️ stringArray と stringArrayWrappersCount オプションが有効になっている必要があります

stringArrayWrappersCount オプションによって追加されるラッパーの型を選択できます。

利用可能な値:

• 'variable': 各スコープの先頭に変数ラッパーを追加します。高速なパフォーマンスです。
• 'function': 各スコープ内のランダムな位置に関数ラッパーを追加します。variable よりもパフォーマンスは遅くなりますが、より厳格な難読化を提供します。

パフォーマンスの低下が難読化対象アプリケーションに大きな影響を与えない場合は、より高い難読化のために function ラッパーを使用することを強くお勧めします。

'function' オプション値の例:

// 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

⚠️ stringArray オプションが有効になっている必要があります

この設定を使用して、文字列リテラルが stringArray に挿入される確率（0 から 1）を調整できます。

この設定は、string array を繰り返し呼び出すことでコードの速度を低下させる可能性があるため、コードサイズが大きい場合に特に有用です。

stringArrayThreshold: 0 は stringArray: false と同等です。

strictMode

Type: boolean | null Default: null

JavaScript の strict モードに関して、難読化ツールがコードをどのように扱うかを指定できます。

利用可能な値:

• null（デフォルト） - コードから strict モードを自動検出します。コードに明示的な 'use strict' ディレクティブ、ES モジュール構文、またはクラスメソッドが含まれている場合、strict モードとして扱われます。それ以外の場合は sloppy モードとみなされます。
• true - 明示的な 'use strict' ディレクティブがなくても、すべてのコードを strict モードとして扱うことを強制します。コードが strict モードのコンテキスト（ES モジュール、バンドラー、モダンなフレームワークなど）で実行される場合に使用してください。
• false - 明示的な strict モードの指標（'use strict'、ES モジュール、クラスメソッド）のみが strict として扱われます。親スコープの継承は JS の仕様どおり引き続き適用されます。

target

Type: string Default: browser

難読化されたコードのターゲット環境を設定できます。

利用可能な値:

• browser（デフォルト） — 標準的な Web ページ環境です。出力コードは node と同一ですが、一部のブラウザ固有のオプションは node ターゲットでは使用できません
• browser-no-eval — browser と同じですが、出力で eval() を使用しません。ターゲットページの Content Security Policy が eval／unsafe-eval を禁止している場合に使用してください
• node — Node.js 環境です。ブラウザ固有のオプションは無効化されます（それらは window／document を必要とし、Node では何もしないか例外をスローするためです）。ヘッドレスブラウザの検知、iframe を用いたクリーンレルムの回復、インスペクター／DOM 対策のチェックなど、ブラウザ専用の API に依存する一部の vmSelfDefending の防御は、このターゲットでは出力されません
• service-worker — Service Worker のコンテキストです。window も document もなく、self グローバルが異なります
• userscript — ユーザースクリプトマネージャーのサンドボックス（Tampermonkey など）です。vmSelfDefending の防御はそれに応じて調整されます
• bytenode — 難読化後に bytenode ローダー（V8 のキャッシュされたバイトコード .jsc）でコンパイルされる Node.js コードです。難読化ツール自体は bytenode を呼び出しません。bytenode のコンパイルステップを通過できるよう構造化されたランタイムを持つ VM 難読化された JavaScript を出力するだけです。vmSelfDefending の防御はそれに応じて調整されます。最終的な .jsc を生成するには、難読化された出力に対してご自身で bytenode を実行してください

transformObjectKeys

Type: boolean Default: false

オブジェクトのキーの変換を有効にします。

例:

// 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;
}());

warnings

Type: string | object Default: all

ObfuscationResult.getWarnings() メソッドを通じて出力される、致命的でない難読化の警告を制御します。

利用可能な値:

• 'all'（デフォルト） — すべての警告が出力されます。
• 'none' — すべての警告が抑制されます。
• 警告の種類をブール値にマッピングするオブジェクト — false にマッピングされた種類は抑制されます。存在しない（または true にマッピングされた）すべての種類は有効なままになります。たとえば、{ "VMGlobalFunctionNamesNotRenamed": false } は、その 1 つを除くすべての警告を維持します。

警告の種類:

• VMGlobalFunctionNamesNotRenamed — vmObfuscation の下で、トップレベルの関数宣言、クラス宣言、および関数／アロー／クラス式が代入された変数の名前がそのまま維持された場合です（renameGlobals オプションが無効で、コードが IIFE でラップされていない）。本体はバイトコードとして隠されますが、名前は出力に読み取り可能なまま残ります。エクスポートされた名前は報告されません。
• VMTopLevelInitializerNotVirtualized — vmWrapTopLevelInitializers が無効であるか、それらを仮想化できなかったため、トップレベルの変数初期化子が VM 難読化の下でプレーンな JavaScript のまま残った場合です。
• DynamicCodeRenameRisk — コードが実行時に文字列から関数を構築している場合です（直接 eval、Function コンストラクタ、または <script>／Worker に注入される fn.toString()）。難読化ツールがリネームした識別子を参照している可能性があります。
• VMDynamicCodeSkipped — 関数が直接 eval / 動的な new Function / Function を含んでいたため、VM バイトコード化からスキップされた場合です（vmForceCompileDynamicCode を参照）。
• VMSyncFunctionSkippedInAsyncMode — vmAsyncExecutor が有効な状態で、comment モードで明示的にマークした関数が同期関数であることが判明し、スキップされた場合です（そのモードでは非同期関数のみが仮想化されます）。
• VMAsyncGeneratorSkippedInAsyncMode — vmAsyncExecutor と非同期キーゲッターが有効な状態で、マークされた非同期ジェネレーターを仮想化できなかった場合です（イテレーターを同期的に返す必要があります）。
• BrowserTargetWithNodeStyleCode — target オプションがブラウザ系の環境に設定されているにもかかわらず、コードが Node.js を対象としているように見える場合です（require('fs')、__dirname、process.argv など）。

vmObfuscation

Type: boolean Default: false

VM ベースのバイトコード難読化を有効にします。有効にすると、JavaScript の関数が、組み込みの仮想マシン上で実行されるカスタムバイトコードにコンパイルされます。元のコードのロジックが完全に変換されるため、これは最高レベルの保護を提供します。

例: return qty * price のような読み取り可能なコードは、[0x15,0x03,0x17,...] のような数値のリストになり、組み込みの VM インタープリターだけがそれを実行できます。元のロジックは JavaScript として見えなくなります。

vmTargetFunctions

Type: string[] Default: []

どのルートレベルの関数に VM 保護を適用するかを名前で正確に指定します。

例:

{
    vmObfuscation: true,
    vmTargetFunctions: ['someFunctionName']
}

結果: これら 3 つの関数だけが VM で保護されます。それ以外はすべて通常の（ただし依然として難読化された）JavaScript のままになります。機密性の高いライセンスチェックや認証ロジックを保護しつつ、残りのコードを軽量に保つのに最適です。

vmExcludeFunctions

Type: string[] Default: []

VM 保護を適用しないルートレベルの関数を指定します。他の設定よりも優先されます。

例:

{
    vmObfuscation: true,
    vmExcludeFunctions: ['someFunctionName']
}

使いどころ: パフォーマンスが重要なルートレベルの関数（アニメーションループ、リアルタイムのデータ処理）は、VM のオーバーヘッドを避けるために除外しつつ、それ以外のすべてを保護できます。

vmTargetFunctionsMode

Type: string Default: root

どの関数／メソッドを VM 難読化の対象にするかを制御します。

例 - コメントモード:

// Source code
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();
}

// Obfuscator options
{
    vmObfuscation: true,
    vmTargetFunctionsMode: 'comment'
}

使いどころ: どの関数に VM 保護を適用するかを厳密に制御する必要がある場合、特に機密性の高いロジックを含むネストされた関数に有用です。ルートレベルの名前付き関数でのみ機能する vmTargetFunctions とは異なり、コメントモードではコード内の任意の場所にある任意の関数を保護できます。

vmForceCompileDynamicCode

Type: boolean Default: false

直接 eval、new Function(...)、または Function(...) の呼び出しを含む関数に対して、VM 難読化が何を行うかを制御します。

デフォルトでは、そのような関数（およびその内部で定義されたすべての関数）は VM バイトコード化からスキップされ、result.getWarnings() に VMDynamicCodeSkipped 警告が報告されます。これは、実行時に構築されるソースが、難読化ツールがリネームした周囲のスコープチェーンの識別子を参照する可能性があるためです。

true に設定すると、その関数はいずれにせよバイトコード化され、VMDynamicCodeSkipped 警告は出力されなくなります。

別の DynamicCodeRenameRisk 警告は、このオプションに関係なく引き続き発生します。それが説明するリネームのリスクは VM のスキップとは無関係であり、このオプションを有効にしても根底にあるパターンが安全になるわけではないためです。

// Source code
function loadConfig(src) {
    return eval(src);
}
loadConfig('1 + 2');

// Options
{
    vmObfuscation: true,
    vmForceCompileDynamicCode: true
}

オプションがオフ（デフォルト）の場合、loadConfig はプレーンな JavaScript のまま残ります。オプションがオンの場合、loadConfig は他の関数と同様に VM バイトコードにコンパイルされます。呼び出し箇所を精査し、実行時に構築されるコードがクロージャでリネームされた識別子に依存しないことがわかっている場合に使用してください。

vmWrapTopLevelInitializers

Type: boolean Default: false

一部のトップレベルの変数初期化子を IIFE（即時実行関数式）でラップし、VM 難読化できるようにします。

動作内容: このオプションがない場合、トップレベルの定数や変数は出力に表示されたまま残ります:

// Input
const MY_STRING = "my-string";

// Output (without vmWrapTopLevelInitializers)
const MY_STRING = "my-string";  // String is visible!

このオプションを有効にすると、初期化子は VM 難読化される IIFE でラップされます:

// Input
const MY_STRING = "my-string";

// Output (with vmWrapTopLevelInitializers: true)
const MY_STRING = (() => { return /* VM bytecode call */ })();  // String hidden in bytecode

注意: このオプションは vmTargetFunctionsMode が 'root'（デフォルト）の場合にのみ機能します。

警告: VM 難読化の下でトップレベルの初期化子がプレーンな JavaScript のまま残るたびに、影響を受ける変数名を列挙した VMTopLevelInitializerNotVirtualized 警告が報告されます。これには次が含まれます: このオプションが無効な場合、このオプションがスキップせざるを得なかった初期化子（それぞれ理由付き。たとえば初期化子が兄弟の宣言子を参照している、またはトップレベルの await を含む）、および同期ラッパーをまったく仮想化できない vmAsyncExecutor モードです。

vmDynamicOpcodes

Type: boolean Default: false

VM インタープリターをより小さく、ビルドごとに一意にします。

動作内容:

1. 未使用の命令をフィルタリング - コードがクラスを使用していない場合、クラス関連の命令は完全に削除されます
2. 構造をランダム化 - 命令ハンドラーの順序がビルドごとにシャッフルされます

その結果、出力がより小さくなり、各ビルドが異なって見えるようになります。

vmBytecodeEncoding

Type: boolean Default: false

各バイトコード命令をエンコードします。命令は実行中に 1 つずつデコードされます。

vmBytecodeArrayEncoding

Type: boolean Default: false

バイトコード配列全体を単一のブロックとしてエンコードします。配列は実行が始まる前に起動時に一度デコードされます。2 層の保護のために vmBytecodeEncoding と併用してください。

vmBytecodeArrayEncodingKey

Type: string Default: ''

バイトコード配列のエンコード用のカスタム暗号化キーです。設定すると、環境から導出されるデフォルトのキーの代わりにこのキーが使用されます。キーは実行時に vmBytecodeArrayEncodingKeyGetter を通じて提供される必要があります。

このオプションは暗号化キーを外部化します。キーは難読化されたコード自体に埋め込まれません。キーは実行時には依然としてアクセス可能である（したがって真に秘密ではない）ものの、この分離によって、静的解析ツールがコードだけを調べてキーを見つけることを防げます。

重要: キーは、難読化されたコードが読み込まれる際に同期的に利用可能である必要があります。Cookie、localStorage、sessionStorage、グローバル変数、DOM 要素（サーバーが注入する meta タグなど）といった同期ストレージを使用してください。fetch() のような非同期メソッドは、キーゲッターの式で直接使用することはできません。

vmBytecodeArrayEncodingKeyGetter

Type: string Default: ''

実行時に暗号化キーを返す、同期的な JavaScript の式です。この式は難読化されたコードが読み込まれる際に評価され、vmBytecodeArrayEncodingKey で提供されたのと同じキーを返す必要があります。キーを非同期的に（Promise として）解決するには、vmAsyncExecutor を有効にしてください。

難読化されたコードは、キーゲッターが難読化時に使用されたのとまったく同じキーを返した場合にのみ動作します。 キーが一致しない場合、復号が失敗し、コードはゴミデータやエラーを生成します。キーゲッターが undefined、null、または空文字列を返した場合、コードは「VM decryption key not available」というエラーをスローします。

重要: キーは、難読化されたコードと同じファイル／スクリプトの外に置いてください。そこにインライン化すると、バンドルを純粋に静的にスキャンするだけでキーを復元できてしまいます。代わりに別のソースに格納してください: サーバーが設定する Cookie、別のスクリプトが投入する localStorage、サーバーが注入する HTML meta タグ、別のスクリプトが設定するグローバル変数、または（vmAsyncExecutor を使って）実行時にバックエンドから取得する方法です。

キーをバックエンドから（vmAsyncExecutor 経由で）取得する場合は、そのエンドポイントにセッションベースまたはオリジンベースのチェックを追加してください: 実際のユーザー（有効なセッション、想定される Origin／Referer）には正しいキーを返し、不審なリクエスト（localhost／想定外のオリジン、セッションなしなど）にはゴミのキーを返します。実際のユーザーは通常どおり実行され、環境外で動作するコピーは何も復号できないキーを受け取ります。厳密なロジックはサイトによって異なります。

例:

// 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"

// From backend, async (requires vmAsyncExecutor)
vmBytecodeArrayEncodingKeyGetter: 'fetch("/vm-key").then((res) => res.text())'

使用例:

// Build time
JavaScriptObfuscator.obfuscate(code, {
    vmObfuscation: true,
    vmBytecodeArrayEncoding: true,
    vmBytecodeArrayEncodingKey: 'mySecretKey123',
    vmBytecodeArrayEncodingKeyGetter: 'window.__VM_KEY__'
});

// Runtime - key must be set before obfuscated code runs
window.__VM_KEY__ = 'mySecretKey123';

vmAsyncExecutor

Type: boolean Default: false

非同期 VM エグゼキュータを有効にします。これにより、vmBytecodeArrayEncodingKeyGetter が Promise（非同期キーゲッター）を返せるようになります。その結果、復号キーをコード読み込み時に同期的に利用可能にする必要がなく、実行時に（ネットワークリクエスト、IndexedDB などから）取得できるようになります。

完全に非同期のコードベースには強く推奨されます。 このモードでは async 関数のみが仮想化されます。同期関数は、戻り値を Promise に変えて呼び出し側を壊さない限り非同期にできないためです。したがって、全体が async であるコードが最も高い保護範囲を得られます。ルートが同期の場合（同期 IIFE / UMD ラッパーなど）でも機能します: 内部の最も外側の async 関数が保護され、同期部分はそのまま残ります。

変換される対象: どこに現れるかを問わず（同期ラッパー内にネストされている場合も含めて）、最も外側の async 関数すべてです。各チェーンで最も外側の非同期関数が保護の単位となり、その内部にあるすべて（同期・非同期）がコンパイルされます。同期関数とプレーンなジェネレーターは難読化されずに残ります。

function foo() {              // sync — left as-is
    function bar() {}         // sync — left as-is

    async function baz() {    // transformed
        // any code here, including calls to other async or sync functions
    }

    async function bark() {   // transformed
        // any code here, including calls to other async or sync functions
    }
}

スキップと警告。 非同期キーゲッターが有効な場合、非同期ジェネレーターも難読化されずに残ります（非同期ジェネレーターはイテレーターを同期的に返す必要があり、キーを待つことができないためです）。デフォルトの vmTargetFunctionsMode: 'root' ではスキップは通知されません（選択は自動です）。comment モードでは、明示的にマークした関数を仮想化できないたびに（同期関数であることが判明した、または非同期キーゲッターの下での非同期ジェネレーターであった）、ObfuscationResult.getWarnings() を通じて警告が出力されます。

非同期キーゲッターにはさらに、vmBytecodeArrayEncodingKeyGetter を伴う vmBytecodeArrayEncoding が必要です。

使用例:

JavaScriptObfuscator.obfuscate(code, {
    vmObfuscation: true,
    vmAsyncExecutor: true,
    vmBytecodeArrayEncoding: true,
    vmBytecodeArrayEncodingKey: 'mySecretKey123',
    // the key getter may now return a Promise
    vmBytecodeArrayEncodingKeyGetter: 'fetch("/vm-key").then((res) => res.text())'
});

vmJumpsEncoding

Type: boolean Default: false

バイトコード内のジャンプ先をエンコードします。ジャンプのオフセットは実行時に計算されるため、制御フロー構造（if／else、ループなど）を静的解析から隠します。

vmMacroOps

Type: boolean Default: false

よくある命令のシーケンスを単一の「マクロ」オペコードに結合します。たとえば、LOAD + ADD + STORE が単一の MACRO_ADD_TO_VAR 命令になることがあります。これによりパターン認識を妨げ、パフォーマンスを向上させることができます。

vmDebugProtection

Type: boolean Default: false

VM ランタイムに、多層的なデバッグ対策、解析対策、LLM 対策の防御を追加します。browser／browser-no-eval ターゲットで最も効果を発揮します。

vmSelfDefending

Type: boolean Default: false

VM ランタイムに、多層的な改ざん検知、フック対策、リバースエンジニアリング対策の保護を追加します。

最大限の保護のために、vmDebugProtection、vmBytecodeArrayEncodingKey、vmBytecodeArrayEncodingKeyGetter と併用することを強くお勧めします。

vmDefenseHook

Type: { name: string, aliases?: object } Default: ''

vmDefenseHook は、2 つのキー name（必須）と aliases（任意）を持つオブジェクトを受け取ります。

name は、ホストページが定義するグローバル関数であり、VM の防御（vmDebugProtection / vmSelfDefending）が敵対的なシグナル（デバッガーやインスペクター、ヘッドレス／自動化ブラウザ、AI コーディングエージェントのプロセス、許可されていないドメインなど）を検知したときに、シグナルオブジェクトを引数として呼び出します。これを使って、イベントをバックエンドに報告できます（navigator.sendBeacon など）。このフックは純粋なテレメトリのシンクです: その戻り値は無視され、フックが存在しない場合やスローした場合も何もしない静かな no-op となり、防御を無効化することは決してありません。検知時に防御が何をするかを変更するには、vmDefenseReaction を使用してください。

aliases は、そのシグナルオブジェクトのフィールドを任意で改名します。後述のシグナルフィールドの改名で説明します。

シグナルオブジェクト。 フックは単一の signal を受け取ります:

• source — 発火した具体的な検知器です（表を参照）。
• category — それが報告するグループです: automation（人間ではないブラウザ）、debugger（デバッガー／インスペクターがアクティブ）、sandbox（計装された／偽のホスト）、domain（ドメインロック違反）、tamper（実行時に組み込みがパッチされた）、integrity（VM 自身のコードが改変された）。
• score / threshold — 検知器がどれだけ強く発火したか、および到達しなければならない値です。フックは score >= threshold になって初めて発火します。ほとんどのチェックはオール・オア・ナッシング（単一の決定的なシグナル）ですが、headless は複数のブラウザ形状のシグナルを合算するため、その score は通常 threshold より高くなります。

フックの登録。 難読化されたバンドルが読み込まれる前に、プレーンなグローバルとして定義してください。VM ランタイムとその防御は（保護された）あなたのプログラムよりも前に実行され、多くの検知が起動時に発火するためです:

// in your page, before the obfuscated script:
window.__vmDetection = function (signal) { navigator.sendBeacon('/vm-defense', JSON.stringify(signal)); };

// obfuscation option:
vmDefenseHook: { name: '__vmDetection' }

シグナルフィールドの改名（aliases）。 デフォルトの source／category の値は説明的な名前なので、コールバックを計装する（または出力を読む）者は誰でも、保護の存在とどの検知器が発火したかを認識できてしまいます。aliases はシグナルフィールドを任意の不透明なトークンに改名します。これはシグナルが発行される前に VM 内部で適用されるため、それらの名前が出力に現れることも、コールバックに届くこともありません。あなたのアプリは自身のマッピングを把握しており、そのトークンをバックエンドに転送します。

エイリアスはフィールドごとに指定し、キーの改名と値の改名を分けて扱います: 各フィールドは key（コールバックが受け取るプロパティ名）を取ります。文字列の名前フィールドである source と category は values マップも取りますが、score／threshold は数値であり key のみを取ります。マッピングできる名前（それ以外はビルド時に拒否されます）:

• フィールドキー — source、category、score、threshold
• source の値 — headless、agent、node、debugger、timing、sandbox、domain、nativeHook、integrity
• category の値 — automation、debugger、sandbox、domain、tamper、integrity

vmDefenseHook: {
    name: '__vmDetection',
    aliases: {
        source:    { key: 'a8Qm', values: { headless: 'xP4m9Q' } },
        category:  { key: 'p3Tx', values: { automation: 'bQ7s1M' } },
        score:     { key: 's1' },
        threshold: { key: 't1' }
    }
    // the callback now receives e.g. { a8Qm: 'xP4m9Q', p3Tx: 'bQ7s1M', s1: <score>, t1: <threshold> }
}

これは秘匿ではなくフィンガープリントの回避です。マッピングは繰り返しテストすることで依然として推測できます。したがって、その唯一の利点は、安定した自明な名前を露出しないことにあります。設定されていないエントリはデフォルトの名前を保持します。

vmDefenseReaction

Type: object Default: { automation: 'break', debugger: 'decoy', sandbox: 'decoy', domain: 'break', tamper: 'break', integrity: 'break' }

各検知カテゴリがどのように反応するかを設定します。これは何かを有効化するものではありません — 防御そのものは vmSelfDefending、vmDebugProtection、vmDomainLock によって有効化されます。このオプションは、有効化された防御がどのように反応するかを選択するだけです。カテゴリが制御の単位であり、カテゴリ内のすべての検知器がそのカテゴリの反応を実行します。

各カテゴリは、ある種類の敵対的な状態を監視する検知器をグループ化します。カテゴリは、その検知器を発行するオプションが有効な場合にのみ反応します:

各カテゴリは vmSelfDefending、vmDebugProtection、vmDomainLock の 1 つ以上に対応します。これら 3 つのオプションの外にカテゴリは存在せず、オプションがオフのカテゴリに設定された反応は単に効果を持ちません。

キーはこれら 6 つのカテゴリ名、または default（指定されなかったカテゴリのフォールバック）です。値は次のとおりです:

• break — 即座に中断します
• decoy — 汚染された状態で実行を続け、静かに誤った結果を生成します
• none — ローカルでは何もしません（テレメトリのみ）

カテゴリごとのデフォルトは上に示したとおりです。設定しない（またはデフォルト値に設定した）カテゴリは、そのデフォルトを使用します。default は、正しさが構造上保証されているカテゴリ（integrity、tamper）を含むすべてのカテゴリに及ぶため、{ default: 'none' } は本当に何も中断しない、テレメトリのみのビルドになります:

vmDefenseReaction: { default: 'none' }              // never break — pair with vmDefenseHook
vmDefenseReaction: { automation: 'none', domain: 'break' }   // tolerate automation FPs, still break on a bad domain

vmStatefulOpcodes

Type: boolean Default: false

オペコードの意味をバイトコード内の位置に依存させます。各位置はシードから導出される異なるオペコードとハンドラーのマッピングを持つため、同じオペコード番号でも位置が異なれば異なる操作を実行します。

vmCallContextOpcodes

Type: boolean Default: false

保護された関数を、それがどこから呼び出されるかに依存させます。これにより、コードから切り出して単独で実行したり解析したりできなくなり、プログラム内の実際の呼び出し箇所を通じて呼び出された場合にのみ正しく動作します。このオプションは実行時のパフォーマンスに影響します。

現在サポートされているのは次の構文のみです:

• 関数宣言（function f() {}）;
• 変数に代入された関数式およびアロー関数（const f = () => {}）;
• インスタンスのプライベートメソッド（this.#m()）。

いずれの場合も、関数は常に直接呼び出し（f()、this.#m()）を通じて到達する必要があります。別の変数に格納されたり、引数として渡されたり、その他の方法で値として使用されたりすると、保護されません。非同期関数はサポートされますが、ジェネレーターはサポートされません。

このオプションは実験的であり、コードを壊す可能性があるため、使用する前に出力を十分にテストしてください。

vmStackEncoding

Type: boolean Default: false

実行中に VM スタック上の値を暗号化します。値はプッシュ時にエンコードされ、ポップ時にデコードされるため、メモリを調査しても実際の値ではなく暗号化されたデータが表示されます。

このオプションはパフォーマンスに大きく影響します。

vmCompactDispatcher

Type: boolean Default: false

デュアルエグゼキュータ（同期 + ジェネレーター）の代わりに単一の VM エグゼキュータを使用します。難読化されたコードのサイズを削減しますが、再帰の多いコードでは約 20% のパフォーマンスのオーバーヘッドが加わります。

• false（デフォルト）: デュアルエグゼキュータ — 最適なパフォーマンス、より大きな出力
• true: 単一エグゼキュータ — より小さな出力、わずかに遅い

vmStringArrayBytecodeOnly

Type: boolean Default: false

有効にすると、文字列配列はバイトコードデータからのみ文字列を抽出し、コード内の他の文字列は変換されません。これは、明示的に設定されていなくても stringArray を強制的に有効にします。

使いどころ: すべての VM ランタイム文字列を文字列配列に抽出するのは低速です。このオプションは文字列配列への抽出をバイトコードの内容のみに限定し、バイトコード定数を保護しつつパフォーマンスを向上させます。

• vmBytecodeArrayEncoding: false の場合 — バイトコードの定数プール（c 配列）内の文字列が抽出されます
• vmBytecodeArrayEncoding: true の場合 — トップレベルの base64 エンコードされたバイトコード文字列が抽出されます
• stringArrayThreshold は、それらのバイトコード文字列のうちどの割合を抽出するかを引き続き制御します

vmDomainLock

Type: string[] Default: []

⚠️ このオプションは target: 'node'、target: 'service-worker'、target: 'bytenode' では機能しません

難読化されたコードを特定のドメインやサブドメインに限定します。domainLock よりも発見して取り除くことがはるかに困難です。

ソースコードがこのオプションで指定されたドメイン上で実行されていない場合、ブラウザは vmDomainLockRedirectUrl に渡された URL にリダイレクトされ、リダイレクトが抑制された場合でも、以降の保護された呼び出しは不正な結果を返します。

複数のドメインとサブドメイン

コードを複数のドメインやサブドメインにロックすることも可能です。たとえば、コードが www.example.com でのみ実行されるようにロックするには、www.example.com を追加します。ルートドメインおよびすべてのサブドメイン（example.com、sub.example.com）で機能させるには、.example.com を使用します。

vmDomainLockRedirectUrl

Type: string Default: about:blank

⚠️ このオプションは target: 'node'、target: 'service-worker'、target: 'bytenode' では機能しません

ソースコードが vmDomainLock で指定されたドメイン上で実行されていない場合に、ブラウザを指定した URL にリダイレクトできるようにします。

プリセットオプション

高難読化・低パフォーマンス

パフォーマンスは難読化なしの場合よりも大幅に低下します。

{
    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,
    strictMode: null,
    stringArray: true,
    stringArrayCallsTransform: true,
    stringArrayEncoding: ['rc4'],
    stringArrayIndexShift: true,
    stringArrayRotate: true,
    stringArrayShuffle: true,
    stringArrayWrappersCount: 5,
    stringArrayWrappersChainedCalls: true,    
    stringArrayWrappersParametersMaxCount: 5,
    stringArrayWrappersType: 'function',
    stringArrayThreshold: 1,
    transformObjectKeys: true
}

中難読化・最適なパフォーマンス

パフォーマンスは難読化なしの場合よりも低下します。

{
    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,
    strictMode: null,
    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
}

低難読化・高パフォーマンス

パフォーマンスは比較的通常のレベルに保たれます。

{
    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,
    strictMode: null,
    stringArray: true,
    stringArrayCallsTransform: false,
    stringArrayEncoding: [],
    stringArrayIndexShift: true,
    stringArrayRotate: true,
    stringArrayShuffle: true,
    stringArrayWrappersCount: 1,
    stringArrayWrappersChainedCalls: true,
    stringArrayWrappersParametersMaxCount: 2,
    stringArrayWrappersType: 'variable',
    stringArrayThreshold: 0.75
}

デフォルトプリセット・高パフォーマンス

{
    compact: true,
    controlFlowFlattening: false,
    deadCodeInjection: false,
    debugProtection: false,
    debugProtectionInterval: 0,
    disableConsoleOutput: false,
    identifierNamesGenerator: 'hexadecimal',
    log: false,
    numbersToExpressions: false,
    renameGlobals: false,
    selfDefending: false,
    simplify: true,
    splitStrings: false,
    strictMode: null,
    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
}

VM 超高難読化（最大限のセキュリティ）

このプリセットは、間接ディスパッチを含むすべての堅牢化機能を備えた VM ベースのバイトコード難読化を有効にします。最も強力な保護を提供しますが、出力サイズが大きくなり、実行速度が大幅に遅くなります。

{
    optionsPreset: 'vm-ultra-high-obfuscation'
}

または個別に設定します:

{
    compact: true,
    simplify: true,
    identifierNamesGenerator: 'mangled-shuffled',
    vmObfuscation: true,
    vmForceCompileDynamicCode: false,

    vmWrapTopLevelInitializers: true,
    vmDynamicOpcodes: true,

    vmBytecodeEncoding: true,
    vmBytecodeArrayEncoding: true,
    vmBytecodeArrayEncodingKey: '',
    vmBytecodeArrayEncodingKeyGetter: '',
    vmAsyncExecutor: false,
    vmJumpsEncoding: true,
    vmMacroOps: true,
    vmDebugProtection: true,
    vmSelfDefending: true,
    vmDefenseHook: '',
    vmDefenseReaction: {
        automation: 'break',
        debugger: 'decoy',
        sandbox: 'decoy',
        domain: 'break',
        tamper: 'break',
        integrity: 'break'
    },
    vmStatefulOpcodes: true,
    vmCallContextOpcodes: false,
    vmStackEncoding: true,
    vmCompactDispatcher: true,
    controlFlowFlattening: true,
    controlFlowFlatteningThreshold: 0.5,
    deadCodeInjection: true,
    deadCodeInjectionThreshold: 0.5,
    debugProtection: true,
    debugProtectionInterval: 4000,
    disableConsoleOutput: true,
    identifierNamesGenerator: 'hexadecimal',
    log: false,
    numbersToExpressions: true,
    renameGlobals: false,
    selfDefending: true,
    simplify: true,
    splitStrings: true,
    splitStringsChunkLength: 5,
    strictMode: null,
    stringArray: true,
    stringArrayCallsTransform: true,
    stringArrayEncoding: ['rc4'],
    stringArrayIndexShift: true,
    stringArrayRotate: true,
    stringArrayShuffle: true,
    stringArrayWrappersCount: 5,
    stringArrayWrappersChainedCalls: true,
    stringArrayWrappersParametersMaxCount: 5,
    stringArrayWrappersType: 'function',
    stringArrayThreshold: 0.5,
    transformObjectKeys: true
}

VM Anti-LLM（AI エージェント対策）

このプリセットは、AI エージェントや LLM が VM バイトコード化されたコードをリバースエンジニアリングするのを防ぐために特別に設計されています。vm-default をベースに、セルフディフェンディングとデバッグ保護を有効にしています。vm-high-obfuscation よりも軽量ですが、自動解析に対して特別に堅牢化されています。

{
    optionsPreset: 'vm-anti-llm'
}

含まれるもの:

• 文字列配列を伴う VM バイトコード難読化（vm-default から）
• vmSelfDefending — フック対策の検知、整合性ハッシュ、ソースフィンガープリント、iframe によるクリーンレルムの検証、ARX 暗号によるキー導出
• vmDebugProtection — VM ディスパッチループ内のデバッグ対策チェック
• debugProtection: false — レガシーなデバッグ保護なし（VM のデバッグ保護の方が優れています）

VM 高難読化（最高のセキュリティ）

このプリセットは、ほとんどの堅牢化機能を備えた VM ベースのバイトコード難読化を有効にします。超高プリセットよりも優れたパフォーマンスで強力な保護を提供します。

{
    optionsPreset: 'vm-high-obfuscation'
}

または個別に設定します:

{
    compact: true,
    simplify: true,
    identifierNamesGenerator: 'mangled-shuffled',
    vmObfuscation: true,
    vmForceCompileDynamicCode: false,
    vmWrapTopLevelInitializers: true,
    vmDynamicOpcodes: true,
    vmBytecodeEncoding: true,
    vmBytecodeArrayEncoding: true,
    vmBytecodeArrayEncodingKey: '',
    vmBytecodeArrayEncodingKeyGetter: '',
    vmAsyncExecutor: false,
    vmJumpsEncoding: true,
    vmMacroOps: true,
    vmDebugProtection: true,
    vmSelfDefending: true,
    vmDefenseHook: '',
    vmDefenseReaction: {
        automation: 'break',
        debugger: 'decoy',
        sandbox: 'decoy',
        domain: 'break',
        tamper: 'break',
        integrity: 'break'
    },
    vmStatefulOpcodes: true,
    vmCallContextOpcodes: false,
    vmStackEncoding: true,
    vmCompactDispatcher: false
}

VM 中難読化（バランスの取れたセキュリティ）

このプリセットは、バランスの取れた堅牢化機能のセットを備えた VM ベースのバイトコード難読化を有効にします。セキュリティとパフォーマンスの適切な折り合いです。

{
    optionsPreset: 'vm-medium-obfuscation'
}

または個別に設定します:

{
    compact: true,
    simplify: true,
    identifierNamesGenerator: 'mangled-shuffled',
    vmObfuscation: true,
    vmForceCompileDynamicCode: false,
    vmWrapTopLevelInitializers: true,
    vmDynamicOpcodes: true,
    vmBytecodeEncoding: true,
    vmBytecodeArrayEncoding: false,
    vmBytecodeArrayEncodingKey: '',
    vmBytecodeArrayEncodingKeyGetter: '',
    vmAsyncExecutor: false,
    vmJumpsEncoding: true,
    vmMacroOps: true,
    vmDebugProtection: true,
    vmSelfDefending: false,
    vmDefenseHook: '',
    vmDefenseReaction: {
        automation: 'break',
        debugger: 'decoy',
        sandbox: 'decoy',
        domain: 'break',
        tamper: 'break',
        integrity: 'break'
    },
    vmStatefulOpcodes: false,
    vmCallContextOpcodes: false,
    vmStackEncoding: false,
    vmCompactDispatcher: false
}

VM 低難読化（基本的なセキュリティ、より良いパフォーマンス）

このプリセットは、追加の堅牢化機能なしで基本的な VM ベースのバイトコード難読化を有効にします。セキュリティと出力サイズの適切なバランスです。

{
    optionsPreset: 'vm-low-obfuscation'
}

または個別に設定します:

{
    compact: true,
    simplify: true,
    identifierNamesGenerator: 'mangled-shuffled',
    vmObfuscation: true,
    vmForceCompileDynamicCode: false,
    vmWrapTopLevelInitializers: true,
    vmDynamicOpcodes: false,
    vmBytecodeEncoding: false,
    vmBytecodeArrayEncoding: false,
    vmBytecodeArrayEncodingKey: '',
    vmBytecodeArrayEncodingKeyGetter: '',
    vmAsyncExecutor: false,
    vmJumpsEncoding: false,
    vmMacroOps: false,
    vmDebugProtection: false,
    vmSelfDefending: false,
    vmDefenseHook: '',
    vmDefenseReaction: {
        automation: 'break',
        debugger: 'decoy',
        sandbox: 'decoy',
        domain: 'break',
        tamper: 'break',
        integrity: 'break'
    },
    vmStatefulOpcodes: false,
    vmCallContextOpcodes: false,
    vmStackEncoding: false,
    vmCompactDispatcher: false
}

VM デフォルト（VM + 文字列配列保護）

このプリセットは、基本的な VM ベースのバイトコード難読化と文字列配列保護を組み合わせます。文字列保護を伴う VM 難読化の良い出発点です。

{
    optionsPreset: 'vm-default'
}

または個別に設定します:

{
    compact: true,
    simplify: true,
    identifierNamesGenerator: 'mangled-shuffled',
    vmObfuscation: true,
    vmForceCompileDynamicCode: false,
    vmWrapTopLevelInitializers: true,
    vmDynamicOpcodes: true,
    vmBytecodeEncoding: false,
    vmBytecodeArrayEncoding: true,
    vmStringArrayBytecodeOnly: true,
    vmAsyncExecutor: false,
    vmJumpsEncoding: false,
    vmMacroOps: false,
    vmDebugProtection: false,
    vmSelfDefending: false,
    vmDefenseHook: '',
    vmDefenseReaction: {
        automation: 'break',
        debugger: 'decoy',
        sandbox: 'decoy',
        domain: 'break',
        tamper: 'break',
        integrity: 'break'
    },
    vmStatefulOpcodes: false,
    vmCallContextOpcodes: false,
    vmStackEncoding: false,
    vmCompactDispatcher: false,
    stringArray: true,
    stringArrayRotate: true,
    stringArrayShuffle: true,
    stringArrayThreshold: 1,
    stringArrayIndexShift: true,
    stringArrayIndexesType: ['hexadecimal-number'],
    stringArrayCallsTransform: true,
    stringArrayCallsTransformThreshold: 1,
    stringArrayWrappersCount: 3,
    stringArrayWrappersType: 'function',
    stringArrayWrappersParametersMaxCount: 5,
    stringArrayWrappersChainedCalls: true,
    stringArrayEncoding: ['base64'],
    splitStrings: true,
    splitStringsChunkLength: 6
}