diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml new file mode 100644 index 0000000..8b5df37 --- /dev/null +++ b/.github/workflows/fuzz.yml @@ -0,0 +1,36 @@ +name: Fuzz Testing + +on: + push: + branches: [develop] + +jobs: + fuzz: + runs-on: ubuntu-latest + timeout-minutes: 5 + strategy: + fail-fast: false + matrix: + target: + - fuzz_deobfuscate + - fuzz_parser + - fuzz_generator + - fuzz_transforms + - fuzz_expression_simplifier + - fuzz_string_decoders + - fuzz_scope + - fuzz_traverser + steps: + - uses: actions/checkout@v4 + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install project + run: | + python -m pip install --upgrade pip + pip install -e . + - name: Run fuzz target (${{ matrix.target }}) + run: | + chmod +x tests/fuzz/run_local.sh + tests/fuzz/run_local.sh ${{ matrix.target }} 60 diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..13ea7d9 --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,28 @@ +name: Publish to PyPI + +on: + release: + types: [published] + +permissions: + contents: read + +jobs: + publish: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install build dependencies + run: | + python -m pip install --upgrade pip + pip install build + - name: Build package + run: python -m build + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + password: ${{ secrets.PYPI_TOKEN }} diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 99b9ac8..0d6e378 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -2,9 +2,9 @@ name: Tests on: push: - branches: [main] + branches: [main, develop] pull_request: - branches: [main] + branches: [main, develop] jobs: test: diff --git a/CLAUDE.md b/CLAUDE.md index da38b44..ecbed81 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -75,6 +75,30 @@ pytest tests/test_regression.py # end-to-end regression (47k files) Test helpers in `conftest.py`: `roundtrip(code, TransformClass)`, `parse_expr(expr)`, `normalize(code)`. +### Fuzz Testing + +8 fuzz targets in `tests/fuzz/` covering the full pipeline, parser, generator, transforms, expression simplifier, string decoders, scope analysis, and AST traversal. OSS-Fuzz compatible (atheris/libFuzzer). + +```bash +# Run all targets for 10s each (standalone, no extra deps) +tests/fuzz/run_local.sh all 10 + +# Run a single target for 60s +tests/fuzz/run_local.sh fuzz_deobfuscate 60 + +# With atheris (requires clang + libFuzzer): +CLANG_BIN=$(which clang) pip install atheris +tests/fuzz/run_local.sh fuzz_deobfuscate 300 +``` + +Fuzz helpers in `tests/fuzz/conftest_fuzz.py`: `bytes_to_js(data)`, `bytes_to_ast_dict(data)`, `run_fuzzer(target_fn)`. Targets use atheris when available, otherwise a standalone random-based fuzzer. + +## CI/CD + +- **Tests**: `.github/workflows/tests.yml` — pytest on push/PR to `main` (Python 3.11–3.13) +- **Fuzz**: `.github/workflows/fuzz.yml` — 8 fuzz targets on push/PR to `develop` (60s each, standalone fuzzer) +- **Publish**: `.github/workflows/publish.yml` — build + publish to PyPI on GitHub Release (requires `PYPI_TOKEN` secret) + ## Safety Guarantees - Never crashes on valid JS (parse failure → fallback hex decode → return original) diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..2575b1a --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,5 @@ +recursive-include pyjsclear *.py +include LICENSE +include README.md +include NOTICE +include THIRD_PARTY_LICENSES.md diff --git a/NOTICE b/NOTICE index cc95a1b..afba401 100644 --- a/NOTICE +++ b/NOTICE @@ -13,13 +13,7 @@ This product is a derivative work based on the following projects: Licensed under the Apache License, Version 2.0 https://github.com/ben-sb/javascript-deobfuscator -3. esprima2 (v5.0.1) - Copyright JS Foundation and other contributors - Licensed under the BSD 2-Clause License - https://github.com/s0md3v/esprima2 - This Python library re-implements the deobfuscation algorithms and transform -logic from the above Node.js/Babel-based tools (1, 2) in pure Python. No -source code was directly copied; the implementations were written from scratch -following the same algorithmic approaches. esprima2 (3) is used as a runtime -dependency for JavaScript parsing. +logic from the above Node.js/Babel-based tools in pure Python. No source code +was directly copied; the implementations were written from scratch following +the same algorithmic approaches. diff --git a/README.md b/README.md index 28bf2a6..c95e08d 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@

- PyJSClear + PyJSClear

# PyJSClear @@ -14,11 +14,16 @@ into a single Python library with no Node.js dependency. ## Installation ```bash -pip install -r requirements.txt # install runtime dependencies -pip install -e . # install PyJSClear +pip install pyjsclear +``` + +For development: -# For development/testing -pip install -r test-requirements.txt +```bash +git clone https://github.com/intezer/PyJSClear.git +cd PyJSClear +pip install -e . +pip install pytest ``` ## Usage @@ -42,16 +47,16 @@ cleaned = deobfuscate_file("input.js") ```bash # File to stdout -python -m pyjsclear input.js +pyjsclear input.js # File to file -python -m pyjsclear input.js -o output.js +pyjsclear input.js -o output.js # Stdin to stdout -cat input.js | python -m pyjsclear - +cat input.js | pyjsclear - # With custom iteration limit -python -m pyjsclear input.js --max-iterations 20 +pyjsclear input.js --max-iterations 20 ``` ## What it does @@ -133,7 +138,5 @@ This project is a derivative work based on [obfuscator-io-deobfuscator](https://github.com/ben-sb/obfuscator-io-deobfuscator) (Apache 2.0) and [javascript-deobfuscator](https://github.com/ben-sb/javascript-deobfuscator) -(Apache 2.0), and uses [esprima2](https://github.com/s0md3v/esprima2) -(BSD 2-Clause) for JavaScript parsing. -See [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md) and +(Apache 2.0). See [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md) and [NOTICE](NOTICE) for full attribution. diff --git a/THIRD_PARTY_LICENSES.md b/THIRD_PARTY_LICENSES.md index 0ba42cd..a4ad293 100644 --- a/THIRD_PARTY_LICENSES.md +++ b/THIRD_PARTY_LICENSES.md @@ -237,37 +237,3 @@ https://github.com/ben-sb/javascript-deobfuscator/blob/master/LICENSE). **Features derived from this project:** hex escape decoding (`--he`), static array unpacking (`--su`), property access transformation (`--tp`). ---- - -## esprima2 - -- **Version:** 5.0.1 -- **Author:** Somdev Sangwan (s0md3v) -- **Repository:** https://github.com/s0md3v/esprima2 -- **License:** BSD 2-Clause License - -``` -Copyright JS Foundation and other contributors, https://js.foundation/ - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY -DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF -THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -``` - -**Usage:** Runtime dependency — JavaScript parser providing ESTree-compatible AST with ES2024 support. diff --git a/pyjsclear/__init__.py b/pyjsclear/__init__.py index 555dba5..b3ceb84 100644 --- a/pyjsclear/__init__.py +++ b/pyjsclear/__init__.py @@ -8,7 +8,7 @@ from .deobfuscator import Deobfuscator -__version__ = '0.1.0' +__version__ = '0.1.1' def deobfuscate(code, max_iterations=50): diff --git a/pyjsclear/transforms/string_revealer.py b/pyjsclear/transforms/string_revealer.py index 8def8f1..fb82a39 100644 --- a/pyjsclear/transforms/string_revealer.py +++ b/pyjsclear/transforms/string_revealer.py @@ -261,8 +261,14 @@ def _process_obfuscatorio_pattern(self): # Step 5: Find and execute rotation rotation_result = self._find_and_execute_rotation( - body, array_func_name, string_array, primary_decoder, all_wrappers, - all_decoder_aliases, alias_decoder_map=alias_decoder_map, all_decoders=decoders, + body, + array_func_name, + string_array, + primary_decoder, + all_wrappers, + all_decoder_aliases, + alias_decoder_map=alias_decoder_map, + all_decoders=decoders, ) # Update the AST array to reflect rotation so future passes @@ -304,7 +310,6 @@ def _process_obfuscatorio_pattern(self): indices_to_remove.add(array_func_idx) self._remove_body_indices(body, *indices_to_remove) - def _find_string_array_function(self, body): """Find the string array function declaration. @@ -631,8 +636,14 @@ def _find_and_execute_rotation( if expr.get('type') == 'CallExpression': if self._try_execute_rotation_call( - expr, array_func_name, string_array, decoder, wrappers, decoder_aliases, - alias_decoder_map=alias_decoder_map, all_decoders=all_decoders, + expr, + array_func_name, + string_array, + decoder, + wrappers, + decoder_aliases, + alias_decoder_map=alias_decoder_map, + all_decoders=all_decoders, ): return (i, None) @@ -641,16 +652,29 @@ def _find_and_execute_rotation( if sub.get('type') != 'CallExpression': continue if self._try_execute_rotation_call( - sub, array_func_name, string_array, decoder, wrappers, decoder_aliases, - alias_decoder_map=alias_decoder_map, all_decoders=all_decoders, + sub, + array_func_name, + string_array, + decoder, + wrappers, + decoder_aliases, + alias_decoder_map=alias_decoder_map, + all_decoders=all_decoders, ): return (i, sub) return None def _try_execute_rotation_call( - self, call_expr, array_func_name, string_array, decoder, wrappers, decoder_aliases, - alias_decoder_map=None, all_decoders=None, + self, + call_expr, + array_func_name, + string_array, + decoder, + wrappers, + decoder_aliases, + alias_decoder_map=None, + all_decoders=None, ): """Try to parse and execute a single rotation call expression. Returns True on success.""" callee = call_expr.get('callee') @@ -680,7 +704,11 @@ def _try_execute_rotation_call( return False self._execute_rotation( - string_array, operation, wrappers, decoder, stop_value, + string_array, + operation, + wrappers, + decoder, + stop_value, alias_decoder_map=alias_decoder_map, ) return True @@ -1125,10 +1153,7 @@ def _find_simple_rotation(self, body, array_name): if expr.get('type') == 'CallExpression': candidates.append(expr) elif expr.get('type') == 'SequenceExpression': - candidates.extend( - sub for sub in expr.get('expressions', []) - if sub.get('type') == 'CallExpression' - ) + candidates.extend(sub for sub in expr.get('expressions', []) if sub.get('type') == 'CallExpression') for call_expr in candidates: callee = call_expr.get('callee') diff --git a/pyjsclear/utils/string_decoders.py b/pyjsclear/utils/string_decoders.py index cd49ace..cb2b7fa 100644 --- a/pyjsclear/utils/string_decoders.py +++ b/pyjsclear/utils/string_decoders.py @@ -106,7 +106,7 @@ def type(self): return DecoderType.RC4 def get_string(self, index, key=None): - if key is None: + if not key: return None # Include key in cache to avoid collisions with different RC4 keys cache_key = (index, key) diff --git a/pyproject.toml b/pyproject.toml index 92c3c81..5c32333 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,16 +4,42 @@ build-backend = "setuptools.build_meta" [project] name = "pyjsclear" -version = "0.1.0" +dynamic = ["version"] description = "Pure Python JavaScript deobfuscator" readme = "README.md" license = "Apache-2.0" requires-python = ">=3.11" dependencies = ["esprima2>=5.0.1"] +keywords = ["javascript", "deobfuscator", "deobfuscation", "security", "malware-analysis", "ast"] +authors = [ + {name = "Intezer Labs", email = "info@intezer.com"}, +] +classifiers = [ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "Intended Audience :: Information Technology", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Topic :: Security", + "Topic :: Software Development :: Libraries :: Python Modules", + "Typing :: Typed", +] + +[project.urls] +Homepage = "https://github.com/intezer/PyJSClear" +Repository = "https://github.com/intezer/PyJSClear" +Issues = "https://github.com/intezer/PyJSClear/issues" [project.scripts] pyjsclear = "pyjsclear.__main__:main" +[tool.setuptools.packages.find] +include = ["pyjsclear*"] + +[tool.setuptools.dynamic] +version = {attr = "pyjsclear.__version__"} + [tool.black] line-length = 120 target-version = ['py311'] @@ -34,4 +60,4 @@ schema_pattern = """(?s)\ (build|ci|docs|feat|fix|perf|refactor|style|test|chore|revert|bump)\ (\\(\\S+\\))?!?:\ ( [^\\n\\r]+)\ -((\\n\\n.*)|(\\s*))?$""" \ No newline at end of file +((\\n\\n.*)|(\\s*))?$""" diff --git a/tests/fuzz/build.sh b/tests/fuzz/build.sh new file mode 100755 index 0000000..cb5d4c7 --- /dev/null +++ b/tests/fuzz/build.sh @@ -0,0 +1,38 @@ +#!/bin/bash -eu +# OSS-Fuzz build script for pyjsclear +# See https://google.github.io/oss-fuzz/getting-started/new-project-guide/python-lang/ + +# Install project and dependencies +pip3 install . +pip3 install atheris + +# Copy fuzz targets and helpers to $OUT +cp tests/fuzz/fuzz_*.py "$OUT/" +cp tests/fuzz/conftest_fuzz.py "$OUT/" + +# Build seed corpus zips +TARGETS=(deobfuscate parser generator transforms expression_simplifier string_decoders scope traverser) + +for target in "${TARGETS[@]}"; do + corpus_dir="tests/fuzz/seed_corpus" + + # Map target to its corpus directory + case "$target" in + deobfuscate|expression_simplifier|transforms) + src_dir="$corpus_dir/deobfuscate" + ;; + parser|generator|scope|traverser) + src_dir="$corpus_dir/parser" + ;; + string_decoders) + src_dir="$corpus_dir/string_decoders" + ;; + *) + src_dir="$corpus_dir/deobfuscate" + ;; + esac + + if [ -d "$src_dir" ] && [ "$(ls -A "$src_dir")" ]; then + zip -j "$OUT/fuzz_${target}_seed_corpus.zip" "$src_dir"/* + fi +done diff --git a/tests/fuzz/conftest_fuzz.py b/tests/fuzz/conftest_fuzz.py new file mode 100644 index 0000000..99553d7 --- /dev/null +++ b/tests/fuzz/conftest_fuzz.py @@ -0,0 +1,364 @@ +"""Shared helpers for fuzz targets.""" + +import os +import random +import struct +import sys + + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) + +MAX_INPUT_SIZE = 102_400 # 100KB cap + +SAFE_EXCEPTIONS = (RecursionError,) + +# ESTree node types for synthetic AST generation +_STATEMENT_TYPES = [ + "ExpressionStatement", + "VariableDeclaration", + "ReturnStatement", + "IfStatement", + "WhileStatement", + "ForStatement", + "BlockStatement", + "EmptyStatement", + "BreakStatement", + "ContinueStatement", + "ThrowStatement", +] + +_EXPRESSION_TYPES = [ + "Literal", + "Identifier", + "BinaryExpression", + "UnaryExpression", + "CallExpression", + "MemberExpression", + "AssignmentExpression", + "ConditionalExpression", + "ArrayExpression", + "ObjectExpression", + "FunctionExpression", + "ThisExpression", +] + +_BINARY_OPS = [ + "+", + "-", + "*", + "/", + "%", + "==", + "!=", + "===", + "!==", + "<", + ">", + "<=", + ">=", + "&&", + "||", + "&", + "|", + "^", + "<<", + ">>", + ">>>", +] +_UNARY_OPS = ["-", "+", "!", "~", "typeof", "void"] + + +def bytes_to_js(data): + """Decode bytes to a JS string with size limit.""" + text = data[:MAX_INPUT_SIZE].decode("utf-8", errors="replace") + return text + + +def bytes_to_ast_dict(data, max_depth=5, max_children=4): + """Build a synthetic ESTree AST dict from bytes for testing generator/traverser.""" + rng = random.Random(int.from_bytes(data[:8].ljust(8, b"\x00"), "little")) + pos = 8 + + def consume_byte(): + nonlocal pos + if pos < len(data): + val = data[pos] + pos += 1 + return val + return rng.randint(0, 255) + + def make_literal(): + kind = consume_byte() % 4 + if kind == 0: + return {"type": "Literal", "value": consume_byte(), "raw": str(consume_byte())} + elif kind == 1: + return {"type": "Literal", "value": True, "raw": "true"} + elif kind == 2: + return {"type": "Literal", "value": None, "raw": "null"} + else: + return {"type": "Literal", "value": "fuzz", "raw": '"fuzz"'} + + def make_identifier(): + names = ["a", "b", "c", "x", "y", "foo", "bar", "_", "$"] + return {"type": "Identifier", "name": names[consume_byte() % len(names)]} + + def make_node(depth=0): + if depth >= max_depth: + return make_literal() if consume_byte() % 2 == 0 else make_identifier() + + type_idx = consume_byte() + if type_idx % 3 == 0: + # Expression + expr_type = _EXPRESSION_TYPES[consume_byte() % len(_EXPRESSION_TYPES)] + if expr_type == "Literal": + return make_literal() + elif expr_type == "Identifier": + return make_identifier() + elif expr_type == "BinaryExpression": + return { + "type": "BinaryExpression", + "operator": _BINARY_OPS[consume_byte() % len(_BINARY_OPS)], + "left": make_node(depth + 1), + "right": make_node(depth + 1), + } + elif expr_type == "UnaryExpression": + return { + "type": "UnaryExpression", + "operator": _UNARY_OPS[consume_byte() % len(_UNARY_OPS)], + "argument": make_node(depth + 1), + "prefix": True, + } + elif expr_type == "CallExpression": + num_args = consume_byte() % max_children + return { + "type": "CallExpression", + "callee": make_node(depth + 1), + "arguments": [make_node(depth + 1) for _ in range(num_args)], + } + elif expr_type == "MemberExpression": + computed = consume_byte() % 2 == 0 + return { + "type": "MemberExpression", + "object": make_node(depth + 1), + "property": make_node(depth + 1), + "computed": computed, + } + elif expr_type == "AssignmentExpression": + return { + "type": "AssignmentExpression", + "operator": "=", + "left": make_identifier(), + "right": make_node(depth + 1), + } + elif expr_type == "ConditionalExpression": + return { + "type": "ConditionalExpression", + "test": make_node(depth + 1), + "consequent": make_node(depth + 1), + "alternate": make_node(depth + 1), + } + elif expr_type == "ArrayExpression": + num = consume_byte() % max_children + return { + "type": "ArrayExpression", + "elements": [make_node(depth + 1) for _ in range(num)], + } + elif expr_type == "ObjectExpression": + num = consume_byte() % max_children + return { + "type": "ObjectExpression", + "properties": [ + { + "type": "Property", + "key": make_identifier(), + "value": make_node(depth + 1), + "kind": "init", + "computed": False, + "method": False, + "shorthand": False, + } + for _ in range(num) + ], + } + elif expr_type == "FunctionExpression": + return { + "type": "FunctionExpression", + "id": None, + "params": [], + "body": { + "type": "BlockStatement", + "body": [make_statement(depth + 1) for _ in range(consume_byte() % 3)], + }, + "generator": False, + "async": False, + } + else: + return {"type": "ThisExpression"} + else: + return make_statement(depth) + + def make_statement(depth=0): + if depth >= max_depth: + return { + "type": "ExpressionStatement", + "expression": make_literal(), + } + + stmt_type = _STATEMENT_TYPES[consume_byte() % len(_STATEMENT_TYPES)] + if stmt_type == "ExpressionStatement": + return {"type": "ExpressionStatement", "expression": make_node(depth + 1)} + elif stmt_type == "VariableDeclaration": + return { + "type": "VariableDeclaration", + "declarations": [ + { + "type": "VariableDeclarator", + "id": make_identifier(), + "init": make_node(depth + 1) if consume_byte() % 2 == 0 else None, + } + ], + "kind": ["var", "let", "const"][consume_byte() % 3], + } + elif stmt_type == "ReturnStatement": + return {"type": "ReturnStatement", "argument": make_node(depth + 1) if consume_byte() % 2 == 0 else None} + elif stmt_type == "IfStatement": + return { + "type": "IfStatement", + "test": make_node(depth + 1), + "consequent": {"type": "BlockStatement", "body": [make_statement(depth + 1)]}, + "alternate": ( + {"type": "BlockStatement", "body": [make_statement(depth + 1)]} if consume_byte() % 2 == 0 else None + ), + } + elif stmt_type == "WhileStatement": + return { + "type": "WhileStatement", + "test": make_node(depth + 1), + "body": {"type": "BlockStatement", "body": [make_statement(depth + 1)]}, + } + elif stmt_type == "ForStatement": + return { + "type": "ForStatement", + "init": None, + "test": make_node(depth + 1), + "update": None, + "body": {"type": "BlockStatement", "body": [make_statement(depth + 1)]}, + } + elif stmt_type == "BlockStatement": + num = consume_byte() % max_children + return {"type": "BlockStatement", "body": [make_statement(depth + 1) for _ in range(num)]} + elif stmt_type == "EmptyStatement": + return {"type": "EmptyStatement"} + elif stmt_type == "BreakStatement": + return {"type": "BreakStatement", "label": None} + elif stmt_type == "ContinueStatement": + return {"type": "ContinueStatement", "label": None} + elif stmt_type == "ThrowStatement": + return {"type": "ThrowStatement", "argument": make_node(depth + 1)} + return {"type": "EmptyStatement"} + + num_stmts = max(1, consume_byte() % 6) + return { + "type": "Program", + "body": [make_statement(0) for _ in range(num_stmts)], + "sourceType": "script", + } + + +class SimpleFuzzedDataProvider: + """Minimal FuzzedDataProvider for when atheris is not available.""" + + def __init__(self, data): + self._data = data + self._pos = 0 + + def ConsumeUnicode(self, max_length): + end = min(self._pos + max_length, len(self._data)) + chunk = self._data[self._pos : end] + self._pos = end + return chunk.decode("utf-8", errors="replace") + + def ConsumeBytes(self, max_length): + end = min(self._pos + max_length, len(self._data)) + chunk = self._data[self._pos : end] + self._pos = end + return chunk + + def ConsumeIntInRange(self, min_val, max_val): + if self._pos < len(self._data): + val = self._data[self._pos] + self._pos += 1 + return min_val + (val % (max_val - min_val + 1)) + return min_val + + def ConsumeBool(self): + return self.ConsumeIntInRange(0, 1) == 1 + + def remaining_bytes(self): + return len(self._data) - self._pos + + +try: + import atheris + + FuzzedDataProvider = atheris.FuzzedDataProvider +except ImportError: + atheris = None + FuzzedDataProvider = SimpleFuzzedDataProvider + + +def run_fuzzer(target_fn, argv=None, custom_setup=None): + """Run a fuzz target with atheris if available, otherwise with random inputs.""" + if atheris is not None: + if custom_setup: + atheris.instrument_func(target_fn) + custom_setup() + atheris.Setup(argv or sys.argv, target_fn) + atheris.Fuzz() + else: + # Standalone random-based fuzzing + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("corpus_dirs", nargs="*", default=[]) + parser.add_argument("-max_total_time", type=int, default=10) + parser.add_argument("-max_len", type=int, default=MAX_INPUT_SIZE) + parser.add_argument("-timeout", type=int, default=30) + parser.add_argument("-rss_limit_mb", type=int, default=2048) + parser.add_argument("-runs", type=int, default=0) + args = parser.parse_args(argv[1:] if argv else sys.argv[1:]) + + # First, run seed corpus files + seeds_run = 0 + for corpus_dir in args.corpus_dirs: + if os.path.isdir(corpus_dir): + for fname in sorted(os.listdir(corpus_dir)): + fpath = os.path.join(corpus_dir, fname) + if os.path.isfile(fpath): + with open(fpath, "rb") as f: + data = f.read() + try: + target_fn(data) + except Exception as e: + if not isinstance(e, SAFE_EXCEPTIONS): + print(f"FINDING in seed {fname}: {type(e).__name__}: {e}") + seeds_run += 1 + + # Then random inputs + import time + + rng = random.Random(42) + start = time.time() + runs = 0 + max_runs = args.runs if args.runs > 0 else float("inf") + while time.time() - start < args.max_total_time and runs < max_runs: + length = rng.randint(0, min(args.max_len, 4096)) + data = bytes(rng.randint(0, 255) for _ in range(length)) + try: + target_fn(data) + except Exception as e: + if not isinstance(e, SAFE_EXCEPTIONS): + print(f"FINDING at run {runs}: {type(e).__name__}: {e}") + runs += 1 + + print(f"Fuzzing complete: {seeds_run} seeds + {runs} random inputs in {time.time() - start:.1f}s") diff --git a/tests/fuzz/fuzz_deobfuscate.py b/tests/fuzz/fuzz_deobfuscate.py new file mode 100755 index 0000000..5a950f3 --- /dev/null +++ b/tests/fuzz/fuzz_deobfuscate.py @@ -0,0 +1,39 @@ +#!/usr/bin/env python3 +"""Fuzz target for the full pyjsclear deobfuscation pipeline. + +This is the highest priority target — it tests the core safety guarantee +that the deobfuscator never crashes on any input. +""" + +import os +import sys + + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) + +from conftest_fuzz import SAFE_EXCEPTIONS +from conftest_fuzz import bytes_to_js +from conftest_fuzz import run_fuzzer + +from pyjsclear import deobfuscate + + +def TestOneInput(data): + if len(data) < 2: + return + + js_code = bytes_to_js(data) + + try: + result = deobfuscate(js_code, max_iterations=5) + except SAFE_EXCEPTIONS: + return + + # Core safety guarantee: result must never be None + assert result is not None, "deobfuscate() returned None" + # Result must be a string + assert isinstance(result, str), f"deobfuscate() returned {type(result)}, expected str" + + +if __name__ == "__main__": + run_fuzzer(TestOneInput) diff --git a/tests/fuzz/fuzz_expression_simplifier.py b/tests/fuzz/fuzz_expression_simplifier.py new file mode 100755 index 0000000..001ca9f --- /dev/null +++ b/tests/fuzz/fuzz_expression_simplifier.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +"""Fuzz target for ExpressionSimplifier in isolation. + +Dedicated target because it implements JS type coercion and arithmetic +with many edge-case branches (0/0, 1/0, "" + [], etc.). +""" + +import os +import sys + + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) + +from conftest_fuzz import SAFE_EXCEPTIONS +from conftest_fuzz import bytes_to_js +from conftest_fuzz import run_fuzzer + +from pyjsclear.generator import generate +from pyjsclear.parser import parse +from pyjsclear.transforms.expression_simplifier import ExpressionSimplifier + + +def TestOneInput(data): + if len(data) < 2: + return + + js_code = bytes_to_js(data) + + try: + ast = parse(js_code) + except (SyntaxError, RecursionError): + return + + try: + transform = ExpressionSimplifier(ast) + transform.execute() + except SAFE_EXCEPTIONS: + return + + try: + result = generate(ast) + except SAFE_EXCEPTIONS: + return + + assert isinstance(result, str), f"generate() returned {type(result)} after ExpressionSimplifier" + + +if __name__ == "__main__": + run_fuzzer(TestOneInput) diff --git a/tests/fuzz/fuzz_generator.py b/tests/fuzz/fuzz_generator.py new file mode 100755 index 0000000..be2a47a --- /dev/null +++ b/tests/fuzz/fuzz_generator.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +"""Fuzz target for the pyjsclear code generator. + +Two modes: +1. Roundtrip: parse valid JS -> generate -> assert string output +2. Synthetic AST: random AST dict -> generate -> handle expected errors +""" + +import os +import sys + + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) + +from conftest_fuzz import SAFE_EXCEPTIONS +from conftest_fuzz import FuzzedDataProvider +from conftest_fuzz import bytes_to_ast_dict +from conftest_fuzz import bytes_to_js +from conftest_fuzz import run_fuzzer + +from pyjsclear.generator import generate +from pyjsclear.parser import parse + + +def TestOneInput(data): + if len(data) < 4: + return + + fdp = FuzzedDataProvider(data) + mode = fdp.ConsumeIntInRange(0, 1) + + if mode == 0: + # Roundtrip mode: parse valid JS then generate + code = bytes_to_js(fdp.ConsumeBytes(fdp.remaining_bytes())) + try: + ast = parse(code) + except (SyntaxError, RecursionError): + return + + try: + result = generate(ast) + except SAFE_EXCEPTIONS: + return + + assert isinstance(result, str), f"generate() returned {type(result)}, expected str" + else: + # Synthetic AST mode: test with malformed input + remaining = fdp.ConsumeBytes(fdp.remaining_bytes()) + ast = bytes_to_ast_dict(remaining) + + try: + result = generate(ast) + except (KeyError, TypeError, AttributeError, ValueError): + # Expected for malformed ASTs + return + except SAFE_EXCEPTIONS: + return + + assert isinstance(result, str), f"generate() returned {type(result)}, expected str" + + +if __name__ == "__main__": + run_fuzzer(TestOneInput) diff --git a/tests/fuzz/fuzz_parser.py b/tests/fuzz/fuzz_parser.py new file mode 100755 index 0000000..40aa615 --- /dev/null +++ b/tests/fuzz/fuzz_parser.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 +"""Fuzz target for the pyjsclear parser.""" + +import os +import sys + + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) + +from conftest_fuzz import SAFE_EXCEPTIONS +from conftest_fuzz import bytes_to_js +from conftest_fuzz import run_fuzzer + +from pyjsclear.parser import parse + + +def TestOneInput(data): + if len(data) < 1: + return + + code = bytes_to_js(data) + + try: + result = parse(code) + except SyntaxError: + # Expected for invalid JS + return + except SAFE_EXCEPTIONS: + return + + # Successful parse must return a Program or Module dict + assert isinstance(result, dict), f"parse() returned {type(result)}, expected dict" + assert result.get("type") in ("Program", "Module"), f"Unexpected root type: {result.get('type')}" + + +if __name__ == "__main__": + run_fuzzer(TestOneInput) diff --git a/tests/fuzz/fuzz_scope.py b/tests/fuzz/fuzz_scope.py new file mode 100755 index 0000000..21cb853 --- /dev/null +++ b/tests/fuzz/fuzz_scope.py @@ -0,0 +1,39 @@ +#!/usr/bin/env python3 +"""Fuzz target for scope analysis.""" + +import os +import sys + + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) + +from conftest_fuzz import SAFE_EXCEPTIONS +from conftest_fuzz import bytes_to_js +from conftest_fuzz import run_fuzzer + +from pyjsclear.parser import parse +from pyjsclear.scope import build_scope_tree + + +def TestOneInput(data): + if len(data) < 2: + return + + js_code = bytes_to_js(data) + + try: + ast = parse(js_code) + except (SyntaxError, RecursionError): + return + + try: + root_scope, node_scope_map = build_scope_tree(ast) + except SAFE_EXCEPTIONS: + return + + assert root_scope is not None, "build_scope_tree returned None root_scope" + assert isinstance(node_scope_map, dict), f"node_scope_map is {type(node_scope_map)}, expected dict" + + +if __name__ == "__main__": + run_fuzzer(TestOneInput) diff --git a/tests/fuzz/fuzz_string_decoders.py b/tests/fuzz/fuzz_string_decoders.py new file mode 100755 index 0000000..25647a3 --- /dev/null +++ b/tests/fuzz/fuzz_string_decoders.py @@ -0,0 +1,91 @@ +#!/usr/bin/env python3 +"""Fuzz target for string decoders (base64, RC4). + +Tests base64_transform(), BasicStringDecoder, Base64StringDecoder, Rc4StringDecoder +with random arrays, keys, and indices. +""" + +import os +import sys + + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) + +from conftest_fuzz import SAFE_EXCEPTIONS +from conftest_fuzz import FuzzedDataProvider +from conftest_fuzz import run_fuzzer + +from pyjsclear.utils.string_decoders import Base64StringDecoder +from pyjsclear.utils.string_decoders import BasicStringDecoder +from pyjsclear.utils.string_decoders import Rc4StringDecoder +from pyjsclear.utils.string_decoders import base64_transform + + +def TestOneInput(data): + if len(data) < 8: + return + + fdp = FuzzedDataProvider(data) + decoder_choice = fdp.ConsumeIntInRange(0, 3) + + if decoder_choice == 0: + # Test base64_transform with random strings + encoded = fdp.ConsumeUnicode(1024) + try: + result = base64_transform(encoded) + except SAFE_EXCEPTIONS: + return + assert isinstance(result, str), f"base64_transform returned {type(result)}" + + elif decoder_choice == 1: + # Test BasicStringDecoder + num_strings = fdp.ConsumeIntInRange(0, 20) + string_array = [fdp.ConsumeUnicode(64) for _ in range(num_strings)] + offset = fdp.ConsumeIntInRange(-5, 5) + decoder = BasicStringDecoder(string_array, offset) + if num_strings > 0: + idx = fdp.ConsumeIntInRange(-2, num_strings * 2) + try: + result = decoder.get_string(idx) + except SAFE_EXCEPTIONS: + return + # None is valid for out-of-range indices + if result is not None: + assert isinstance(result, str), f"BasicStringDecoder returned {type(result)}" + + elif decoder_choice == 2: + # Test Base64StringDecoder + num_strings = fdp.ConsumeIntInRange(0, 20) + string_array = [fdp.ConsumeUnicode(64) for _ in range(num_strings)] + offset = fdp.ConsumeIntInRange(-5, 5) + decoder = Base64StringDecoder(string_array, offset) + if num_strings > 0: + idx = fdp.ConsumeIntInRange(-2, num_strings * 2) + try: + result = decoder.get_string(idx) + except SAFE_EXCEPTIONS: + return + # None is valid for out-of-range indices + if result is not None: + assert isinstance(result, str), f"Base64StringDecoder returned {type(result)}" + + elif decoder_choice == 3: + # Test Rc4StringDecoder - potential ZeroDivisionError with empty key + num_strings = fdp.ConsumeIntInRange(0, 20) + string_array = [fdp.ConsumeUnicode(64) for _ in range(num_strings)] + offset = fdp.ConsumeIntInRange(-5, 5) + decoder = Rc4StringDecoder(string_array, offset) + if num_strings > 0: + idx = fdp.ConsumeIntInRange(-2, num_strings * 2) + key = fdp.ConsumeUnicode(32) # May be empty - tests empty key guard + try: + result = decoder.get_string(idx, key=key) + except SAFE_EXCEPTIONS: + return + # None is valid for out-of-range or None key + if result is not None: + assert isinstance(result, str), f"Rc4StringDecoder returned {type(result)}" + + +if __name__ == "__main__": + run_fuzzer(TestOneInput) diff --git a/tests/fuzz/fuzz_transforms.py b/tests/fuzz/fuzz_transforms.py new file mode 100755 index 0000000..f5b0eeb --- /dev/null +++ b/tests/fuzz/fuzz_transforms.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python3 +"""Fuzz target for individual transforms. + +Tests each transform in isolation, bypassing the orchestrator's exception masking. +Any unhandled exception (except RecursionError) is a finding. +""" + +import os +import sys + + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) + +from conftest_fuzz import SAFE_EXCEPTIONS +from conftest_fuzz import FuzzedDataProvider +from conftest_fuzz import bytes_to_js +from conftest_fuzz import run_fuzzer + +from pyjsclear.parser import parse +from pyjsclear.scope import build_scope_tree +from pyjsclear.transforms.anti_tamper import AntiTamperRemover +from pyjsclear.transforms.constant_prop import ConstantProp +from pyjsclear.transforms.control_flow import ControlFlowRecoverer +from pyjsclear.transforms.dead_branch import DeadBranchRemover +from pyjsclear.transforms.expression_simplifier import ExpressionSimplifier +from pyjsclear.transforms.hex_escapes import HexEscapes +from pyjsclear.transforms.logical_to_if import LogicalToIf +from pyjsclear.transforms.object_packer import ObjectPacker +from pyjsclear.transforms.object_simplifier import ObjectSimplifier +from pyjsclear.transforms.property_simplifier import PropertySimplifier +from pyjsclear.transforms.proxy_functions import ProxyFunctionInliner +from pyjsclear.transforms.reassignment import ReassignmentRemover +from pyjsclear.transforms.sequence_splitter import SequenceSplitter +from pyjsclear.transforms.string_revealer import StringRevealer +from pyjsclear.transforms.unused_vars import UnusedVariableRemover + + +TRANSFORM_CLASSES = [ + StringRevealer, + HexEscapes, + UnusedVariableRemover, + ConstantProp, + ReassignmentRemover, + DeadBranchRemover, + ObjectPacker, + ProxyFunctionInliner, + SequenceSplitter, + ExpressionSimplifier, + LogicalToIf, + ControlFlowRecoverer, + PropertySimplifier, + AntiTamperRemover, + ObjectSimplifier, +] + + +def TestOneInput(data): + if len(data) < 4: + return + + fdp = FuzzedDataProvider(data) + transform_idx = fdp.ConsumeIntInRange(0, len(TRANSFORM_CLASSES) - 1) + transform_class = TRANSFORM_CLASSES[transform_idx] + + js_code = bytes_to_js(fdp.ConsumeBytes(fdp.remaining_bytes())) + + try: + ast = parse(js_code) + except (SyntaxError, RecursionError): + return + + scope_tree = None + node_scope = None + if transform_class.rebuild_scope: + try: + scope_tree, node_scope = build_scope_tree(ast) + except SAFE_EXCEPTIONS: + return + + try: + transform = transform_class(ast, scope_tree=scope_tree, node_scope=node_scope) + transform.execute() + except SAFE_EXCEPTIONS: + return + + +if __name__ == "__main__": + run_fuzzer(TestOneInput) diff --git a/tests/fuzz/fuzz_traverser.py b/tests/fuzz/fuzz_traverser.py new file mode 100755 index 0000000..64ed65e --- /dev/null +++ b/tests/fuzz/fuzz_traverser.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python3 +"""Fuzz target for AST traversal. + +Tests traverse() and simple_traverse() with synthetic ASTs and +visitors that return REMOVE/SKIP/replacement. +""" + +import os +import sys + + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) + +from conftest_fuzz import SAFE_EXCEPTIONS +from conftest_fuzz import FuzzedDataProvider +from conftest_fuzz import bytes_to_ast_dict +from conftest_fuzz import run_fuzzer + +from pyjsclear.traverser import REMOVE +from pyjsclear.traverser import SKIP +from pyjsclear.traverser import simple_traverse +from pyjsclear.traverser import traverse + + +MAX_VISITED = 10_000 + + +def TestOneInput(data): + if len(data) < 8: + return + + fdp = FuzzedDataProvider(data) + mode = fdp.ConsumeIntInRange(0, 2) + remaining = fdp.ConsumeBytes(fdp.remaining_bytes()) + ast = bytes_to_ast_dict(remaining) + + visited = 0 + + if mode == 0: + # traverse with enter that sometimes returns SKIP + action_byte = remaining[0] if remaining else 0 + + def enter(node, parent, key, index): + nonlocal visited + visited += 1 + if visited > MAX_VISITED: + return SKIP + if isinstance(node, dict) and node.get("type") == "Literal" and action_byte % 3 == 0: + return SKIP + return None + + try: + traverse(ast, {"enter": enter}) + except SAFE_EXCEPTIONS: + return + + elif mode == 1: + # traverse with enter that returns REMOVE for some nodes + action_byte = remaining[1] if len(remaining) > 1 else 0 + + def enter(node, parent, key, index): + nonlocal visited + visited += 1 + if visited > MAX_VISITED: + return SKIP + if isinstance(node, dict) and node.get("type") == "EmptyStatement" and action_byte % 2 == 0: + return REMOVE + return None + + try: + traverse(ast, {"enter": enter}) + except SAFE_EXCEPTIONS: + return + + elif mode == 2: + # simple_traverse - just visit all nodes + def callback(node, parent): + nonlocal visited + visited += 1 + if visited > MAX_VISITED: + raise StopIteration("too many nodes") + + try: + simple_traverse(ast, callback) + except (StopIteration, SAFE_EXCEPTIONS[0]): + return + + +if __name__ == "__main__": + run_fuzzer(TestOneInput) diff --git a/tests/fuzz/requirements.txt b/tests/fuzz/requirements.txt new file mode 100644 index 0000000..3f93cec --- /dev/null +++ b/tests/fuzz/requirements.txt @@ -0,0 +1 @@ +atheris>=2.3.0 diff --git a/tests/fuzz/run_local.sh b/tests/fuzz/run_local.sh new file mode 100755 index 0000000..539a81c --- /dev/null +++ b/tests/fuzz/run_local.sh @@ -0,0 +1,85 @@ +#!/bin/bash +# Local fuzzing runner for pyjsclear +# +# Usage: +# ./tests/fuzz/run_local.sh fuzz_deobfuscate 60 # run for 60 seconds +# ./tests/fuzz/run_local.sh fuzz_parser 30 # run for 30 seconds +# ./tests/fuzz/run_local.sh all 10 # run all targets for 10 seconds each + +set -e + +FUZZ_DIR="$(cd "$(dirname "$0")" && pwd)" +PROJECT_DIR="$(dirname "$(dirname "$FUZZ_DIR")")" + +# Use python3 explicitly (python may not exist on some systems) +PYTHON="${PYTHON:-python3}" + +TARGET="${1:-fuzz_deobfuscate}" +DURATION="${2:-10}" + +# Map targets to seed corpus directories +get_corpus_dir() { + local target="$1" + case "$target" in + fuzz_deobfuscate|fuzz_expression_simplifier|fuzz_transforms) + echo "$FUZZ_DIR/seed_corpus/deobfuscate" + ;; + fuzz_parser|fuzz_generator|fuzz_scope|fuzz_traverser) + echo "$FUZZ_DIR/seed_corpus/parser" + ;; + fuzz_string_decoders) + echo "$FUZZ_DIR/seed_corpus/string_decoders" + ;; + *) + echo "$FUZZ_DIR/seed_corpus/deobfuscate" + ;; + esac +} + +run_target() { + local target="$1" + local duration="$2" + local corpus_dir + corpus_dir="$(get_corpus_dir "$target")" + local work_corpus="$FUZZ_DIR/corpus/$target" + + mkdir -p "$work_corpus" + + echo "=========================================" + echo "Running $target for ${duration}s" + echo "Seed corpus: $corpus_dir" + echo "Work corpus: $work_corpus" + echo "=========================================" + + cd "$PROJECT_DIR" + + # Check if atheris is available + if "$PYTHON" -c "import atheris" 2>/dev/null; then + # Run with atheris/libFuzzer + "$PYTHON" "$FUZZ_DIR/${target}.py" \ + "$work_corpus" "$corpus_dir" \ + -max_total_time="$duration" \ + -timeout=30 \ + -rss_limit_mb=2048 \ + -max_len=102400 + else + # Run with standalone fuzzer + "$PYTHON" "$FUZZ_DIR/${target}.py" \ + "$corpus_dir" \ + -max_total_time="$duration" \ + -max_len=102400 \ + -timeout=30 \ + -rss_limit_mb=2048 + fi + + echo "" +} + +if [ "$TARGET" = "all" ]; then + TARGETS=(fuzz_deobfuscate fuzz_parser fuzz_generator fuzz_transforms fuzz_expression_simplifier fuzz_string_decoders fuzz_scope fuzz_traverser) + for t in "${TARGETS[@]}"; do + run_target "$t" "$DURATION" + done +else + run_target "$TARGET" "$DURATION" +fi diff --git a/tests/fuzz/seed_corpus/deobfuscate/2100bytes-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/2100bytes-obfuscated.js new file mode 100644 index 0000000..e3831cb --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/2100bytes-obfuscated.js @@ -0,0 +1,21 @@ +var _0x440a=['_____________________________________________1200','_____________________________________________1250','_____________________________________________1350','_____________________________________________1400','_____________________________________________1600','_____________________________________________1750','_____________________________________________1800','_____________________________________________1850','_____________________________________________1950','_____________________________________________2000','_____________________________________________2050','_____________________________________________2100','join','../common','_______________________________________________50','______________________________________________100','______________________________________________150','______________________________________________250','______________________________________________300','______________________________________________350','______________________________________________400','______________________________________________550','______________________________________________600','______________________________________________650','______________________________________________750','______________________________________________800','______________________________________________950','_____________________________________________1100','_____________________________________________1150'];(function(_0x5ed9b0,_0x1226e4){var _0x5f46e3=function(_0x3d85d4){while(--_0x3d85d4){_0x5ed9b0['push'](_0x5ed9b0['shift']());}};_0x5f46e3(++_0x1226e4);}(_0x440a,0x9e));var _0x5984=function(_0x2caeb1,_0xe91e25){_0x2caeb1=_0x2caeb1-0x0;var _0xba190d=_0x440a[_0x2caeb1];return _0xba190d;};// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. +'use strict';require(_0x5984('0x0'));console['log']([_0x5984('0x1'),_0x5984('0x2'),_0x5984('0x3'),'______________________________________________200',_0x5984('0x4'),_0x5984('0x5'),_0x5984('0x6'),_0x5984('0x7'),'______________________________________________450','______________________________________________500',_0x5984('0x8'),_0x5984('0x9'),_0x5984('0xa'),'______________________________________________700',_0x5984('0xb'),_0x5984('0xc'),'______________________________________________850','______________________________________________900',_0x5984('0xd'),'_____________________________________________1000','_____________________________________________1050',_0x5984('0xe'),_0x5984('0xf'),_0x5984('0x10'),_0x5984('0x11'),'_____________________________________________1300',_0x5984('0x12'),_0x5984('0x13'),'_____________________________________________1450','_____________________________________________1500','_____________________________________________1550',_0x5984('0x14'),'_____________________________________________1650','_____________________________________________1700',_0x5984('0x15'),_0x5984('0x16'),_0x5984('0x17'),'_____________________________________________1900',_0x5984('0x18'),_0x5984('0x19'),_0x5984('0x1a'),_0x5984('0x1b')][_0x5984('0x1c')]('\x0a')); \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/AnimatedFlatList-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/AnimatedFlatList-obfuscated.js new file mode 100644 index 0000000..4f98373 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/AnimatedFlatList-obfuscated.js @@ -0,0 +1,10 @@ +var _0x4513=['createAnimatedComponent'];(function(_0x122c40,_0x3aed78){var _0x15d54d=function(_0x52741c){while(--_0x52741c){_0x122c40['push'](_0x122c40['shift']());}};_0x15d54d(++_0x3aed78);}(_0x4513,0xc0));var _0xb4c9=function(_0x4ab944,_0xf7a37a){_0x4ab944=_0x4ab944-0x0;var _0x342b16=_0x4513[_0x4ab944];return _0x342b16;};/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @flow strict-local + * @format + */ +'use strict';const FlatList=require('FlatList');const createAnimatedComponent=require(_0xb4c9('0x0'));module['exports']=createAnimatedComponent(FlatList); \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/AnimatedImage-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/AnimatedImage-obfuscated.js new file mode 100644 index 0000000..1173d47 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/AnimatedImage-obfuscated.js @@ -0,0 +1,10 @@ +var _0x8ec6=['createAnimatedComponent','exports'];(function(_0x491406,_0x234b10){var _0x2e0746=function(_0xe61c3a){while(--_0xe61c3a){_0x491406['push'](_0x491406['shift']());}};_0x2e0746(++_0x234b10);}(_0x8ec6,0x6e));var _0xdcd7=function(_0x4169bf,_0x236275){_0x4169bf=_0x4169bf-0x0;var _0x4fe88c=_0x8ec6[_0x4169bf];return _0x4fe88c;};/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @flow strict-local + * @format + */ +'use strict';const Image=require('Image');const createAnimatedComponent=require(_0xdcd7('0x0'));module[_0xdcd7('0x1')]=createAnimatedComponent(Image); \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/AnimatedWeb-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/AnimatedWeb-obfuscated.js new file mode 100644 index 0000000..4d3212f --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/AnimatedWeb-obfuscated.js @@ -0,0 +1,10 @@ +var _0x2087=['exports','createAnimatedComponent','div','span','img'];(function(_0x587216,_0x4ff990){var _0x309a00=function(_0x2ad6ff){while(--_0x2ad6ff){_0x587216['push'](_0x587216['shift']());}};_0x309a00(++_0x4ff990);}(_0x2087,0x1e0));var _0x1a50=function(_0xd7505,_0x5d61cf){_0xd7505=_0xd7505-0x0;var _0x587c8b=_0x2087[_0xd7505];return _0x587c8b;};/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @format + * @flow strict-local + */ +'use strict';const AnimatedImplementation=require('AnimatedImplementation');module[_0x1a50('0x0')]={...AnimatedImplementation,'div':AnimatedImplementation[_0x1a50('0x1')](_0x1a50('0x2')),'span':AnimatedImplementation[_0x1a50('0x1')](_0x1a50('0x3')),'img':AnimatedImplementation[_0x1a50('0x1')](_0x1a50('0x4'))}; \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/App-obfuscated.test.js b/tests/fuzz/seed_corpus/deobfuscate/App-obfuscated.test.js new file mode 100644 index 0000000..d991c5c --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/App-obfuscated.test.js @@ -0,0 +1 @@ +var _0x3e35=['creates\x20instance\x20without','foo','toBe'];(function(_0x172ba0,_0x47a250){var _0x18c49a=function(_0x5111d9){while(--_0x5111d9){_0x172ba0['push'](_0x172ba0['shift']());}};_0x18c49a(++_0x47a250);}(_0x3e35,0x180));var _0x4be9=function(_0x1f37d0,_0x426088){_0x1f37d0=_0x1f37d0-0x0;var _0x3744b8=_0x3e35[_0x1f37d0];return _0x3744b8;};import _0x5acf3d from'./App';it(_0x4be9('0x0'),()=>{const _0x3d0c37=new _0x5acf3d();expect(_0x3d0c37[_0x4be9('0x1')]())[_0x4be9('0x2')]('bar');}); \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/InteractionManager-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/InteractionManager-obfuscated.js new file mode 100644 index 0000000..45c6cc0 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/InteractionManager-obfuscated.js @@ -0,0 +1,9 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @format + */ +'use strict';module['exports']={'createInteractionHandle':function(){},'clearInteractionHandle':function(){}}; \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/_stream_passthrough-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/_stream_passthrough-obfuscated.js new file mode 100644 index 0000000..5641809 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/_stream_passthrough-obfuscated.js @@ -0,0 +1,24 @@ +var _0xa76a=['exports','_stream_transform','setPrototypeOf','prototype','call','_transform'];(function(_0x2a4513,_0x2a749d){var _0x30ac98=function(_0x5d05ff){while(--_0x5d05ff){_0x2a4513['push'](_0x2a4513['shift']());}};_0x30ac98(++_0x2a749d);}(_0xa76a,0x1a4));var _0x5a71=function(_0x512274,_0x2d8866){_0x512274=_0x512274-0x0;var _0xe48c53=_0xa76a[_0x512274];return _0xe48c53;};// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. +// a passthrough stream. +// basically just the most minimal sort of Transform stream. +// Every written chunk gets output as-is. +'use strict';module[_0x5a71('0x0')]=PassThrough;const Transform=require(_0x5a71('0x1'));Object[_0x5a71('0x2')](PassThrough[_0x5a71('0x3')],Transform[_0x5a71('0x3')]);Object[_0x5a71('0x2')](PassThrough,Transform);function PassThrough(_0x1e0b1a){if(!(this instanceof PassThrough))return new PassThrough(_0x1e0b1a);Transform[_0x5a71('0x4')](this,_0x1e0b1a);}PassThrough[_0x5a71('0x3')][_0x5a71('0x5')]=function(_0x5a83b6,_0x595a31,_0x5b08c2){_0x5b08c2(null,_0x5a83b6);}; \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/alias-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/alias-obfuscated.js new file mode 100644 index 0000000..9778e0b --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/alias-obfuscated.js @@ -0,0 +1 @@ +var _0x57fc=['../','src/platforms/web/entry-runtime-with-compiler','src/core','src/shared','src/platforms/web','src/platforms/weex','src/server','src/sfc','path'];(function(_0x8cc41d,_0x23aa62){var _0x248af3=function(_0x3ca02c){while(--_0x3ca02c){_0x8cc41d['push'](_0x8cc41d['shift']());}};_0x248af3(++_0x23aa62);}(_0x57fc,0x1af));var _0xfec6=function(_0x6d31f3,_0x5b79d8){_0x6d31f3=_0x6d31f3-0x0;var _0x12333a=_0x57fc[_0x6d31f3];return _0x12333a;};const path=require(_0xfec6('0x0'));const resolve=_0x5e8d00=>path['resolve'](__dirname,_0xfec6('0x1'),_0x5e8d00);module['exports']={'vue':resolve(_0xfec6('0x2')),'compiler':resolve('src/compiler'),'core':resolve(_0xfec6('0x3')),'shared':resolve(_0xfec6('0x4')),'web':resolve(_0xfec6('0x5')),'weex':resolve(_0xfec6('0x6')),'server':resolve(_0xfec6('0x7')),'sfc':resolve(_0xfec6('0x8'))}; \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/authentication-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/authentication-obfuscated.js new file mode 100644 index 0000000..41e624e --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/authentication-obfuscated.js @@ -0,0 +1 @@ +var _0x3790=['log','fcc:boot:auth\x20-\x20Sign\x20up\x20is\x20disabled','exports','Router','LOCAL_MOCK_AUTH','get','/signin','devlogin','authenticate','auth0-login','/auth/auth0/callback','auth0','/signout','logout','session','destroy','info','redirect','use','env'];(function(_0x2ed248,_0x3361b1){var _0x27b87e=function(_0x300ddf){while(--_0x300ddf){_0x2ed248['push'](_0x2ed248['shift']());}};_0x27b87e(++_0x3361b1);}(_0x3790,0x18f));var _0xb67a=function(_0x2a34e1,_0x27826a){_0x2a34e1=_0x2a34e1-0x0;var _0x5cd7a8=_0x3790[_0x2a34e1];return _0x5cd7a8;};import _0x5854f9 from'passport';import{homeLocation}from'../../../config/env';import{createPassportCallbackAuthenticator,saveResponseAuthCookies,loginRedirect}from'../component-passport';import{ifUserRedirectTo}from'../utils/middleware';import{wrapHandledError}from'../utils/create-handled-error.js';import{removeCookies}from'../utils/getSetAccessToken';const isSignUpDisabled=!!process[_0xb67a('0x0')]['DISABLE_SIGNUP'];if(isSignUpDisabled){console[_0xb67a('0x1')](_0xb67a('0x2'));}module[_0xb67a('0x3')]=function enableAuthentication(app){app['enableAuth']();const ifUserRedirect=ifUserRedirectTo();const saveAuthCookies=saveResponseAuthCookies();const loginSuccessRedirect=loginRedirect();const api=app['loopback'][_0xb67a('0x4')]();if(process[_0xb67a('0x0')][_0xb67a('0x5')]==='true'){api[_0xb67a('0x6')](_0xb67a('0x7'),_0x5854f9['authenticate'](_0xb67a('0x8')),saveAuthCookies,loginSuccessRedirect);}else{api['get'](_0xb67a('0x7'),ifUserRedirect,_0x5854f9[_0xb67a('0x9')](_0xb67a('0xa'),{}));api['get'](_0xb67a('0xb'),createPassportCallbackAuthenticator(_0xb67a('0xa'),{'provider':_0xb67a('0xc')}));}api[_0xb67a('0x6')](_0xb67a('0xd'),(req,res)=>{req[_0xb67a('0xe')]();req[_0xb67a('0xf')][_0xb67a('0x10')](err=>{if(err){throw wrapHandledError(new Error('could\x20not\x20destroy\x20session'),{'type':_0xb67a('0x11'),'message':'Oops,\x20something\x20is\x20not\x20right.','redirectTo':homeLocation});}removeCookies(req,res);res[_0xb67a('0x12')](homeLocation);});});app[_0xb67a('0x13')](api);}; \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/base64_strings.js b/tests/fuzz/seed_corpus/deobfuscate/base64_strings.js new file mode 100644 index 0000000..5470d6e --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/base64_strings.js @@ -0,0 +1 @@ +function i(){var G=['C3bSAxq','CMv2zxjZzq','AM9PBG','CMvWBgfJzq','CMfKyxi','AgvSBg8','Bgv2zwW','D29YBgq','Bg9N','igLZihbHBgLUzhjVBwu6'];i=function(){return G;};return i();}function Z(m,A){m=m-0x0;var S=i();var D=S[m];if(Z['TtgeCi']===undefined){var h=function(I){var G='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var q='';var c='';for(var F=0x0,N,J,C=0x0;J=I['charAt'](C++);~J&&(N=F%0x4?N*0x40+J:J,F++%0x4)?q+=String['fromCharCode'](0xff&N>>(-0x2*F&0x6)):0x0){J=G['indexOf'](J);}for(var H=0x0,M=q['length'];H:1:1)\x0a\x20\x20\x20\x20at\x20a\x20(file:///Users/joe/Documents/Development/OSS/stack-frame/index.html:8:9)\x0a\x20\x20\x20\x20at\x20file:///Users/joe/Documents/Development/OSS/stack-frame/index.html:32:7','toMatchSnapshot'];(function(_0x196350,_0xa608e0){var _0xa5418b=function(_0x1dc21f){while(--_0x1dc21f){_0x196350['push'](_0x196350['shift']());}};_0xa5418b(++_0xa608e0);}(_0x2a9e,0x19a));var _0x5949=function(_0x1193a8,_0xbff324){_0x1193a8=_0x1193a8-0x0;var _0x2dbcd1=_0x2a9e[_0x1193a8];return _0x2dbcd1;};import{parse}from'../../utils/parser';test('stack\x20with\x20eval',()=>{expect(parse(_0x5949('0x0')))[_0x5949('0x1')]();}); \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/code_beautify_site.js b/tests/fuzz/seed_corpus/deobfuscate/code_beautify_site.js new file mode 100644 index 0000000..3d8cf15 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/code_beautify_site.js @@ -0,0 +1 @@ +function _0x2615(_0x4082e7,_0x1f4b97){_0x4082e7=_0x4082e7-(0x9b1+-0x356+-0x475);var _0x302ef7=_0x2997();var _0x48e296=_0x302ef7[_0x4082e7];return _0x48e296;}function _0x2997(){var _0x56b87d=['forEach','310602RhzfCI','2302704pUDPbr','toLowerCas','lKFrK','join','\x20is\x20palind','hello','log','tTvXP','rome:','178428KyEAhC','level','3YJoQmS','NLwuO','reverse','SyGyT','replace','108284XVQGfx','MVjMh','33238wBAitb','728975KHRPzT','radar','wIGHE','world','EBlpd','split','996198XqETvj','iMyPs'];_0x2997=function(){return _0x56b87d;};return _0x2997();}(function(_0x391956,_0x9da1c9){var _0x59973c=_0x2615,_0x31f998=_0x391956();while(!![]){try{var _0x366601=-parseInt(_0x59973c(0x202))/(-0x179*-0x17+-0x1948*0x1+0x2*-0x44b)+-parseInt(_0x59973c(0x1ee))/(-0x1*-0xab4+0x20e1+-0x2b93)*(-parseInt(_0x59973c(0x1e7))/(-0x2*-0xee3+0x135f+-0x3122))+parseInt(_0x59973c(0x1ec))/(0xd1+0x15d1+-0x169e)+parseInt(_0x59973c(0x1ef))/(0x66b*0x4+0x1*-0x2689+0xce2)+-parseInt(_0x59973c(0x1f8))/(0x64c*0x1+0x1a15+-0xac9*0x3)+-parseInt(_0x59973c(0x1f5))/(-0x5*-0x709+0x4f4*-0x1+-0x2*0xf19)+parseInt(_0x59973c(0x1f9))/(-0xf49+-0x161f+0x2570);if(_0x366601===_0x9da1c9)break;else _0x31f998['push'](_0x31f998['shift']());}catch(_0x5b13a5){_0x31f998['push'](_0x31f998['shift']());}}}(_0x2997,0x5*-0x7ee2+0x6f31*0x5+0x1e7e3),(function(){var _0x24e80f=_0x2615,_0x1f9dae={'wIGHE':function(_0x392ac9,_0x2a1900){return _0x392ac9===_0x2a1900;},'MVjMh':function(_0x5f41a3,_0x343e5f){return _0x5f41a3(_0x343e5f);},'EBlpd':function(_0x56b4df,_0x32fe8d){return _0x56b4df+_0x32fe8d;},'tTvXP':_0x24e80f(0x1fd)+_0x24e80f(0x201),'SyGyT':_0x24e80f(0x1f0),'lKFrK':_0x24e80f(0x1fe),'iMyPs':_0x24e80f(0x1e6),'NLwuO':_0x24e80f(0x1f2)};function _0x2993a3(_0x2300de){var _0x56c8d8=_0x24e80f;return _0x2300de[_0x56c8d8(0x1f4)]('')[_0x56c8d8(0x1e9)]()[_0x56c8d8(0x1fc)]('');}function _0x5163e8(_0x2014d1){var _0x443432=_0x24e80f,_0x2579d5=_0x2014d1[_0x443432(0x1fa)+'e']()[_0x443432(0x1eb)](/[^a-z]/g,'');return _0x1f9dae[_0x443432(0x1f1)](_0x2579d5,_0x1f9dae[_0x443432(0x1ed)](_0x2993a3,_0x2579d5));}var _0x14f80a=[_0x1f9dae[_0x24e80f(0x1ea)],_0x1f9dae[_0x24e80f(0x1fb)],_0x1f9dae[_0x24e80f(0x1f6)],_0x1f9dae[_0x24e80f(0x1e8)]];_0x14f80a[_0x24e80f(0x1f7)](function(_0x13e1ea){var _0x9d1d5b=_0x24e80f;console[_0x9d1d5b(0x1ff)](_0x1f9dae[_0x9d1d5b(0x1f3)](_0x13e1ea,_0x1f9dae[_0x9d1d5b(0x200)]),_0x1f9dae[_0x9d1d5b(0x1ed)](_0x5163e8,_0x13e1ea));});}())); \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/control_flow_flatten.js b/tests/fuzz/seed_corpus/deobfuscate/control_flow_flatten.js new file mode 100644 index 0000000..14ca2a7 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/control_flow_flatten.js @@ -0,0 +1 @@ +(function(){var i={'WqSdl':function(S,D){return S(D);},'ISOfZ':'\x20is\x20palindrome:','HZEhI':function(S,D){return S(D);},'pXSrL':'radar','hTwpb':'hello','sePsv':'level','PdjHE':'world'};function Z(S){return S['split']('')['reverse']()['join']('');}function m(S){var D=S['toLowerCase']()['replace'](/[^a-z]/g,'');return D===i['WqSdl'](Z,D);}var A=[i['pXSrL'],i['hTwpb'],i['sePsv'],i['PdjHE']];A['forEach'](function(S){console['log'](S+i['ISOfZ'],i['HZEhI'](m,S));});}()); \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/dns-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/dns-obfuscated.js new file mode 100644 index 0000000..7594e32 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/dns-obfuscated.js @@ -0,0 +1,2 @@ +var _0x3de3=['cls','TXT','byteLength','Unknown\x20RR\x20type\x20','byteOffset','swap16','swap32','ENOTFOUND','getaddrinfo','errno','syscall','exports','toString','ascii','strictEqual','readUInt16BE','length','questions','answers','type','ttl','readInt32BE','address','AAAA','$1:','entries','push','priority','readInt16BE','exchange','CNAME','PTR','value','SOA','nread','nsname','domain','hostmaster','serial','readUInt32BE','refresh','retry','expire','minttl','split','alloc','writeUInt16BE','concat','from','flags','authorityAnswers','additionalRecords'];(function(_0xa3fea0,_0x474340){var _0x25b2af=function(_0x312580){while(--_0x312580){_0xa3fea0['push'](_0xa3fea0['shift']());}};_0x25b2af(++_0x474340);}(_0x3de3,0x110));var _0x3819=function(_0xb118db,_0x44ff94){_0xb118db=_0xb118db-0x0;var _0x581c8b=_0x3de3[_0xb118db];return _0x581c8b;};/* eslint-disable node-core/required-modules */ +'use strict';const assert=require('assert');const os=require('os');const types={'A':0x1,'AAAA':0x1c,'NS':0x2,'CNAME':0x5,'SOA':0x6,'PTR':0xc,'MX':0xf,'TXT':0x10,'ANY':0xff};const classes={'IN':0x1};function readDomainFromPacket(_0x3516da,_0x109a7c){assert['ok'](_0x109a7c<_0x3516da['length']);const _0x278a69=_0x3516da[_0x109a7c];if(_0x278a69===0x0){return{'nread':0x1,'domain':''};}else if((_0x278a69&0xc0)===0x0){_0x109a7c+=0x1;const _0x289420=_0x3516da[_0x3819('0x0')](_0x3819('0x1'),_0x109a7c,_0x109a7c+_0x278a69);const {nread,domain}=readDomainFromPacket(_0x3516da,_0x109a7c+_0x278a69);return{'nread':0x1+_0x278a69+nread,'domain':domain?_0x289420+'.'+domain:_0x289420};}else{assert[_0x3819('0x2')](_0x278a69&0xc0,0xc0);const _0x15873c=_0x3516da[_0x3819('0x3')](_0x109a7c)&~0xc000;return{'nread':0x2,'domain':readDomainFromPacket(_0x3516da,_0x15873c)};}}function parseDNSPacket(_0x5094dc){assert['ok'](_0x5094dc[_0x3819('0x4')]>0xc);const _0x485467={'id':_0x5094dc[_0x3819('0x3')](0x0),'flags':_0x5094dc[_0x3819('0x3')](0x2)};const _0x30ca26=[[_0x3819('0x5'),_0x5094dc['readUInt16BE'](0x4)],[_0x3819('0x6'),_0x5094dc[_0x3819('0x3')](0x6)],['authorityAnswers',_0x5094dc[_0x3819('0x3')](0x8)],['additionalRecords',_0x5094dc['readUInt16BE'](0xa)]];let _0x528db5=0xc;for(const [_0x37b479,_0x294932]of _0x30ca26){_0x485467[_0x37b479]=[];for(let _0xe8bea=0x0;_0xe8bea<_0x294932;++_0xe8bea){const {nread,domain}=readDomainFromPacket(_0x5094dc,_0x528db5);_0x528db5+=nread;const _0x2c47d9=_0x5094dc[_0x3819('0x3')](_0x528db5);const _0x2bd124={'domain':domain,'cls':_0x5094dc[_0x3819('0x3')](_0x528db5+0x2)};_0x528db5+=0x4;for(const _0x48e45c in types){if(types[_0x48e45c]===_0x2c47d9)_0x2bd124[_0x3819('0x7')]=_0x48e45c;}if(_0x37b479!==_0x3819('0x5')){_0x2bd124[_0x3819('0x8')]=_0x5094dc[_0x3819('0x9')](_0x528db5);const _0x5c9852=_0x5094dc[_0x3819('0x3')](_0x528db5);_0x528db5+=0x6;switch(_0x2c47d9){case types['A']:assert[_0x3819('0x2')](_0x5c9852,0x4);_0x2bd124[_0x3819('0xa')]=_0x5094dc[_0x528db5+0x0]+'.'+_0x5094dc[_0x528db5+0x1]+'.'+(_0x5094dc[_0x528db5+0x2]+'.'+_0x5094dc[_0x528db5+0x3]);break;case types[_0x3819('0xb')]:assert[_0x3819('0x2')](_0x5c9852,0x10);_0x2bd124[_0x3819('0xa')]=_0x5094dc[_0x3819('0x0')]('hex',_0x528db5,_0x528db5+0x10)['replace'](/(.{4}(?!$))/g,_0x3819('0xc'));break;case types['TXT']:{let _0x836470=_0x528db5;_0x2bd124[_0x3819('0xd')]=[];while(_0x836470<_0x528db5+_0x5c9852){const _0x1747d6=_0x5094dc[_0x528db5];_0x2bd124['entries'][_0x3819('0xe')](_0x5094dc[_0x3819('0x0')]('utf8',_0x836470+0x1,_0x836470+0x1+_0x1747d6));_0x836470+=0x1+_0x1747d6;}assert['strictEqual'](_0x836470,_0x528db5+_0x5c9852);break;}case types['MX']:{_0x2bd124[_0x3819('0xf')]=_0x5094dc[_0x3819('0x10')](_0x5094dc,_0x528db5);_0x528db5+=0x2;const {nread,domain}=readDomainFromPacket(_0x5094dc,_0x528db5);_0x2bd124[_0x3819('0x11')]=domain;assert[_0x3819('0x2')](nread,_0x5c9852);break;}case types['NS']:case types[_0x3819('0x12')]:case types[_0x3819('0x13')]:{const {nread,domain}=readDomainFromPacket(_0x5094dc,_0x528db5);_0x2bd124[_0x3819('0x14')]=domain;assert[_0x3819('0x2')](nread,_0x5c9852);break;}case types[_0x3819('0x15')]:{const _0x372504=readDomainFromPacket(_0x5094dc,_0x528db5);const _0x2b3b5a=readDomainFromPacket(_0x5094dc,_0x528db5+_0x372504[_0x3819('0x16')]);_0x2bd124[_0x3819('0x17')]=_0x372504[_0x3819('0x18')];_0x2bd124[_0x3819('0x19')]=_0x2b3b5a[_0x3819('0x18')];const _0x13c08f=_0x528db5+_0x372504[_0x3819('0x16')]+_0x2b3b5a[_0x3819('0x16')];_0x2bd124[_0x3819('0x1a')]=_0x5094dc[_0x3819('0x1b')](_0x13c08f);_0x2bd124[_0x3819('0x1c')]=_0x5094dc[_0x3819('0x1b')](_0x13c08f+0x4);_0x2bd124[_0x3819('0x1d')]=_0x5094dc[_0x3819('0x1b')](_0x13c08f+0x8);_0x2bd124[_0x3819('0x1e')]=_0x5094dc[_0x3819('0x1b')](_0x13c08f+0xc);_0x2bd124[_0x3819('0x1f')]=_0x5094dc[_0x3819('0x1b')](_0x13c08f+0x10);assert['strictEqual'](_0x13c08f+0x14,_0x5c9852);break;}default:throw new Error('Unknown\x20RR\x20type\x20'+_0x2bd124['type']);}_0x528db5+=_0x5c9852;}_0x485467[_0x37b479][_0x3819('0xe')](_0x2bd124);assert['ok'](_0x528db5<=_0x5094dc['length']);}}assert[_0x3819('0x2')](_0x528db5,_0x5094dc[_0x3819('0x4')]);return _0x485467;}function writeIPv6(_0x4233a0){const _0x6684cb=_0x4233a0['replace'](/^:|:$/g,'')[_0x3819('0x20')](':');const _0x95937d=Buffer[_0x3819('0x21')](0x10);let _0x55c7cb=0x0;for(const _0x5275f9 of _0x6684cb){if(_0x5275f9===''){_0x55c7cb+=0x10-0x2*(_0x6684cb[_0x3819('0x4')]-0x1);}else{_0x95937d[_0x3819('0x22')](parseInt(_0x5275f9,0x10),_0x55c7cb);_0x55c7cb+=0x2;}}return _0x95937d;}function writeDomainName(_0x3b6a7c){return Buffer[_0x3819('0x23')](_0x3b6a7c[_0x3819('0x20')]('.')['map'](_0x22df02=>{assert(_0x22df02['length']<0x40);return Buffer[_0x3819('0x23')]([Buffer[_0x3819('0x24')]([_0x22df02[_0x3819('0x4')]]),Buffer[_0x3819('0x24')](_0x22df02,'ascii')]);})[_0x3819('0x23')]([Buffer[_0x3819('0x21')](0x1)]));}function writeDNSPacket(_0x53675d){const _0x3106d7=[];const _0x2e758e=0x8180;_0x3106d7[_0x3819('0xe')](new Uint16Array([_0x53675d['id'],_0x53675d[_0x3819('0x25')]===undefined?_0x2e758e:_0x53675d[_0x3819('0x25')],_0x53675d[_0x3819('0x5')]&&_0x53675d[_0x3819('0x5')][_0x3819('0x4')],_0x53675d[_0x3819('0x6')]&&_0x53675d[_0x3819('0x6')]['length'],_0x53675d[_0x3819('0x26')]&&_0x53675d[_0x3819('0x26')][_0x3819('0x4')],_0x53675d[_0x3819('0x27')]&&_0x53675d[_0x3819('0x27')][_0x3819('0x4')]]));for(const _0x4ecf61 of _0x53675d[_0x3819('0x5')]){assert(types[_0x4ecf61[_0x3819('0x7')]]);_0x3106d7[_0x3819('0xe')](writeDomainName(_0x4ecf61[_0x3819('0x18')]));_0x3106d7[_0x3819('0xe')](new Uint16Array([types[_0x4ecf61['type']],_0x4ecf61[_0x3819('0x28')]===undefined?classes['IN']:_0x4ecf61[_0x3819('0x28')]]));}for(const _0x38fa1c of[][_0x3819('0x23')](_0x53675d[_0x3819('0x6')],_0x53675d['authorityAnswers'],_0x53675d[_0x3819('0x27')])){if(!_0x38fa1c)continue;assert(types[_0x38fa1c[_0x3819('0x7')]]);_0x3106d7[_0x3819('0xe')](writeDomainName(_0x38fa1c['domain']));_0x3106d7['push'](new Uint16Array([types[_0x38fa1c[_0x3819('0x7')]],_0x38fa1c[_0x3819('0x28')]===undefined?classes['IN']:_0x38fa1c[_0x3819('0x28')]]));_0x3106d7[_0x3819('0xe')](new Int32Array([_0x38fa1c[_0x3819('0x8')]]));const _0x458b24=new Uint16Array(0x1);_0x3106d7['push'](_0x458b24);switch(_0x38fa1c[_0x3819('0x7')]){case'A':_0x458b24[0x0]=0x4;_0x3106d7[_0x3819('0xe')](new Uint8Array(_0x38fa1c[_0x3819('0xa')][_0x3819('0x20')]('.')));break;case _0x3819('0xb'):_0x458b24[0x0]=0x10;_0x3106d7[_0x3819('0xe')](writeIPv6(_0x38fa1c['address']));break;case _0x3819('0x29'):const _0x26632e=_0x38fa1c[_0x3819('0xd')]['map'](_0x5a58f4=>_0x5a58f4[_0x3819('0x4')])['reduce']((_0x32ac9d,_0x398dfb)=>_0x32ac9d+_0x398dfb);_0x458b24[0x0]=_0x38fa1c[_0x3819('0xd')]['length']+_0x26632e;for(const _0x56c193 of _0x38fa1c[_0x3819('0xd')]){_0x3106d7[_0x3819('0xe')](new Uint8Array([Buffer[_0x3819('0x2a')](_0x56c193)]));_0x3106d7['push'](Buffer[_0x3819('0x24')](_0x56c193));}break;case'MX':_0x458b24[0x0]=0x2;_0x3106d7['push'](new Uint16Array([_0x38fa1c['priority']]));case'NS':case _0x3819('0x12'):case _0x3819('0x13'):{const _0x26e374=writeDomainName(_0x38fa1c[_0x3819('0x11')]||_0x38fa1c['value']);_0x458b24[0x0]+=_0x26e374[_0x3819('0x4')];_0x3106d7[_0x3819('0xe')](_0x26e374);break;}case _0x3819('0x15'):{const _0x5f5209=writeDomainName(_0x38fa1c[_0x3819('0x17')]);const _0x18f7f1=writeDomainName(_0x38fa1c[_0x3819('0x19')]);_0x458b24[0x0]=_0x5f5209[_0x3819('0x4')]+_0x18f7f1[_0x3819('0x4')]+0x14;_0x3106d7[_0x3819('0xe')](_0x5f5209,_0x18f7f1);_0x3106d7[_0x3819('0xe')](new Uint32Array([_0x38fa1c['serial'],_0x38fa1c[_0x3819('0x1c')],_0x38fa1c['retry'],_0x38fa1c[_0x3819('0x1e')],_0x38fa1c[_0x3819('0x1f')]]));break;}default:throw new Error(_0x3819('0x2b')+_0x38fa1c[_0x3819('0x7')]);}}return Buffer['concat'](_0x3106d7['map'](_0x1fdb17=>{const _0x210ad8=Buffer['from'](_0x1fdb17['buffer'],_0x1fdb17[_0x3819('0x2c')],_0x1fdb17[_0x3819('0x2a')]);if(os['endianness']()==='LE'){if(_0x1fdb17['BYTES_PER_ELEMENT']===0x2)_0x210ad8[_0x3819('0x2d')]();if(_0x1fdb17['BYTES_PER_ELEMENT']===0x4)_0x210ad8[_0x3819('0x2e')]();}return _0x210ad8;}));}const mockedErrorCode=_0x3819('0x2f');const mockedSysCall=_0x3819('0x30');function errorLookupMock(_0x5476fc=mockedErrorCode,_0x147ffb=mockedSysCall){return function lookupWithError(_0x24c445,_0x25a2ec,_0x203084){const _0x3d927a=new Error(_0x147ffb+'\x20'+_0x5476fc+'\x20'+_0x24c445);_0x3d927a['code']=_0x5476fc;_0x3d927a[_0x3819('0x31')]=_0x5476fc;_0x3d927a[_0x3819('0x32')]=_0x147ffb;_0x3d927a['hostname']=_0x24c445;_0x203084(_0x3d927a);};}module[_0x3819('0x33')]={'types':types,'classes':classes,'writeDNSPacket':writeDNSPacket,'parseDNSPacket':parseDNSPacket,'errorLookupMock':errorLookupMock,'mockedErrorCode':mockedErrorCode,'mockedSysCall':mockedSysCall}; \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/edge_control_flow_flat.js b/tests/fuzz/seed_corpus/deobfuscate/edge_control_flow_flat.js new file mode 100644 index 0000000..fac76d2 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/edge_control_flow_flat.js @@ -0,0 +1,10 @@ +var _0x1 = '2|0|1|3'.split('|'), _0x2 = 0; +while (true) { + switch (_0x1[_0x2++]) { + case '0': var b = 2; continue; + case '1': var c = a + b; continue; + case '2': var a = 1; continue; + case '3': console.log(c); continue; + } + break; +} diff --git a/tests/fuzz/seed_corpus/deobfuscate/edge_deep_nesting.js b/tests/fuzz/seed_corpus/deobfuscate/edge_deep_nesting.js new file mode 100644 index 0000000..4e5c0ce --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/edge_deep_nesting.js @@ -0,0 +1 @@ +var x = ((((((((((((((((((((1)))))))))))))))))))); \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/edge_empty.js b/tests/fuzz/seed_corpus/deobfuscate/edge_empty.js new file mode 100644 index 0000000..e69de29 diff --git a/tests/fuzz/seed_corpus/deobfuscate/edge_huge_array.js b/tests/fuzz/seed_corpus/deobfuscate/edge_huge_array.js new file mode 100644 index 0000000..58fe48b --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/edge_huge_array.js @@ -0,0 +1 @@ +var a = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]; \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/edge_null_bytes.js b/tests/fuzz/seed_corpus/deobfuscate/edge_null_bytes.js new file mode 100644 index 0000000..14bfc2d --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/edge_null_bytes.js @@ -0,0 +1 @@ +var x = "hello\x00world"; \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/edge_obfuscatorio_minimal.js b/tests/fuzz/seed_corpus/deobfuscate/edge_obfuscatorio_minimal.js new file mode 100644 index 0000000..05477b7 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/edge_obfuscatorio_minimal.js @@ -0,0 +1,13 @@ +var _0x1234 = ['aGVsbG8=', 'd29ybGQ=']; +(function(_0x5678, _0x9abc) { + var _0xdef0 = function(_0x1111) { + while (--_0x1111) { + _0x5678['push'](_0x5678['shift']()); + } + }; + _0xdef0(++_0x9abc); +}(_0x1234, 0x1)); +var _0xget = function(_0x2222) { + return _0x1234[_0x2222]; +}; +console['log'](_0xget(0x0)); diff --git a/tests/fuzz/seed_corpus/deobfuscate/edge_semicolon.js b/tests/fuzz/seed_corpus/deobfuscate/edge_semicolon.js new file mode 100644 index 0000000..1c8a0e7 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/edge_semicolon.js @@ -0,0 +1 @@ +; \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/edge_type_coercion.js b/tests/fuzz/seed_corpus/deobfuscate/edge_type_coercion.js new file mode 100644 index 0000000..20140c6 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/edge_type_coercion.js @@ -0,0 +1,14 @@ +var a = 0 / 0; +var b = 1 / 0; +var c = "" + []; +var d = [] + {}; +var e = {} + []; +var f = !!""; +var g = !!0; +var h = !![]; +var i = +true; +var j = +false; +var k = +null; +var l = +undefined; +var m = "5" - 3; +var n = "5" + 3; diff --git a/tests/fuzz/seed_corpus/deobfuscate/edge_unicode.js b/tests/fuzz/seed_corpus/deobfuscate/edge_unicode.js new file mode 100644 index 0000000..0d270f3 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/edge_unicode.js @@ -0,0 +1,3 @@ +var café = "héllo"; +var π = 3.14159; +var _$_ = "underscore dollar"; diff --git a/tests/fuzz/seed_corpus/deobfuscate/hello_world-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/hello_world-obfuscated.js new file mode 100644 index 0000000..ddf77bc --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/hello_world-obfuscated.js @@ -0,0 +1,21 @@ +var _0x4314=['hello\x20world','../common','log'];(function(_0x3488d3,_0x313423){var _0x416c96=function(_0x30ad36){while(--_0x30ad36){_0x3488d3['push'](_0x3488d3['shift']());}};_0x416c96(++_0x313423);}(_0x4314,0x1d5));var _0x44c6=function(_0x1da8fd,_0x4465df){_0x1da8fd=_0x1da8fd-0x0;var _0x522bde=_0x4314[_0x1da8fd];return _0x522bde;};// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. +'use strict';require(_0x44c6('0x0'));console[_0x44c6('0x1')](_0x44c6('0x2')); \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/large-obfuscatorio-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/large-obfuscatorio-obfuscated.js new file mode 100644 index 0000000..1c0a6cd --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/large-obfuscatorio-obfuscated.js @@ -0,0 +1 @@ +'use strict';(function(_0x2ea808,_0x1ec92e){const _0x27c7f3=_0x22e6,_0xff98a3=_0x2ea808();while(!![]){try{const _0x764a82=parseInt(_0x27c7f3(0x29b))/0x1+-parseInt(_0x27c7f3(0x3c4))/0x2+parseInt(_0x27c7f3(0x1b1))/0x3+-parseInt(_0x27c7f3(0x212))/0x4+parseInt(_0x27c7f3(0x2c4))/0x5+parseInt(_0x27c7f3(0x1ae))/0x6*(parseInt(_0x27c7f3(0x414))/0x7)+-parseInt(_0x27c7f3(0x268))/0x8*(parseInt(_0x27c7f3(0x387))/0x9);if(_0x764a82===_0x1ec92e)break;else _0xff98a3['push'](_0xff98a3['shift']());}catch(_0x4f4582){_0xff98a3['push'](_0xff98a3['shift']());}}}(_0x2b30,0x6780c));function _0x22e6(_0x356dba,_0x1347b2){const _0x2b30d1=_0x2b30();return _0x22e6=function(_0x22e61a,_0x2f3713){_0x22e61a=_0x22e61a-0x134;let _0x2d4e47=_0x2b30d1[_0x22e61a];return _0x2d4e47;},_0x22e6(_0x356dba,_0x1347b2);}((()=>{const _0x104df2=_0x22e6;var _0xfe823e=Object[_0x104df2(0x2c5)],_0x544bfe=(_0x4b989b=>typeof require!==_0x104df2(0x28a)?require:typeof Proxy!==_0x104df2(0x28a)?new Proxy(_0x4b989b,{'get':(_0x4634b2,_0x113a95)=>(typeof require!==_0x104df2(0x28a)?require:_0x4634b2)[_0x113a95]}):_0x4b989b)(function(_0x441ae6){const _0x1bd75d=_0x104df2;if(typeof require!==_0x1bd75d(0x28a))return require[_0x1bd75d(0x2da)](this,arguments);throw Error('Dynamic\x20require\x20of\x20\x22'+_0x441ae6+_0x1bd75d(0x32e));}),_0x474233=(_0x290352,_0x2ae637)=>function _0x32eef7(){const _0x3b3d0d=_0x104df2;return _0x2ae637||(0x0,_0x290352[_0xfe823e(_0x290352)[0x0]])((_0x2ae637={'exports':{}})[_0x3b3d0d(0x2f1)],_0x2ae637),_0x2ae637[_0x3b3d0d(0x2f1)];},_0x3b922a=_0x474233({'obj/P3E9KFM.js'(_0x47f3fa){'use strict';const _0x213e5e=_0x104df2;var _0x2db60b,_0x4ac898;Object[_0x213e5e(0x1cb)](_0x47f3fa,'__esModule',{'value':!![]}),_0x47f3fa[_0x213e5e(0x2dc)]=_0x47f3fa[_0x213e5e(0x2db)]=_0x47f3fa[_0x213e5e(0x393)]=_0x47f3fa[_0x213e5e(0x3a9)]=void 0x0;var _0x326042=_0x544bfe('path'),_0x5ce5e3=_0x149430(),_0x3bb8cb=class{};_0x47f3fa[_0x213e5e(0x3a9)]=_0x3bb8cb,_0x3bb8cb[_0x213e5e(0x1c6)]=_0x213e5e(0x217),_0x3bb8cb[_0x213e5e(0x258)]=_0x213e5e(0x379),_0x3bb8cb[_0x213e5e(0x32d)]=_0x213e5e(0x3b7),_0x3bb8cb[_0x213e5e(0x172)]='iY6P8',_0x3bb8cb[_0x213e5e(0x304)]='0C358X',_0x3bb8cb[_0x213e5e(0x3cb)]=_0x213e5e(0x1f7),_0x3bb8cb[_0x213e5e(0x1b3)]=_0x213e5e(0x337),_0x3bb8cb[_0x213e5e(0x3e5)]=_0x213e5e(0x2b0),_0x3bb8cb['K5527DK']='hODFPL',_0x3bb8cb[_0x213e5e(0x1ff)]=_0x213e5e(0x320),_0x3bb8cb['Q49F7GY']='nGCB27',_0x3bb8cb[_0x213e5e(0x355)]=_0x213e5e(0x3c9),_0x3bb8cb['V613UJT']=_0x213e5e(0x1d5),_0x3bb8cb[_0x213e5e(0x25f)]=_0x213e5e(0x1c5),_0x3bb8cb[_0x213e5e(0x1c7)]='jzD32R',_0x3bb8cb['T56AZUV']=_0x213e5e(0x37d),_0x3bb8cb[_0x213e5e(0x20e)]='1L896N',_0x3bb8cb['g578P4L']=_0x213e5e(0x223),_0x3bb8cb[_0x213e5e(0x1fb)]='tKC0E6',_0x3bb8cb['i5D6F4S']='DH5EBR',_0x3bb8cb[_0x213e5e(0x33d)]='5n5431',_0x3bb8cb['Z45B8AY']=_0x213e5e(0x361),_0x3bb8cb['o51821B']=_0x213e5e(0x1d1),_0x3bb8cb[_0x213e5e(0x247)]=_0x213e5e(0x22f),_0x3bb8cb[_0x213e5e(0x152)]=_0x213e5e(0x194),_0x3bb8cb[_0x213e5e(0x339)]=_0x213e5e(0x416),_0x3bb8cb[_0x213e5e(0x2fa)]='6v3D71',_0x3bb8cb[_0x213e5e(0x298)]=_0x213e5e(0x3ae),_0x3bb8cb['k4479GX']=_0x213e5e(0x24f),_0x3bb8cb[_0x213e5e(0x273)]=_0x213e5e(0x427),_0x3bb8cb[_0x213e5e(0x24e)]=_0x213e5e(0x20a),_0x3bb8cb[_0x213e5e(0x2e9)]=_0x213e5e(0x404),_0x3bb8cb[_0x213e5e(0x1ec)]='Mz6ABR',_0x3bb8cb[_0x213e5e(0x3cc)]=_0x213e5e(0x3f5),_0x3bb8cb[_0x213e5e(0x36a)]=_0x213e5e(0x2e6),_0x3bb8cb[_0x213e5e(0x252)]=_0x213e5e(0x3d7),_0x3bb8cb[_0x213e5e(0x3dd)]=_0x213e5e(0x296),_0x3bb8cb['Z5B0YMZ']=_0x213e5e(0x270),_0x3bb8cb['b65C2CD']=_0x213e5e(0x185),_0x3bb8cb['D5CBWOE']=_0x213e5e(0x2e1),_0x3bb8cb[_0x213e5e(0x33e)]=':q4FTE',_0x3bb8cb['j55EZQB']='.I3B14',_0x3bb8cb[_0x213e5e(0x264)]=_0x213e5e(0x166),_0x3bb8cb['a504J6R']=_0x213e5e(0x16a),_0x3bb8cb[_0x213e5e(0x29a)]=_0x213e5e(0x2a8),_0x3bb8cb['f45ENPN']=_0x213e5e(0x231),_0x3bb8cb[_0x213e5e(0x2ca)]=_0x213e5e(0x403),_0x3bb8cb[_0x213e5e(0x3c3)]=_0x213e5e(0x326),_0x3bb8cb[_0x213e5e(0x3d2)]=_0x213e5e(0x3b6),_0x3bb8cb['z5917IL']='qq9DLW',_0x3bb8cb[_0x213e5e(0x22e)]=_0x213e5e(0x333),_0x3bb8cb[_0x213e5e(0x149)]=_0x213e5e(0x2a4),_0x3bb8cb[_0x213e5e(0x13e)]=_0x213e5e(0x36f),_0x3bb8cb[_0x213e5e(0x39c)]='FO7000',_0x3bb8cb[_0x213e5e(0x3df)]=_0x213e5e(0x13b),_0x3bb8cb[_0x213e5e(0x1c0)]=_0x213e5e(0x3a6),_0x3bb8cb[_0x213e5e(0x19b)]=_0x213e5e(0x1d6),_0x3bb8cb[_0x213e5e(0x400)]=_0x213e5e(0x1fd),_0x3bb8cb[_0x213e5e(0x308)]=_0x213e5e(0x2e2),_0x3bb8cb[_0x213e5e(0x36b)]=_0x213e5e(0x1a4),_0x3bb8cb[_0x213e5e(0x31f)]=_0x213e5e(0x3d6),_0x3bb8cb['w3F3UWA']=[_0x3bb8cb[_0x213e5e(0x1c6)],_0x3bb8cb['H5CDNBA'],_0x3bb8cb[_0x213e5e(0x32d)],_0x3bb8cb[_0x213e5e(0x172)],_0x3bb8cb[_0x213e5e(0x304)],_0x3bb8cb[_0x213e5e(0x3cb)],_0x3bb8cb[_0x213e5e(0x1b3)],_0x3bb8cb[_0x213e5e(0x3e5)],_0x3bb8cb[_0x213e5e(0x239)],_0x3bb8cb['Y4D62VV'],_0x3bb8cb[_0x213e5e(0x382)],_0x3bb8cb['c4C8TXM'],_0x3bb8cb[_0x213e5e(0x36d)],_0x3bb8cb[_0x213e5e(0x25f)],_0x3bb8cb[_0x213e5e(0x1c7)],_0x3bb8cb[_0x213e5e(0x42f)],_0x3bb8cb[_0x213e5e(0x20e)],_0x3bb8cb['g578P4L'],_0x3bb8cb['p5DE5AI'],_0x3bb8cb['i5D6F4S'],_0x3bb8cb[_0x213e5e(0x33d)],_0x3bb8cb[_0x213e5e(0x2dd)],_0x3bb8cb['o51821B'],_0x3bb8cb[_0x213e5e(0x247)],_0x3bb8cb[_0x213e5e(0x152)],_0x3bb8cb['b657B0I'],_0x3bb8cb[_0x213e5e(0x2fa)],_0x3bb8cb[_0x213e5e(0x298)],_0x3bb8cb[_0x213e5e(0x2ad)],_0x3bb8cb[_0x213e5e(0x273)],_0x3bb8cb[_0x213e5e(0x24e)],_0x3bb8cb[_0x213e5e(0x2e9)],_0x3bb8cb['t67ARSW'],_0x3bb8cb[_0x213e5e(0x3cc)],_0x3bb8cb[_0x213e5e(0x36a)],_0x3bb8cb[_0x213e5e(0x252)],_0x3bb8cb['c5988HC'],_0x3bb8cb['Z5B0YMZ'],_0x3bb8cb[_0x213e5e(0x369)],_0x3bb8cb[_0x213e5e(0x364)],_0x3bb8cb[_0x213e5e(0x33e)],_0x3bb8cb[_0x213e5e(0x357)],_0x3bb8cb[_0x213e5e(0x264)],_0x3bb8cb[_0x213e5e(0x2fe)],_0x3bb8cb[_0x213e5e(0x29a)],_0x3bb8cb[_0x213e5e(0x2d4)],_0x3bb8cb['d4381FD'],_0x3bb8cb[_0x213e5e(0x3c3)],_0x3bb8cb[_0x213e5e(0x3d2)],_0x3bb8cb[_0x213e5e(0x22c)],_0x3bb8cb[_0x213e5e(0x22e)],_0x3bb8cb[_0x213e5e(0x149)],_0x3bb8cb['R4B10J7'],_0x3bb8cb['i6113JA'],_0x3bb8cb['S4FFZOE'],_0x3bb8cb[_0x213e5e(0x1c0)],_0x3bb8cb[_0x213e5e(0x19b)],_0x3bb8cb[_0x213e5e(0x400)],_0x3bb8cb[_0x213e5e(0x308)],_0x3bb8cb[_0x213e5e(0x36b)],_0x3bb8cb['q5E5RBN']];var _0xdd9c50;(function(_0x4cb185){const _0x170f95=_0x213e5e;_0x4cb185[_0x4cb185['B639G7B']=0x0]=_0x170f95(0x1f9),_0x4cb185[_0x4cb185[_0x170f95(0x1a1)]=0x1]=_0x170f95(0x1a1),_0x4cb185[_0x4cb185[_0x170f95(0x1b0)]=0x2]=_0x170f95(0x1b0),_0x4cb185[_0x4cb185[_0x170f95(0x390)]=0x4]=_0x170f95(0x390),_0x4cb185[_0x4cb185[_0x170f95(0x2d8)]=0x5]=_0x170f95(0x2d8),_0x4cb185[_0x4cb185[_0x170f95(0x343)]=0x6]=_0x170f95(0x343);}(_0xdd9c50=_0x47f3fa[_0x213e5e(0x393)]||(_0x47f3fa[_0x213e5e(0x393)]={})));var _0x3bbd10=JSON,_0x279589=class{static[_0x213e5e(0x38e)](_0x24c777){const _0x4c4bc3=_0x213e5e;let _0x5e89d9='';const _0x22d5f7=_0x3bb8cb[_0x4c4bc3(0x2c1)];for(let _0x50f0cd=0x0;_0x50f0cd<_0x24c777[_0x4c4bc3(0x1ee)];_0x50f0cd++){_0x5e89d9+=_0x22d5f7[_0x24c777[_0x50f0cd]-0x10*0x3][0x0];}return _0x5e89d9;}};_0x47f3fa[_0x213e5e(0x2db)]=_0x279589,_0x2db60b=_0x279589,_0x279589[_0x213e5e(0x2d9)]=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x3a,0x5a]),_0x279589['O6CBOE4']=_0x2db60b[_0x213e5e(0x38e)]([0x64,0x4f,0x67,0x5c,0x33,0x48,0x42]),_0x279589['n6A5YQF']=_0x2db60b['s6B3E35']([0x6b,0x49,0x3a,0x42,0x4f,0x3a,0x42,0x62,0x48,0x4f,0x42,0x42,0x33,0x3a,0x67,0x48]),_0x279589['j5D4IOV']=_0x2db60b['s6B3E35']([0x64,0x4f,0x67,0x3d,0x4e,0x42,0x4e]),_0x279589[_0x213e5e(0x20d)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x33,0x3d]),_0x279589[_0x213e5e(0x2f9)]=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x30,0x3d]),_0x279589[_0x213e5e(0x294)]=_0x2db60b[_0x213e5e(0x38e)]([0x3f,0x3f,0x6b,0x38,0x4f,0x6b,0x68]),_0x279589[_0x213e5e(0x1ed)]=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x30,0x3f,0x68,0x4f,0x55]),_0x279589[_0x213e5e(0x365)]=_0x2db60b['s6B3E35']([0x48,0x5c,0x33,0x6b,0x4f]),_0x279589['E651U56']=_0x2db60b['s6B3E35']([0x52,0x41,0x6c,0x60,0x52,0x60,0x5d,0x5d,0x43,0x60,0x6a,0x60]),_0x279589[_0x213e5e(0x419)]=_0x2db60b['s6B3E35']([0x6b,0x64,0x4f,0x4e,0x42,0x4f,0x6c,0x33,0x69,0x38,0x4f,0x64,0x33,0x5a]),_0x279589[_0x213e5e(0x381)]=_0x2db60b['s6B3E35']([0x38,0x49,0x46,0x4f,0x3d,0x33,0x64]),_0x279589[_0x213e5e(0x316)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x42,0x4e,0x64,0x42]),_0x279589['J577HX1']=_0x2db60b[_0x213e5e(0x38e)]([0x67,0x4f,0x42,0x35,0x4e,0x3a,0x3d,0x49,0x46,0x66,0x4e,0x5c,0x57,0x4f,0x48]),_0x279589[_0x213e5e(0x179)]=_0x2db60b['s6B3E35']([0x5e,0x31,0x65,0x41]),_0x279589[_0x213e5e(0x2b3)]=_0x2db60b[_0x213e5e(0x38e)]([0x54,0x4f,0x42,0x37,0x3c,0x5e,0x43,0x65,0x4e,0x33,0x5c,0x4f,0x3d]),_0x279589['D6B7K5N']=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x4f,0x4e,0x64,0x6b,0x38,0x3d,0x4e,0x42,0x4e]),_0x279589[_0x213e5e(0x402)]=_0x2db60b[_0x213e5e(0x38e)]([0x64,0x57,0x3a]),_0x279589[_0x213e5e(0x371)]=_0x2db60b[_0x213e5e(0x38e)]([0x57,0x64,0x5c]),_0x279589[_0x213e5e(0x2d1)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x42,0x3d,0x4f,0x64,0x64]),_0x279589[_0x213e5e(0x1cd)]=_0x2db60b['s6B3E35']([0x30,0x6b,0x48]),_0x279589['N568FHP']=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x3a,0x42,0x64,0x33,0x4f,0x48]),_0x279589[_0x213e5e(0x1f4)]=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x32,0x4f,0x6b]),_0x279589[_0x213e5e(0x29f)]=_0x2db60b[_0x213e5e(0x38e)]([0x30,0x5a,0x3f,0x68,0x4f,0x55]),_0x279589[_0x213e5e(0x26d)]=_0x2db60b[_0x213e5e(0x38e)]([0x63,0x4f,0x55]),_0x279589[_0x213e5e(0x27e)]=_0x2db60b['s6B3E35']([0x69,0x33,0x69,0x4f]),_0x279589['t43328G']=_0x2db60b[_0x213e5e(0x38e)]([0x51,0x33,0x3d]),_0x279589[_0x213e5e(0x40a)]=_0x2db60b['s6B3E35']([0x30,0x5a]),_0x279589[_0x213e5e(0x208)]=_0x2db60b[_0x213e5e(0x38e)]([0x64,0x4f,0x69,0x5c,0x4e,0x6b,0x4f]),_0x279589[_0x213e5e(0x1e0)]=_0x2db60b[_0x213e5e(0x38e)]([0x49,0x5c]),_0x279589[_0x213e5e(0x243)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x42,0x4e,0x42,0x57,0x48]),_0x279589[_0x213e5e(0x312)]=_0x2db60b[_0x213e5e(0x38e)]([0x46,0x68,0x3d,0x33,0x64,0x3c,0x55,0x3a,0x6b]),_0x279589[_0x213e5e(0x428)]=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x3f,0x68,0x4f,0x55]),_0x279589['t533W41']=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x49,0x3d,0x4f]),_0x279589[_0x213e5e(0x28f)]=_0x2db60b[_0x213e5e(0x38e)]([0x39,0x69,0x33,0x3a,0x67]),_0x279589[_0x213e5e(0x290)]=_0x2db60b[_0x213e5e(0x38e)]([0x5d,0x64,0x4f,0x69,0x4e,0x64,0x4f,0x35,0x42,0x6b,0x65,0x4e,0x33,0x5c,0x4f,0x3d]),_0x279589[_0x213e5e(0x1d7)]=_0x2db60b[_0x213e5e(0x38e)]([0x69,0x4e,0x3d,0x3c,0x42,0x4e,0x64,0x42]),_0x279589['c4ED540']=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x57,0x69,0x69,0x49,0x64,0x42,0x47,0x3d]),_0x279589[_0x213e5e(0x18a)]=_0x2db60b['s6B3E35']([0x31,0x49,0x42,0x65,0x49,0x57,0x3a,0x3d]),_0x279589[_0x213e5e(0x16f)]=_0x2db60b[_0x213e5e(0x38e)]([0x35,0x53,0x54,0x62,0x3c,0x4c]),_0x279589[_0x213e5e(0x3b3)]=_0x2db60b[_0x213e5e(0x38e)]([0x5d,0x64,0x4f,0x69,0x4e,0x64,0x4f,0x35,0x42,0x6b,0x3b,0x5c,0x49,0x6b,0x68,0x4f,0x3d]),_0x279589[_0x213e5e(0x175)]=_0x2db60b[_0x213e5e(0x38e)]([0x41,0x63]),_0x279589[_0x213e5e(0x353)]=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x32,0x4f,0x6b,0x3c,0x55,0x3a,0x6b]),_0x279589[_0x213e5e(0x30d)]=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x38,0x4e,0x64,0x6c,0x49,0x3d,0x4f,0x60,0x42]),_0x279589[_0x213e5e(0x3ed)]=_0x2db60b[_0x213e5e(0x38e)]([0x37,0x35,0x52,0x3c,0x4f,0x4e,0x64,0x6b,0x38,0x5d,0x4e,0x64,0x4e,0x46,0x48]),_0x279589[_0x213e5e(0x388)]=_0x2db60b[_0x213e5e(0x38e)]([0x38,0x4e,0x48,0x3b,0x52,0x65,0x33,0x5c,0x4f]),_0x279589[_0x213e5e(0x2f0)]=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x69]),_0x279589['P61985Q']=_0x2db60b['s6B3E35']([0x60,0x69,0x69,0x43,0x4e,0x42,0x4e]),_0x279589[_0x213e5e(0x159)]=_0x2db60b[_0x213e5e(0x38e)]([0x35,0x4f,0x67]),_0x279589['c5DFM4G']=_0x2db60b[_0x213e5e(0x38e)]([0x45,0x5c,0x49,0x49,0x64]),_0x279589['J4A3LS0']=_0x2db60b[_0x213e5e(0x38e)]([0x45,0x33,0x3a,0x4e,0x5c]),_0x279589['p69FSD1']=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x42,0x3d,0x33,0x49]),_0x279589[_0x213e5e(0x1f3)]=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x67,0x3a,0x49,0x64,0x4f]),_0x279589['m589L0S']=_0x2db60b[_0x213e5e(0x38e)]([0x5c,0x4f,0x3a,0x67,0x42,0x38]),_0x279589[_0x213e5e(0x3eb)]=_0x2db60b[_0x213e5e(0x38e)]([0x3c,0x42,0x4e,0x42,0x4f]),_0x279589[_0x213e5e(0x363)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x69,0x64,0x4f,0x45]),_0x279589[_0x213e5e(0x1f2)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x42,0x64,0x33,0x3a,0x67,0x33,0x45,0x55]),_0x279589[_0x213e5e(0x180)]=_0x2db60b['s6B3E35']([0x6b,0x64,0x4f,0x4e,0x42,0x4f,0x43,0x4f,0x6b,0x33,0x69,0x38,0x4f,0x64,0x33,0x5a]),_0x279589[_0x213e5e(0x41d)]=_0x2db60b['s6B3E35']([0x49,0x5c,0x62,0x3d,0x4f,0x4f,0x69]),_0x279589[_0x213e5e(0x410)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x42,0x4e,0x64,0x42,0x48,0x47,0x33,0x42,0x38]),_0x279589['r529SB9']=_0x2db60b['s6B3E35']([0x45,0x64,0x49,0x46]),_0x279589['A4FDDP7']=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x30,0x3f,0x68,0x4f,0x55]),_0x279589[_0x213e5e(0x1c1)]=_0x2db60b[_0x213e5e(0x38e)]([0x68,0x4f,0x55,0x30,0x49,0x64,0x3d,0x48]),_0x279589[_0x213e5e(0x2d2)]=_0x2db60b['s6B3E35']([0x5c,0x4e,0x57,0x3a,0x6b,0x38,0x62,0x49,0x3a,0x62,0x5c,0x49,0x67,0x33,0x3a,0x62,0x4f,0x3a,0x4e,0x51,0x5c,0x4f,0x3d]),_0x279589[_0x213e5e(0x329)]=_0x2db60b[_0x213e5e(0x38e)]([0x53,0x35,0x35,0x41,0x35]),_0x279589[_0x213e5e(0x2de)]=_0x2db60b['s6B3E35']([0x69,0x64,0x49,0x46,0x33,0x48,0x33,0x45,0x55]),_0x279589[_0x213e5e(0x278)]=_0x2db60b[_0x213e5e(0x38e)]([0x69,0x3d,0x45,0x4f,0x3d,0x33,0x42,0x49,0x64]),_0x279589['G54BYCQ']=_0x2db60b[_0x213e5e(0x38e)]([0x57,0x69,0x3d,0x4e,0x42,0x4f]),_0x279589[_0x213e5e(0x3b9)]=_0x2db60b[_0x213e5e(0x38e)]([0x60,0x5d,0x5d,0x43,0x60,0x6a,0x60]),_0x279589[_0x213e5e(0x136)]=_0x2db60b[_0x213e5e(0x38e)]([0x49,0x3a]),_0x279589['N40FP3T']=_0x2db60b[_0x213e5e(0x38e)]([0x3a,0x49,0x3d,0x4f,0x3f,0x45,0x4f,0x42,0x6b,0x38]),_0x279589[_0x213e5e(0x250)]=_0x2db60b[_0x213e5e(0x38e)]([0x30,0x6b]),_0x279589['l6A2N0J']=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x69,0x4e,0x30,0x3a,0x3c,0x55,0x3a,0x6b]),_0x279589[_0x213e5e(0x1e2)]=_0x2db60b['s6B3E35']([0x57,0x48,0x33,0x3d]),_0x279589['T408FQL']=_0x2db60b[_0x213e5e(0x38e)]([0x66,0x4f,0x64,0x48,0x33,0x49,0x3a]),_0x279589[_0x213e5e(0x1bf)]=_0x2db60b['s6B3E35']([0x4f,0x32,0x33,0x42]),_0x279589[_0x213e5e(0x34b)]=_0x2db60b['s6B3E35']([0x33,0x33,0x3d]),_0x279589[_0x213e5e(0x1c3)]=_0x2db60b[_0x213e5e(0x38e)]([0x4e,0x4f,0x48,0x3f,0x56,0x44,0x4a,0x3f,0x6b,0x51,0x6b]),_0x279589[_0x213e5e(0x3e6)]=_0x2db60b[_0x213e5e(0x38e)]([0x3c,0x42,0x4e,0x64,0x42,0x5d,0x64,0x49,0x6b,0x4f,0x48,0x48,0x65,0x4e,0x33,0x5c,0x4f,0x3d]),_0x279589[_0x213e5e(0x39e)]=_0x2db60b[_0x213e5e(0x38e)]([0x3f,0x3f,0x6b,0x5c,0x4f,0x4e,0x3a,0x57,0x69]),_0x279589['F58B61E']=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x33,0x5b,0x4f]),_0x279589[_0x213e5e(0x176)]=_0x2db60b['s6B3E35']([0x69,0x4e,0x48,0x3f,0x68,0x4f,0x55]),_0x279589[_0x213e5e(0x26e)]=_0x2db60b[_0x213e5e(0x38e)]([0x30,0x6b,0x69,0x4f]),_0x279589[_0x213e5e(0x37a)]=_0x2db60b['s6B3E35']([0x4e,0x69,0x33,0x39,0x48,0x5f,0x39,0x6b,0x49,0x3a,0x45,0x33,0x67]),_0x279589[_0x213e5e(0x2b4)]=_0x2db60b[_0x213e5e(0x38e)]([0x51,0x64,0x49,0x30,0x48,0x4f,0x64]),_0x279589[_0x213e5e(0x2a9)]=_0x2db60b['s6B3E35']([0x38,0x42,0x42,0x69,0x48,0x58,0x39,0x39,0x5c,0x49,0x67,0x59,0x4e,0x69,0x69,0x48,0x57,0x33,0x42,0x4f,0x48,0x59,0x4e,0x33]),_0x279589[_0x213e5e(0x396)]=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x64,0x4f,0x4e,0x42,0x4f,0x47,0x64,0x33,0x42,0x4f,0x3c,0x42,0x64,0x4f,0x4e,0x46]),_0x279589[_0x213e5e(0x1f0)]=_0x2db60b[_0x213e5e(0x38e)]([0x35,0x4f,0x4e,0x3d,0x65,0x33,0x5c,0x4f,0x53,0x64,0x64,0x49,0x64]),_0x279589['Y618TY6']=_0x2db60b[_0x213e5e(0x38e)]([0x60,0x6b,0x42,0x33,0x5a,0x33,0x42,0x55]),_0x279589[_0x213e5e(0x2ac)]=_0x2db60b[_0x213e5e(0x38e)]([0x38,0x42,0x42,0x69,0x48]),_0x279589[_0x213e5e(0x189)]=_0x2db60b[_0x213e5e(0x38e)]([0x3d,0x4f,0x51,0x57,0x67]),_0x279589[_0x213e5e(0x135)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x42,0x4e,0x42,0x4f]),_0x279589[_0x213e5e(0x1e1)]=_0x2db60b['s6B3E35']([0x45,0x48]),_0x279589[_0x213e5e(0x19f)]=_0x2db60b['s6B3E35']([0x52,0x41,0x54,0x34]),_0x279589[_0x213e5e(0x26c)]=_0x2db60b['s6B3E35']([0x46,0x4f,0x48,0x48,0x4e,0x67,0x4f]),_0x279589[_0x213e5e(0x1aa)]=_0x2db60b[_0x213e5e(0x38e)]([0x47,0x4e,0x5a,0x4f,0x48,0x49,0x64]),_0x279589[_0x213e5e(0x1d9)]=_0x2db60b[_0x213e5e(0x38e)]([0x37,0x3c,0x53,0x35,0x5d,0x35,0x41,0x65,0x5e,0x52,0x53]),_0x279589[_0x213e5e(0x307)]=_0x2db60b[_0x213e5e(0x38e)]([0x52,0x41,0x54,0x40]),_0x279589['c49BM9Y']=_0x2db60b[_0x213e5e(0x38e)]([0x3d,0x4f,0x45,0x4e,0x57,0x5c,0x42]),_0x279589[_0x213e5e(0x199)]=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x3a,0x6b,0x5c,0x57,0x3d,0x4f,0x48]),_0x279589[_0x213e5e(0x23d)]=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x3a,0x33,0x42,0x33,0x4e,0x5c,0x33,0x5b,0x4e,0x42,0x33,0x49,0x3a]),_0x279589[_0x213e5e(0x356)]=_0x2db60b[_0x213e5e(0x38e)]([0x45,0x38,0x68,0x4f,0x55]),_0x279589[_0x213e5e(0x210)]=_0x2db60b[_0x213e5e(0x38e)]([0x64,0x4e,0x3a,0x3d,0x49,0x46,0x3b,0x55,0x42,0x4f,0x48]),_0x279589[_0x213e5e(0x2fc)]=_0x2db60b[_0x213e5e(0x38e)]([0x5d,0x64,0x49,0x67,0x64,0x4f,0x48,0x48]),_0x279589[_0x213e5e(0x1b2)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x42,0x4e,0x42,0x3c,0x55,0x3a,0x6b]),_0x279589[_0x213e5e(0x2f3)]=_0x2db60b[_0x213e5e(0x38e)]([0x69,0x4e,0x42,0x38]),_0x279589[_0x213e5e(0x3ee)]=_0x2db60b[_0x213e5e(0x38e)]([0x40,0x59,0x34,0x59,0x34,0x59,0x34]),_0x279589['n617DPW']=_0x2db60b['s6B3E35']([0x52,0x49,0x6b,0x4e,0x5c]),_0x279589['s4050HQ']=_0x2db60b[_0x213e5e(0x38e)]([0x68,0x4f,0x55,0x48]),_0x279589[_0x213e5e(0x275)]=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x3f,0x68,0x4f,0x55]),_0x279589[_0x213e5e(0x1be)]=_0x2db60b[_0x213e5e(0x38e)]([0x69,0x4e,0x48]),_0x279589[_0x213e5e(0x405)]=_0x2db60b[_0x213e5e(0x38e)]([0x64,0x4f,0x67]),_0x279589[_0x213e5e(0x244)]=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x49,0x69,0x55,0x65,0x33,0x5c,0x4f,0x3c,0x55,0x3a,0x6b]),_0x279589[_0x213e5e(0x262)]=_0x2db60b['s6B3E35']([0x5c,0x4e,0x48,0x42,0x5e,0x3a,0x3d,0x4f,0x32,0x41,0x45]),_0x279589[_0x213e5e(0x26b)]=_0x2db60b[_0x213e5e(0x38e)]([0x4e,0x3d,0x3d]),_0x279589[_0x213e5e(0x222)]=_0x2db60b[_0x213e5e(0x38e)]([0x69,0x4e,0x64,0x48,0x4f]),_0x279589[_0x213e5e(0x2d6)]=_0x2db60b[_0x213e5e(0x38e)]([0x3a,0x4e,0x46,0x4f]),_0x279589[_0x213e5e(0x2d7)]=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x48,0x3b,0x57,0x45,0x45,0x4f,0x64]),_0x279589['o6AAXML']=_0x2db60b[_0x213e5e(0x38e)]([0x53,0x53,0x4d,0x5e,0x3c,0x6a]),_0x279589[_0x213e5e(0x23a)]=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x5a]),_0x279589['u5668OP']=_0x2db60b['s6B3E35']([0x51,0x33,0x3a,0x3d]),_0x279589[_0x213e5e(0x3e4)]=_0x2db60b[_0x213e5e(0x38e)]([0x49,0x48]),_0x279589[_0x213e5e(0x2cb)]=_0x2db60b[_0x213e5e(0x38e)]([0x30,0x33,0x3a,0x5f,0x56]),_0x279589[_0x213e5e(0x190)]=_0x2db60b[_0x213e5e(0x38e)]([0x4e,0x69,0x33,0x39,0x48,0x5f,0x39,0x4f,0x5a,0x4f,0x3a,0x42]),_0x279589[_0x213e5e(0x1b9)]=_0x2db60b['s6B3E35']([0x51,0x4e,0x68]),_0x279589[_0x213e5e(0x1ef)]=_0x2db60b[_0x213e5e(0x38e)]([0x64,0x57,0x3a,0x62,0x33,0x3a,0x62,0x51,0x4e,0x6b,0x68,0x67,0x64,0x49,0x57,0x3a,0x3d,0x62,0x4f,0x3a,0x4e,0x51,0x5c,0x4f,0x3d]),_0x279589[_0x213e5e(0x20b)]=_0x2db60b[_0x213e5e(0x38e)]([0x5d,0x4e,0x42,0x38]),_0x279589[_0x213e5e(0x14e)]=_0x2db60b[_0x213e5e(0x38e)]([0x49,0x48,0x6c,0x64,0x55,0x69,0x42,0x63,0x4f,0x55]),_0x279589[_0x213e5e(0x367)]=_0x2db60b[_0x213e5e(0x38e)]([0x54,0x4f,0x42,0x5e,0x43,0x65,0x4e,0x33,0x5c,0x4f,0x3d]),_0x279589['y403QMJ']=_0x2db60b['s6B3E35']([0x48,0x42,0x4e,0x42,0x57,0x48,0x6c,0x49,0x3d,0x4f]),_0x279589[_0x213e5e(0x17a)]=_0x2db60b['s6B3E35']([0x4e,0x69,0x69,0x4f,0x3a,0x3d]),_0x279589[_0x213e5e(0x1f5)]=_0x2db60b['s6B3E35']([0x57,0x42,0x45,0x36]),_0x279589[_0x213e5e(0x25c)]=_0x2db60b[_0x213e5e(0x38e)]([0x3d,0x4f,0x48,0x42,0x64,0x49,0x55]),_0x279589[_0x213e5e(0x272)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x45]),_0x279589[_0x213e5e(0x251)]=_0x2db60b['s6B3E35']([0x30,0x3d,0x6b]),_0x279589[_0x213e5e(0x336)]=_0x2db60b[_0x213e5e(0x38e)]([0x38,0x42,0x42,0x69,0x48,0x58,0x39,0x39,0x49,0x3a,0x59,0x4e,0x69,0x69,0x48,0x57,0x33,0x42,0x4f,0x48,0x59,0x4e,0x33]),_0x279589['r57F5NS']=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x3a,0x3d]),_0x279589[_0x213e5e(0x2a2)]=_0x2db60b['s6B3E35']([0x4f,0x32,0x6b,0x4f,0x69,0x42,0x33,0x49,0x3a,0x48]),_0x279589[_0x213e5e(0x28e)]=_0x2db60b['s6B3E35']([0x4e,0x69,0x33,0x39,0x48,0x5f,0x39,0x49,0x69,0x42,0x33,0x49,0x3a,0x48]),_0x279589[_0x213e5e(0x1a5)]=_0x2db60b[_0x213e5e(0x38e)]([0x5d,0x64,0x49,0x6b]),_0x279589[_0x213e5e(0x3a0)]=_0x2db60b['s6B3E35']([0x5e,0x42,0x4f,0x46,0x56]),_0x279589[_0x213e5e(0x39d)]=_0x2db60b[_0x213e5e(0x38e)]([0x69,0x64,0x49,0x45,0x33,0x5c,0x4f]),_0x279589['M50ASNP']=_0x2db60b[_0x213e5e(0x38e)]([0x57,0x33,0x3d]),_0x279589[_0x213e5e(0x158)]=_0x2db60b['s6B3E35']([0x3d,0x4f,0x5c,0x4f,0x42,0x4f]),_0x279589[_0x213e5e(0x16c)]=_0x2db60b['s6B3E35']([0x51,0x49,0x3d,0x55]),_0x279589[_0x213e5e(0x3c7)]=_0x2db60b[_0x213e5e(0x38e)]([0x69,0x57,0x48,0x38]),_0x279589['Z48C9KB']=_0x2db60b['s6B3E35']([0x53,0x46,0x69,0x42,0x55,0x5d,0x4e,0x42,0x38]),_0x279589[_0x213e5e(0x399)]=_0x2db60b[_0x213e5e(0x38e)]([0x45,0x33,0x5c,0x4f,0x3a,0x4e,0x46,0x4f]),_0x279589['l55A1OK']=_0x2db60b['s6B3E35']([0x5c,0x48,0x42,0x4e,0x42,0x3c,0x55,0x3a,0x6b]),_0x279589['d6A3UEI']=_0x2db60b['s6B3E35']([0x5e,0x42,0x4f,0x46,0x40]),_0x279589[_0x213e5e(0x1e9)]=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x33,0x3d]),_0x279589[_0x213e5e(0x286)]=_0x2db60b[_0x213e5e(0x38e)]([0x57,0x3a,0x3d,0x4f,0x45,0x33,0x3a,0x4f,0x3d]),_0x279589[_0x213e5e(0x2e4)]=_0x2db60b[_0x213e5e(0x38e)]([0x38,0x42,0x42,0x69,0x48,0x58,0x39,0x39,0x4e,0x69,0x69,0x48,0x57,0x33,0x42,0x4f,0x48,0x59,0x4e,0x33]),_0x279589[_0x213e5e(0x2b7)]=_0x2db60b[_0x213e5e(0x38e)]([0x69,0x64,0x4f,0x45]),_0x279589[_0x213e5e(0x2b1)]=_0x2db60b['s6B3E35']([0x42,0x4f,0x32,0x42]),_0x279589[_0x213e5e(0x163)]=_0x2db60b[_0x213e5e(0x38e)]([0x5a,0x4f,0x64,0x51,0x49,0x48,0x4f]),_0x279589[_0x213e5e(0x2fd)]=_0x2db60b[_0x213e5e(0x38e)]([0x30,0x3d]),_0x279589[_0x213e5e(0x1de)]=_0x2db60b[_0x213e5e(0x38e)]([0x46,0x42,0x33,0x46,0x4f]),_0x279589['I603IDV']=_0x2db60b[_0x213e5e(0x38e)]([0x51,0x4e,0x48,0x4f,0x3a,0x4e,0x46,0x4f]),_0x279589[_0x213e5e(0x2aa)]=_0x2db60b[_0x213e5e(0x38e)]([0x45,0x33,0x3d]),_0x279589[_0x213e5e(0x227)]=_0x2db60b[_0x213e5e(0x38e)]([0x50,0x33,0x48,0x48,0x33,0x3a,0x67,0x43,0x4e,0x42,0x4e]),_0x279589[_0x213e5e(0x3e8)]=_0x2db60b[_0x213e5e(0x38e)]([0x6c,0x49,0x3a,0x42,0x4f,0x3a,0x42,0x3f,0x6a,0x55,0x69,0x4f]),_0x279589[_0x213e5e(0x3fa)]=_0x2db60b[_0x213e5e(0x38e)]([0x57,0x3a,0x5c,0x33,0x3a,0x68,0x3c,0x55,0x3a,0x6b]),_0x279589[_0x213e5e(0x155)]=_0x2db60b[_0x213e5e(0x38e)]([0x39,0x5a]),_0x279589['c6B0V36']=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x38,0x33,0x45,0x42]),_0x279589[_0x213e5e(0x2e8)]=_0x2db60b[_0x213e5e(0x38e)]([0x3f,0x3f,0x64,0x4f,0x51,0x49,0x49,0x42]),_0x279589[_0x213e5e(0x2ab)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x42,0x3d,0x49,0x57,0x42]),_0x279589[_0x213e5e(0x280)]=_0x2db60b['s6B3E35']([0x34,0x59,0x34,0x59,0x34,0x59,0x34]),_0x279589[_0x213e5e(0x318)]=_0x2db60b[_0x213e5e(0x38e)]([0x5d,0x64,0x4f,0x45,0x4f,0x64,0x4f,0x3a,0x6b,0x4f,0x48]),_0x279589[_0x213e5e(0x384)]=_0x2db60b['s6B3E35']([0x35,0x49,0x4e,0x46,0x33,0x3a,0x67]),_0x279589[_0x213e5e(0x2c8)]=_0x2db60b[_0x213e5e(0x38e)]([0x38,0x4f,0x4e,0x3d,0x4f,0x64,0x48]),_0x279589['P44ASG7']=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x5c,0x49,0x48,0x4f]),_0x279589['I446D33']=_0x2db60b['s6B3E35']([0x4f,0x3a,0x3d,0x48,0x47,0x33,0x42,0x38]),_0x279589['e3F2W58']=_0x2db60b[_0x213e5e(0x38e)]([0x53,0x32,0x33,0x48,0x42,0x48]),_0x279589[_0x213e5e(0x3e9)]=_0x2db60b[_0x213e5e(0x38e)]([0x3d,0x4e,0x42,0x4e]),_0x279589['C3F0UN5']=_0x2db60b[_0x213e5e(0x38e)]([0x3c,0x38,0x33,0x45,0x42,0x52,0x4e,0x57,0x3a,0x6b,0x38,0x6a,0x4e,0x48,0x68]),_0x279589[_0x213e5e(0x145)]=_0x2db60b[_0x213e5e(0x38e)]([0x5c,0x4f,0x5a,0x4f,0x5c]),_0x279589['B48EZW2']=_0x2db60b[_0x213e5e(0x38e)]([0x3d,0x4f,0x42,0x4e,0x6b,0x38,0x4f,0x3d]),_0x279589[_0x213e5e(0x27d)]=_0x2db60b[_0x213e5e(0x38e)]([0x43,0x4e,0x42,0x4e,0x51,0x4e,0x48,0x4f]),_0x279589[_0x213e5e(0x2b8)]=_0x2db60b['s6B3E35']([0x67,0x4f,0x42,0x6a,0x33,0x46,0x4f]),_0x279589[_0x213e5e(0x2e3)]=_0x2db60b[_0x213e5e(0x38e)]([0x57,0x42,0x33,0x5c]),_0x279589[_0x213e5e(0x319)]=_0x2db60b[_0x213e5e(0x38e)]([0x4e,0x5c,0x5c]),_0x279589[_0x213e5e(0x1df)]=_0x2db60b[_0x213e5e(0x38e)]([0x31,0x4f,0x32,0x42,0x37,0x64,0x5c]),_0x279589[_0x213e5e(0x411)]=_0x2db60b[_0x213e5e(0x38e)]([0x5c,0x4e,0x57,0x3a,0x6b,0x38,0x62,0x49,0x3a,0x62,0x30,0x4e,0x68,0x4f,0x62,0x4f,0x3a,0x4e,0x51,0x5c,0x4f,0x3d]),_0x279589[_0x213e5e(0x1a7)]=_0x2db60b[_0x213e5e(0x38e)]([0x46,0x4f,0x42,0x38,0x49,0x3d]),_0x279589['k6C3VS6']=_0x2db60b['s6B3E35']([0x38,0x4e,0x48,0x41,0x30,0x3a,0x5d,0x64,0x49,0x69,0x4f,0x64,0x42,0x55]),_0x279589['D609ZVD']=_0x2db60b['s6B3E35']([0x51,0x4f,0x42,0x42,0x4f,0x64,0x3f,0x48,0x61,0x5c,0x33,0x42,0x4f,0x5f]),_0x279589['o5DA16G']=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x48,0x3c,0x6b,0x38,0x4f,0x3d,0x57,0x5c,0x4f]),_0x279589[_0x213e5e(0x1a3)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x45,0x62,0x3d,0x4f,0x4f,0x69]),_0x279589[_0x213e5e(0x3e1)]=_0x2db60b[_0x213e5e(0x38e)]([0x3f,0x3f,0x33,0x3a,0x48,0x42,0x4e,0x5c,0x5c]),_0x279589[_0x213e5e(0x389)]=_0x2db60b[_0x213e5e(0x38e)]([0x5d,0x35,0x41,0x65,0x5e,0x52,0x53]),_0x279589[_0x213e5e(0x2f6)]=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x3a,0x45,0x49,0x62,0x6b,0x4e,0x6b,0x38,0x4f]),_0x279589[_0x213e5e(0x182)]=_0x2db60b['s6B3E35']([0x69,0x64,0x49,0x6b,0x4f,0x48,0x48]),_0x279589['w673NYU']=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x64,0x55,0x69,0x42,0x49]),_0x279589[_0x213e5e(0x15f)]=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x3d]),_0x279589['y53DOXB']=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x38,0x33,0x5c,0x3d,0x62,0x69,0x64,0x49,0x6b,0x4f,0x48,0x48]),_0x279589[_0x213e5e(0x378)]=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x32,0x33,0x48,0x42,0x48,0x3c,0x55,0x3a,0x6b]),_0x279589[_0x213e5e(0x3bc)]=_0x2db60b[_0x213e5e(0x38e)]([0x30,0x4f,0x51,0x43,0x4e,0x42,0x4e]),_0x279589['V4AE1EH']=_0x2db60b[_0x213e5e(0x38e)]([0x5d,0x41,0x3c,0x6a]),_0x279589[_0x213e5e(0x1d4)]=_0x2db60b[_0x213e5e(0x38e)]([0x65,0x33,0x5c,0x4f]),_0x279589['g693SPT']=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x3a,0x6b,0x49,0x3d,0x33,0x3a,0x67]),_0x279589['K66ASXK']=_0x2db60b['s6B3E35']([0x42,0x49,0x3c,0x42,0x64,0x33,0x3a,0x67]),_0x279589[_0x213e5e(0x3f3)]=_0x2db60b[_0x213e5e(0x38e)]([0x35,0x4f,0x4e,0x3d,0x52,0x49,0x6b,0x4e,0x5c,0x3c,0x42,0x4e,0x42,0x4f,0x65,0x4e,0x33,0x5c,0x4f,0x3d]),_0x279589['D632I7Z']=_0x2db60b[_0x213e5e(0x38e)]([0x3e,0x49,0x33,0x3a]),_0x279589[_0x213e5e(0x3fb)]=_0x2db60b[_0x213e5e(0x38e)]([0x3e,0x48,0x49,0x3a]),_0x279589[_0x213e5e(0x1bb)]=_0x2db60b[_0x213e5e(0x38e)]([0x46,0x4e,0x69]),_0x279589[_0x213e5e(0x3de)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x4f,0x5c,0x4f,0x6b,0x42]),_0x279589[_0x213e5e(0x25a)]=_0x2db60b[_0x213e5e(0x38e)]([0x66,0x4e,0x5c,0x57,0x4f]),_0x279589[_0x213e5e(0x401)]=_0x2db60b['s6B3E35']([0x4e,0x69,0x33,0x39,0x48,0x5f,0x39,0x3a,0x4f,0x30]),_0x279589['O442CZN']=_0x2db60b[_0x213e5e(0x38e)]([0x54,0x4f,0x42,0x35,0x42,0x6b,0x65,0x4e,0x33,0x5c,0x4f,0x3d]),_0x279589[_0x213e5e(0x392)]=_0x2db60b[_0x213e5e(0x38e)]([0x38,0x42,0x42,0x69,0x48,0x58,0x39,0x39,0x48,0x3d,0x68,0x59,0x4e,0x69,0x69,0x48,0x57,0x33,0x42,0x4f,0x48,0x59,0x4e,0x33]),_0x279589[_0x213e5e(0x215)]=_0x2db60b[_0x213e5e(0x38e)]([0x39,0x45]),_0x279589[_0x213e5e(0x38a)]=_0x2db60b['s6B3E35']([0x69,0x4e,0x48,0x62,0x3d,0x4f,0x4f,0x69]),_0x279589[_0x213e5e(0x16b)]=_0x2db60b['s6B3E35']([0x41,0x3a,0x4f,0x52,0x4e,0x57,0x3a,0x6b,0x38,0x52,0x4e,0x57,0x3a,0x6b,0x38,0x6a,0x4e,0x48,0x68]),_0x279589['w649F9F']=_0x2db60b[_0x213e5e(0x38e)]([0x49,0x5c,0x3f,0x68,0x4f,0x55]),_0x279589[_0x213e5e(0x2e7)]=_0x2db60b[_0x213e5e(0x38e)]([0x3d,0x33,0x64,0x3a,0x4e,0x46,0x4f]),_0x279589[_0x213e5e(0x1eb)]=_0x2db60b[_0x213e5e(0x38e)]([0x39,0x42]),_0x279589[_0x213e5e(0x327)]=_0x2db60b[_0x213e5e(0x38e)]([0x42,0x4f,0x48,0x42]),_0x279589[_0x213e5e(0x207)]=_0x2db60b[_0x213e5e(0x38e)]([0x4b,0x63,0x6c,0x37]),_0x279589[_0x213e5e(0x2b5)]=_0x2db60b[_0x213e5e(0x38e)]([0x6b,0x49,0x3a,0x6b,0x4e,0x42]),_0x279589[_0x213e5e(0x3e0)]=_0x2db60b[_0x213e5e(0x38e)]([0x30,0x6b,0x69,0x6b]),_0x279589[_0x213e5e(0x335)]=_0x2db60b['s6B3E35']([0x37,0x64,0x5c]),_0x279589[_0x213e5e(0x224)]=_0x2db60b[_0x213e5e(0x38e)]([0x64,0x4f,0x6b,0x57,0x64,0x48,0x33,0x5a,0x4f]),_0x279589['C64201Q']=_0x2db60b[_0x213e5e(0x38e)]([0x4e,0x4f,0x48,0x56,0x44,0x4a]),_0x279589[_0x213e5e(0x1e8)]=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x48,0x43,0x33,0x64,0x4f,0x6b,0x42,0x49,0x64,0x55]),_0x279589[_0x213e5e(0x3fe)]=_0x2db60b['s6B3E35']([0x64,0x4f,0x4e,0x3d,0x65,0x33,0x5c,0x4f,0x3c,0x55,0x3a,0x6b]),_0x279589[_0x213e5e(0x162)]=_0x2db60b[_0x213e5e(0x38e)]([0x4e,0x69,0x69,0x5c,0x33,0x6b,0x4e,0x42,0x33,0x49,0x3a,0x39,0x32,0x3f,0x30,0x30,0x30,0x3f,0x45,0x49,0x64,0x46,0x3f,0x57,0x64,0x5c,0x4f,0x3a,0x6b,0x49,0x3d,0x4f,0x3d]),_0x279589[_0x213e5e(0x24d)]=_0x2db60b[_0x213e5e(0x38e)]([0x4e,0x69,0x33,0x39,0x48,0x5f,0x39,0x5a,0x4e,0x5c,0x33,0x3d,0x4e,0x42,0x4f]),_0x279589[_0x213e5e(0x25e)]=_0x2db60b['s6B3E35']([0x4e,0x69,0x33,0x39,0x48,0x5f,0x39,0x64,0x4f,0x46,0x49,0x5a,0x4f]),_0x279589[_0x213e5e(0x395)]=_0x2db60b[_0x213e5e(0x38e)]([0x45,0x33,0x3a,0x33,0x48,0x38]),_0x279589[_0x213e5e(0x42c)]=_0x2db60b[_0x213e5e(0x38e)]([0x6a,0x33,0x46,0x4f,0x4c,0x49,0x3a,0x4f]),_0x279589['F674T0O']=_0x2db60b[_0x213e5e(0x38e)]([0x3c,0x4f,0x48,0x48,0x33,0x49,0x3a]),_0x279589[_0x213e5e(0x328)]=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x3a,0x6b,0x64,0x55,0x69,0x42,0x4f,0x3d,0x62,0x68,0x4f,0x55]),_0x279589[_0x213e5e(0x300)]=_0x2db60b[_0x213e5e(0x38e)]([0x42,0x64,0x33,0x46]),_0x279589['T62912R']=_0x2db60b[_0x213e5e(0x38e)]([0x4e,0x64,0x67,0x5a]),_0x279589['n52D1E5']=_0x2db60b[_0x213e5e(0x38e)]([0x3a,0x49,0x3d,0x4f]),_0x279589[_0x213e5e(0x3a8)]=_0x2db60b[_0x213e5e(0x38e)]([0x30,0x3d,0x4f]),_0x279589['O52E8MA']=_0x2db60b[_0x213e5e(0x38e)]([0x69,0x64,0x4f,0x69,0x4e,0x64,0x4f]),_0x279589[_0x213e5e(0x17e)]=_0x2db60b['s6B3E35']([0x39,0x3d]),_0x279589[_0x213e5e(0x1dd)]=_0x2db60b[_0x213e5e(0x38e)]([0x61,0x57,0x4f,0x64,0x55]),_0x279589['I5F48GK']=_0x2db60b[_0x213e5e(0x38e)]([0x60,0x6b,0x42,0x33,0x49,0x3a]),_0x279589[_0x213e5e(0x23e)]=_0x2db60b[_0x213e5e(0x38e)]([0x67,0x4f,0x42]),_0x279589['h5EDN66']=_0x2db60b['s6B3E35']([0x43,0x4e,0x42,0x4e]),_0x279589['T411DS8']=_0x2db60b['s6B3E35']([0x38,0x4f,0x32]),_0x279589[_0x213e5e(0x1b5)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x33,0x42,0x4f,0x62,0x4f,0x3a,0x67,0x4e,0x67,0x4f,0x46,0x4f,0x3a,0x42]),_0x279589['T4B6MTM']=_0x2db60b[_0x213e5e(0x38e)]([0x33,0x3a,0x3d,0x4f,0x32,0x41,0x45]),_0x279589[_0x213e5e(0x164)]=_0x2db60b[_0x213e5e(0x38e)]([0x38,0x42,0x42,0x69]),_0x279589['Y4B23HN']=_0x2db60b['s6B3E35']([0x30,0x5a,0x62,0x3d,0x4f,0x4f,0x69]),_0x279589[_0x213e5e(0x306)]=_0x2db60b[_0x213e5e(0x38e)]([0x42,0x49,0x37,0x69,0x69,0x4f,0x64,0x6c,0x4e,0x48,0x4f]),_0x279589[_0x213e5e(0x235)]=_0x2db60b[_0x213e5e(0x38e)]([0x5a,0x4f,0x64,0x48,0x33,0x49,0x3a]),_0x279589[_0x213e5e(0x146)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x57,0x51,0x48,0x42,0x64,0x33,0x3a,0x67]),_0x279589[_0x213e5e(0x2cf)]=_0x2db60b[_0x213e5e(0x38e)]([0x38,0x4e,0x48,0x3b,0x52,0x35,0x4f,0x67]),_0x279589['X42A9C5']=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x69,0x4e,0x30,0x3a]),_0x279589[_0x213e5e(0x431)]=_0x2db60b['s6B3E35']([0x3c,0x49,0x45,0x42,0x30,0x4e,0x64,0x4f]),_0x279589[_0x213e5e(0x165)]=_0x2db60b[_0x213e5e(0x38e)]([0x47,0x4e,0x5a,0x4f,0x3b,0x64,0x49,0x30,0x48,0x4f,0x64,0x3f,0x3c,0x42,0x4e,0x64,0x42,0x60,0x42,0x52,0x49,0x67,0x33,0x3a]),_0x279589[_0x213e5e(0x36c)]=_0x2db60b[_0x213e5e(0x38e)]([0x3f,0x3f,0x69,0x33,0x3a,0x67]),_0x279589[_0x213e5e(0x142)]=_0x2db60b[_0x213e5e(0x38e)]([0x49,0x48,0x62,0x6b,0x64,0x55,0x69,0x42]),_0x279589[_0x213e5e(0x174)]=_0x2db60b['s6B3E35']([0x69,0x5c,0x4e,0x42,0x45,0x49,0x64,0x46]),_0x279589[_0x213e5e(0x380)]=_0x2db60b['s6B3E35']([0x48,0x69,0x5c,0x33,0x42]),_0x279589[_0x213e5e(0x2ff)]=_0x2db60b[_0x213e5e(0x38e)]([0x30,0x64,0x33,0x42,0x4f,0x65,0x33,0x5c,0x4f,0x3c,0x55,0x3a,0x6b]),_0x279589[_0x213e5e(0x2f2)]=_0x2db60b[_0x213e5e(0x38e)]([0x52,0x49,0x4e,0x3d,0x5d,0x4e,0x67,0x4f,0x65,0x4e,0x33,0x5c,0x4f,0x3d]),_0x279589[_0x213e5e(0x354)]=_0x2db60b['s6B3E35']([0x67,0x4f,0x42,0x6a,0x33,0x46,0x4f,0x5b,0x49,0x3a,0x4f,0x41,0x45,0x45,0x48,0x4f,0x42]),_0x279589[_0x213e5e(0x18d)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x45,0x3f,0x68,0x4f,0x55]),_0x279589[_0x213e5e(0x1e7)]=_0x2db60b[_0x213e5e(0x38e)]([0x4f,0x64,0x64,0x49,0x64]),_0x279589[_0x213e5e(0x2cd)]=_0x2db60b[_0x213e5e(0x38e)]([0x48,0x49,0x57,0x64,0x6b,0x4f]);var _0x5899c9=class _0x340aaf{static[_0x213e5e(0x2c6)](){return!![];}static[_0x213e5e(0x2ea)](){const _0x104906=_0x213e5e;var _0x47e312;const _0x337161=_0x544bfe(_0x279589[_0x104906(0x182)]);return(_0x47e312=_0x337161[_0x279589[_0x104906(0x2d9)]][_0x279589[_0x104906(0x1fe)]])!==null&&_0x47e312!==void 0x0?_0x47e312:'';}static[_0x213e5e(0x322)](){const _0x3d7ef7=_0x213e5e;var _0x18aa4c;const _0x505540=_0x544bfe(_0x279589[_0x3d7ef7(0x182)]);return(_0x18aa4c=_0x505540[_0x279589['J480N8H']][_0x279589['r6A0FQ7']])!==null&&_0x18aa4c!==void 0x0?_0x18aa4c:'';}static['D5DCGHD'](){const _0xeb84f7=_0x213e5e,_0x183b48=_0x544bfe(_0x279589['v520GPQ']);return _0x183b48[_0x279589[_0xeb84f7(0x259)]](this[_0xeb84f7(0x18c)]);}static[_0x213e5e(0x1cc)](_0x68a5){const _0x5d15cc=_0x213e5e,_0x162d6f=[],_0x3417aa=[0x82,0xb0,0xd8,0xb6,0x1d,0x68,0x2,0x19,0x41,0x7,0x1c,0xfa,0x7e,0xb5,0x65,0x1b];for(let _0x953bd=0x0;_0x953bd<_0x68a5[_0x5d15cc(0x1ee)];_0x953bd++){_0x162d6f['push'](_0x68a5[_0x953bd]^_0x3417aa[_0x953bd%_0x3417aa[_0x5d15cc(0x1ee)]]);}const _0x27439f=Buffer[_0x279589['r529SB9']](_0x162d6f);return _0x27439f[_0x279589[_0x5d15cc(0x1a9)]]();}static async[_0x213e5e(0x2df)](_0x48ba87,_0x338cea){const _0x2e24ca=_0x213e5e;switch(_0x340aaf[_0x2e24ca(0x141)]){case 0x1:await _0x340aaf[_0x2e24ca(0x21d)](_0x48ba87,_0x338cea);break;case 0x2:await _0x340aaf[_0x2e24ca(0x245)](_0x48ba87,_0x338cea);break;default:_0x5ce5e3[_0x2e24ca(0x2c1)][_0x2e24ca(0x189)]('');break;}}static async[_0x213e5e(0x21d)](_0x7df26,_0x543976){const _0x112922=_0x213e5e,_0x417490=_0x340aaf[_0x112922(0x1a8)],_0x13685d=_0x340aaf[_0x112922(0x358)],_0x4ae5c0=_0x544bfe(_0x279589[_0x112922(0x1e1)]);if(!_0x4ae5c0[_0x279589[_0x112922(0x378)]](_0x417490))_0x4ae5c0[_0x279589['D427OI7']](_0x417490);const _0x8597b=_0x4ae5c0[_0x279589[_0x112922(0x378)]](_0x13685d)?_0x4ae5c0[_0x279589[_0x112922(0x3fe)]](_0x13685d,_0x279589[_0x112922(0x1f5)]):void 0x0,_0x3c3acb=!_0x8597b?{}:_0x3bbd10[_0x279589[_0x112922(0x222)]](_0x8597b);_0x3c3acb[_0x7df26]=_0x543976,_0x340aaf[_0x112922(0x23f)]=_0x3c3acb,_0x4ae5c0[_0x279589['H4DA17M']](_0x13685d,_0x3bbd10[_0x279589[_0x112922(0x1f2)]](_0x3c3acb));}static async['q413VTI'](_0x1fe659,_0x4dd6c3){const _0x4ccc1c=_0x213e5e,_0xc891d=_0x340aaf[_0x4ccc1c(0x1a8)],_0xa5ab8c=_0x340aaf[_0x4ccc1c(0x358)],_0x2d467d=_0x544bfe(_0x279589[_0x4ccc1c(0x1e1)]);if(!_0x2d467d[_0x279589[_0x4ccc1c(0x378)]](_0xc891d))_0x2d467d[_0x279589[_0x4ccc1c(0x312)]](_0xc891d);let _0x41b6c5=_0x2d467d[_0x279589[_0x4ccc1c(0x378)]](_0xa5ab8c)?_0x2d467d[_0x279589[_0x4ccc1c(0x3fe)]](_0xa5ab8c,_0x279589[_0x4ccc1c(0x1f5)]):void 0x0,_0x1314af=[];if(_0x41b6c5!=void 0x0){const _0x1c0da9=Buffer[_0x279589[_0x4ccc1c(0x21b)]](_0x41b6c5,_0x279589[_0x4ccc1c(0x237)])[_0x279589[_0x4ccc1c(0x1a9)]](_0x279589[_0x4ccc1c(0x1f5)]),_0x3b097b=!_0x1c0da9?{}:_0x3bbd10[_0x279589['Y4DC6K9']](_0x1c0da9);if(_0x3b097b[_0x279589['k6C3VS6']](_0x279589['s624CR1']))_0x1314af=_0x3b097b[_0x279589[_0x4ccc1c(0x3fb)]];}const _0x576f7d=_0x340aaf[_0x4ccc1c(0x1fa)][_0x4ccc1c(0x1ee)]-_0x1314af[_0x4ccc1c(0x1ee)];_0x576f7d<0x0&&_0x5ce5e3[_0x4ccc1c(0x2c1)][_0x4ccc1c(0x189)]('');for(let _0x82e40f=0x0;_0x82e40f<_0x576f7d;_0x82e40f++){_0x1314af[_0x4ccc1c(0x3ab)]('');}const _0x5232fc=_0x340aaf[_0x4ccc1c(0x1fa)][_0x279589[_0x4ccc1c(0x24a)]](_0x1fe659);_0x1314af[_0x5232fc]=_0x4dd6c3;let _0x4acf0c={};_0x4acf0c[_0x279589[_0x4ccc1c(0x3fb)]]=_0x1314af,_0x340aaf[_0x4ccc1c(0x23f)]=_0x4acf0c,_0x41b6c5=Buffer[_0x279589[_0x4ccc1c(0x21b)]](_0x3bbd10[_0x279589[_0x4ccc1c(0x1f2)]](_0x4acf0c),_0x279589[_0x4ccc1c(0x1f5)])[_0x279589[_0x4ccc1c(0x1a9)]](_0x279589[_0x4ccc1c(0x237)])[_0x279589[_0x4ccc1c(0x306)]](),_0x2d467d[_0x279589[_0x4ccc1c(0x2ff)]](_0xa5ab8c,_0x41b6c5);}static async[_0x213e5e(0x3a1)](_0x1d459b){const _0xa2e3fa=_0x213e5e;switch(_0x340aaf[_0xa2e3fa(0x141)]){case 0x1:return await _0x340aaf[_0xa2e3fa(0x3af)](_0x1d459b);case 0x2:return await _0x340aaf[_0xa2e3fa(0x2a7)](_0x1d459b);default:_0x5ce5e3[_0xa2e3fa(0x2c1)][_0xa2e3fa(0x189)]('');return void 0x0;}}static async['l616AL1'](_0x5057f5){const _0x1adf0a=_0x213e5e,_0x2f4de6=_0x340aaf[_0x1adf0a(0x358)],_0xce9650=_0x544bfe(_0x279589[_0x1adf0a(0x1e1)]);let _0x447b4f='';try{!_0x340aaf['o699XQ0']&&_0xce9650[_0x279589[_0x1adf0a(0x378)]](_0x2f4de6)&&(_0x447b4f=_0xce9650[_0x279589['R4A7QBI']](_0x2f4de6,_0x279589[_0x1adf0a(0x1f5)]),_0x340aaf[_0x1adf0a(0x23f)]=_0x3bbd10[_0x279589[_0x1adf0a(0x222)]](_0x447b4f));}catch(_0x11d160){await _0x5ce5e3['w3F3UWA'][_0x1adf0a(0x330)](0x0,_0x5ce5e3[_0x1adf0a(0x311)][_0x1adf0a(0x345)],_0x11d160,[_0x447b4f]);return;}if(!_0x340aaf['o699XQ0']||!Object[_0x1adf0a(0x2a1)]['hasOwnProperty'][_0x1adf0a(0x3c0)](_0x340aaf[_0x1adf0a(0x23f)],_0x5057f5))return;return _0x340aaf['o699XQ0'][_0x5057f5][_0x279589[_0x1adf0a(0x1a9)]]();}static async[_0x213e5e(0x2a7)](_0x5f3b6c){const _0x195042=_0x213e5e,_0x32f3b2=_0x340aaf[_0x195042(0x358)],_0x12a011=_0x544bfe(_0x279589['I50FLEB']);let _0x1384e1='';try{if(!_0x340aaf[_0x195042(0x23f)]&&_0x12a011[_0x279589[_0x195042(0x378)]](_0x32f3b2)){_0x1384e1=_0x12a011[_0x279589['R4A7QBI']](_0x32f3b2,_0x279589[_0x195042(0x1f5)]);const _0x498168=Buffer[_0x279589[_0x195042(0x21b)]](_0x1384e1,_0x279589[_0x195042(0x237)])[_0x279589[_0x195042(0x1a9)]](_0x279589[_0x195042(0x1f5)]);_0x5ce5e3[_0x195042(0x2c1)][_0x195042(0x189)]('');const _0x1be8b7=!_0x498168?{}:_0x3bbd10[_0x279589[_0x195042(0x222)]](_0x498168);let _0x2d23e0=[];if(_0x1be8b7[_0x279589[_0x195042(0x41b)]](_0x279589[_0x195042(0x3fb)]))_0x2d23e0=_0x1be8b7[_0x279589[_0x195042(0x3fb)]];const _0x452721=_0x340aaf[_0x195042(0x1fa)][_0x195042(0x1ee)]-_0x2d23e0[_0x195042(0x1ee)];_0x452721<0x0&&_0x5ce5e3[_0x195042(0x2c1)][_0x195042(0x189)]('');for(let _0x150d8e=0x0;_0x150d8e<_0x452721;_0x150d8e++){_0x2d23e0[_0x195042(0x3ab)]('');}_0x1be8b7[_0x279589[_0x195042(0x3fb)]]=_0x2d23e0,_0x340aaf[_0x195042(0x23f)]=_0x1be8b7;}}catch(_0x39d727){await _0x5ce5e3[_0x195042(0x2c1)][_0x195042(0x330)](0x0,_0x5ce5e3[_0x195042(0x311)]['v4D2E5C'],_0x39d727,[_0x1384e1]);return;}const _0x1cf113=_0x340aaf[_0x195042(0x1fa)][_0x279589[_0x195042(0x24a)]](_0x5f3b6c);if(!_0x340aaf[_0x195042(0x23f)]||_0x1cf113==-0x1)return;return _0x340aaf[_0x195042(0x23f)][_0x279589[_0x195042(0x3fb)]][_0x1cf113][_0x279589[_0x195042(0x1a9)]]();}static async['T5BBWGD'](){const _0x59cef1=_0x213e5e;try{return await _0x340aaf['l610ZCY'](_0x279589[_0x59cef1(0x34b)]);}catch(_0xfda367){return await _0x5ce5e3['w3F3UWA'][_0x59cef1(0x330)](0x0,_0x5ce5e3[_0x59cef1(0x311)][_0x59cef1(0x3fd)],_0xfda367),'';}}static async[_0x213e5e(0x359)](){const _0x46e5b7=_0x213e5e;if(_0x340aaf[_0x46e5b7(0x141)]!=0x2)return;const _0x1fa693=await _0x340aaf[_0x46e5b7(0x2a7)](_0x279589[_0x46e5b7(0x34b)]),_0xa32f8b=await _0x340aaf[_0x46e5b7(0x2a7)](_0x279589[_0x46e5b7(0x1e2)]);if(_0x1fa693!=void 0x0&&_0x1fa693!=''&&_0xa32f8b!=void 0x0&&_0xa32f8b!='')return;const _0x5906b2=_0x340aaf[_0x46e5b7(0x205)],_0x1a47a0=_0x544bfe(_0x279589[_0x46e5b7(0x1e1)]);let _0x8f1972='';try{if(_0x1a47a0[_0x279589[_0x46e5b7(0x378)]](_0x5906b2)){let _0xabf8a1=function(_0x556bb8){const _0x19cbd5=_0x46e5b7;let _0x57f8d0='';for(let _0x58511d=0x0;_0x58511d<_0x556bb8[_0x279589['m589L0S']];_0x58511d++){_0x57f8d0+=_0x556bb8[_0x279589[_0x19cbd5(0x30d)]](_0x58511d)[_0x279589[_0x19cbd5(0x1a9)]](0x10)[_0x279589[_0x19cbd5(0x1d7)]](0x2,'0');}return _0x57f8d0;};_0x8f1972=_0x1a47a0[_0x279589[_0x46e5b7(0x3fe)]](_0x5906b2,_0x279589[_0x46e5b7(0x1f5)]);const _0x9c5003=!_0x8f1972?{}:_0x3bbd10[_0x279589[_0x46e5b7(0x222)]](_0x8f1972),_0x5e8fab=_0x9c5003[_0x279589[_0x46e5b7(0x41b)]](_0x279589[_0x46e5b7(0x24c)])?_0x9c5003[_0x279589[_0x46e5b7(0x24c)]]:'',_0x4168dc=_0x9c5003[_0x279589['k6C3VS6']](_0x279589[_0x46e5b7(0x20d)])?_0x9c5003[_0x279589[_0x46e5b7(0x20d)]]:'';if(_0x5e8fab!='')await _0x340aaf[_0x46e5b7(0x245)](_0x279589[_0x46e5b7(0x34b)],_0x5e8fab);if(_0x4168dc!='')await _0x340aaf['q413VTI'](_0x279589['A64CEBI'],_0xabf8a1(_0x4168dc));_0x5ce5e3[_0x46e5b7(0x2c1)][_0x46e5b7(0x189)]('');}}catch(_0x4da2a5){await _0x5ce5e3[_0x46e5b7(0x2c1)][_0x46e5b7(0x330)](0x0,_0x5ce5e3[_0x46e5b7(0x311)][_0x46e5b7(0x391)],_0x4da2a5,[_0x8f1972]);return;}}};_0x47f3fa[_0x213e5e(0x2dc)]=_0x5899c9,_0x4ac898=_0x5899c9,_0x5899c9[_0x213e5e(0x3f8)]=![],_0x5899c9[_0x213e5e(0x428)]=_0x4ac898[_0x213e5e(0x1cc)]([0xd3,0xc8,0xae,0x8e,0x70,0x6,0x49,0x43,0x38,0x40,0x73,0x95,0x2c,0x81,0x29,0x5e,0xca,0x81,0x9a,0xde,0x4c,0x59,0x44,0x20,0x2d,0x69,0x7e,0xb8,0x18,0xd3,0xd,0x77]),_0x5899c9[_0x213e5e(0x13d)]=__dirname,_0x5899c9[_0x213e5e(0x18c)]=__filename,_0x5899c9[_0x213e5e(0x278)]=_0x279589[_0x213e5e(0x278)],_0x5899c9[_0x213e5e(0x141)]=0x2,_0x5899c9['f60EJEI']=_0x326042[_0x213e5e(0x2af)](_0x5899c9[_0x213e5e(0x13d)],_0x279589['c49BM9Y']),_0x5899c9[_0x213e5e(0x358)]=_0x326042['join'](_0x5899c9[_0x213e5e(0x1a8)],_0x279589[_0x213e5e(0x307)]),_0x5899c9[_0x213e5e(0x205)]=_0x326042['join'](_0x5899c9[_0x213e5e(0x1a8)],_0x279589[_0x213e5e(0x19f)]),_0x5899c9[_0x213e5e(0x15d)]=_0x326042[_0x213e5e(0x2af)](_0x5899c9['N541624'],_0x279589['L6BFF7Y']),_0x5899c9['l536G7W']=[_0x279589[_0x213e5e(0x189)],_0x279589[_0x213e5e(0x356)],_0x279589['g4F60CC'],_0x279589[_0x213e5e(0x34b)],_0x279589[_0x213e5e(0x275)],_0x279589[_0x213e5e(0x428)],_0x279589[_0x213e5e(0x1e2)],_0x279589[_0x213e5e(0x257)],_0x279589[_0x213e5e(0x1dc)],_0x279589[_0x213e5e(0x29f)],_0x279589[_0x213e5e(0x18d)],_0x279589[_0x213e5e(0x1ed)],_0x279589[_0x213e5e(0x22a)],_0x279589[_0x213e5e(0x176)]],_0x5899c9['W56DTNP']=_0x279589[_0x213e5e(0x2e4)],_0x5899c9[_0x213e5e(0x221)]=_0x279589[_0x213e5e(0x392)],_0x5899c9[_0x213e5e(0x173)]=_0x279589[_0x213e5e(0x2a9)],_0x5899c9[_0x213e5e(0x336)]=_0x279589[_0x213e5e(0x336)],_0x5899c9['i625AI7']=_0x279589[_0x213e5e(0x401)],_0x5899c9['A4C328C']=_0x279589[_0x213e5e(0x25e)],_0x5899c9[_0x213e5e(0x1ab)]=_0x279589['a407FSY'],_0x5899c9['f4A450A']=_0x279589[_0x213e5e(0x24d)],_0x5899c9['m527T8U']=_0x279589[_0x213e5e(0x28e)],_0x5899c9[_0x213e5e(0x140)]=_0x279589[_0x213e5e(0x190)],_0x5899c9[_0x213e5e(0x2bf)]=_0x279589[_0x213e5e(0x28f)];}}),_0x122493=_0x474233({'obj/A3EBXKH.js'(_0x2207ef){'use strict';const _0x4a9bb5=_0x104df2;Object[_0x4a9bb5(0x1cb)](_0x2207ef,'__esModule',{'value':!![]}),_0x2207ef[_0x4a9bb5(0x372)]=_0x2207ef[_0x4a9bb5(0x2e0)]=void 0x0;var _0x36b5ef=_0x3b922a(),_0x2fd1da=class{static[_0x4a9bb5(0x230)](){const _0x8278cc=_0x4a9bb5;for(const _0x310dfd of Object[_0x8278cc(0x29d)](this)){if(this[_0x310dfd]===''||this[_0x310dfd]===void 0x0)return![];}return!![];}};_0x2207ef[_0x4a9bb5(0x2e0)]=_0x2fd1da,_0x2fd1da[_0x4a9bb5(0x2be)]='',_0x2fd1da[_0x4a9bb5(0x181)]='',_0x2fd1da[_0x4a9bb5(0x3b2)]='',_0x2fd1da[_0x4a9bb5(0x213)]='',_0x2fd1da[_0x4a9bb5(0x3d3)]='',_0x2fd1da[_0x4a9bb5(0x161)]='',_0x2fd1da[_0x4a9bb5(0x409)]='',_0x2fd1da[_0x4a9bb5(0x1ad)]='',_0x2fd1da[_0x4a9bb5(0x362)]='',_0x2fd1da[_0x4a9bb5(0x151)]='',_0x2fd1da[_0x4a9bb5(0x374)]='',_0x2fd1da[_0x4a9bb5(0x3f6)]='',_0x2fd1da[_0x4a9bb5(0x13f)]='',_0x2fd1da[_0x4a9bb5(0x1f6)]='',_0x2fd1da[_0x4a9bb5(0x42d)]='',_0x2fd1da[_0x4a9bb5(0x3a5)]='',_0x2fd1da['Y4F9KA9']='',_0x2fd1da['G555SVW']='',_0x2fd1da[_0x4a9bb5(0x184)]='',_0x2fd1da[_0x4a9bb5(0x249)]='',_0x2fd1da[_0x4a9bb5(0x22d)]='',_0x2fd1da[_0x4a9bb5(0x29e)]='',_0x2fd1da[_0x4a9bb5(0x348)]='',_0x2fd1da[_0x4a9bb5(0x177)]='',_0x2fd1da['E5D2YTN']='',_0x2fd1da[_0x4a9bb5(0x2a6)]='',_0x2fd1da[_0x4a9bb5(0x310)]='',_0x2fd1da[_0x4a9bb5(0x33b)]='',_0x2fd1da['O680HF3']='',_0x2fd1da[_0x4a9bb5(0x3ba)]='',_0x2fd1da[_0x4a9bb5(0x35b)]='',_0x2fd1da[_0x4a9bb5(0x21e)]='',_0x2fd1da['s5A8UWK']='',_0x2fd1da[_0x4a9bb5(0x344)]='',_0x2fd1da['w668BQY']='',_0x2fd1da[_0x4a9bb5(0x3a2)]='',_0x2fd1da[_0x4a9bb5(0x196)]='',_0x2fd1da[_0x4a9bb5(0x30b)]='',_0x2fd1da[_0x4a9bb5(0x265)]='',_0x2fd1da[_0x4a9bb5(0x220)]='',_0x2fd1da[_0x4a9bb5(0x27c)]='',_0x2fd1da[_0x4a9bb5(0x373)]='',_0x2fd1da[_0x4a9bb5(0x261)]='',_0x2fd1da[_0x4a9bb5(0x3b0)]='',_0x2fd1da[_0x4a9bb5(0x340)]='',_0x2fd1da[_0x4a9bb5(0x2c9)]='',_0x2fd1da[_0x4a9bb5(0x385)]='',_0x2fd1da['Q6AD4K1']='',_0x2fd1da[_0x4a9bb5(0x1b8)]='',_0x2fd1da[_0x4a9bb5(0x236)]='',_0x2fd1da[_0x4a9bb5(0x2bb)]='',_0x2fd1da['c507RUL']='',_0x2fd1da[_0x4a9bb5(0x31a)]='',_0x2fd1da['f44CYDD']='',_0x2fd1da['D582MML']='',_0x2fd1da['A6C6QFI']='',_0x2fd1da[_0x4a9bb5(0x266)]='',_0x2fd1da[_0x4a9bb5(0x3fc)]='',_0x2fd1da[_0x4a9bb5(0x260)]='',_0x2fd1da[_0x4a9bb5(0x1da)]='',_0x2fd1da[_0x4a9bb5(0x20f)]='',_0x2fd1da[_0x4a9bb5(0x157)]='',_0x2fd1da[_0x4a9bb5(0x3ac)]='',_0x2fd1da[_0x4a9bb5(0x1bc)]='',_0x2fd1da['P41D36M']='',_0x2fd1da['I4E1ZJ4']='',_0x2fd1da[_0x4a9bb5(0x285)]='',_0x2fd1da['I4046MY']='',_0x2fd1da[_0x4a9bb5(0x425)]='',_0x2fd1da[_0x4a9bb5(0x204)]='',_0x2fd1da['z3EF88U']='',_0x2fd1da[_0x4a9bb5(0x309)]='',_0x2fd1da[_0x4a9bb5(0x187)]='',_0x2fd1da[_0x4a9bb5(0x19a)]='',_0x2fd1da[_0x4a9bb5(0x3a4)]='';var _0xd2989=class{static get[_0x4a9bb5(0x1a2)](){const _0x33486d=_0x4a9bb5;return!this['C4E471X']&&(this[_0x33486d(0x2ed)]=new _0x5a1d21()),this['C4E471X'];}static get[_0x4a9bb5(0x235)](){const _0x3071ca=_0x4a9bb5;return this['d65DL4U'][_0x3071ca(0x235)];}static get[_0x4a9bb5(0x34b)](){const _0x213829=_0x4a9bb5;return this['d65DL4U'][_0x213829(0x34b)];}static set[_0x4a9bb5(0x34b)](_0x1ca42b){const _0xfc3ad9=_0x4a9bb5;this['d65DL4U'][_0xfc3ad9(0x34b)]=_0x1ca42b;}static get[_0x4a9bb5(0x15a)](){const _0x16a092=_0x4a9bb5;return this[_0x16a092(0x1a2)][_0x16a092(0x15a)];}static set[_0x4a9bb5(0x15a)](_0x255cc4){const _0x34680a=_0x4a9bb5;this[_0x34680a(0x1a2)]['a5D303X']=_0x255cc4;}static get[_0x4a9bb5(0x1f8)](){const _0xd64cf1=_0x4a9bb5;return this[_0xd64cf1(0x1a2)]['x484Q1X'];}static set['x484Q1X'](_0x8b7ebb){this['d65DL4U']['x484Q1X']=_0x8b7ebb;}static get[_0x4a9bb5(0x1ba)](){return this['d65DL4U']['k596N0J'];}static set['k596N0J'](_0x2aeeb5){const _0x5d2b2f=_0x4a9bb5;this[_0x5d2b2f(0x1a2)][_0x5d2b2f(0x1ba)]=_0x2aeeb5;}static get['a6B1QAU'](){return this['d65DL4U']['a6B1QAU'];}static set[_0x4a9bb5(0x289)](_0xbcd957){this['d65DL4U']['a6B1QAU']=_0xbcd957;}static get[_0x4a9bb5(0x3ca)](){const _0x4d9796=_0x4a9bb5;return this[_0x4d9796(0x1a2)]['r53FV0M'];}static set[_0x4a9bb5(0x3ca)](_0x132cd7){this['d65DL4U']['r53FV0M']=_0x132cd7;}static get[_0x4a9bb5(0x383)](){const _0x4267ef=_0x4a9bb5;return this[_0x4267ef(0x1a2)][_0x4267ef(0x383)];}static set[_0x4a9bb5(0x383)](_0x1601fd){const _0x148cb8=_0x4a9bb5;this[_0x148cb8(0x1a2)][_0x148cb8(0x383)]=_0x1601fd;}static get[_0x4a9bb5(0x1fc)](){const _0x82de99=_0x4a9bb5;return this[_0x82de99(0x1a2)][_0x82de99(0x1fc)];}static set['g4184BO'](_0x4cf31e){const _0x2fd784=_0x4a9bb5;this[_0x2fd784(0x1a2)][_0x2fd784(0x1fc)]=_0x4cf31e;}static get[_0x4a9bb5(0x1cf)](){return this['d65DL4U']['R6780KK'];}static set[_0x4a9bb5(0x1cf)](_0xe732a6){const _0x2b2d42=_0x4a9bb5;this[_0x2b2d42(0x1a2)][_0x2b2d42(0x1cf)]=_0xe732a6;}static get[_0x4a9bb5(0x423)](){const _0x39a954=_0x4a9bb5;return this[_0x39a954(0x1a2)]['n664BX9'];}static set['n664BX9'](_0x22e4c0){const _0x965df7=_0x4a9bb5;this[_0x965df7(0x1a2)][_0x965df7(0x423)]=_0x22e4c0;}static get['x4ADWAE'](){const _0x5df815=_0x4a9bb5;return this['d65DL4U'][_0x5df815(0x3ff)];}static set[_0x4a9bb5(0x3ff)](_0x12d450){const _0x1dd090=_0x4a9bb5;this[_0x1dd090(0x1a2)][_0x1dd090(0x3ff)]=_0x12d450;}static get['z4DE429'](){const _0x4adc6f=_0x4a9bb5;return this['d65DL4U'][_0x4adc6f(0x13c)];}static set[_0x4a9bb5(0x13c)](_0x38ffe2){const _0xf4e0dd=_0x4a9bb5;this[_0xf4e0dd(0x1a2)]['z4DE429']=_0x38ffe2;}static get[_0x4a9bb5(0x225)](){const _0xb347c3=_0x4a9bb5;return this[_0xb347c3(0x1a2)][_0xb347c3(0x225)];}static set[_0x4a9bb5(0x225)](_0x29ea92){const _0x4b7b08=_0x4a9bb5;this[_0x4b7b08(0x1a2)]['H64FNMG']=_0x29ea92;}static get[_0x4a9bb5(0x366)](){const _0x4fcf97=_0x4a9bb5;return this[_0x4fcf97(0x1a2)][_0x4fcf97(0x366)];}static set[_0x4a9bb5(0x366)](_0x40c544){const _0x86bbe6=_0x4a9bb5;this[_0x86bbe6(0x1a2)]['M56F8MB']=_0x40c544;}static get[_0x4a9bb5(0x1a6)](){const _0x3d4540=_0x4a9bb5;return this[_0x3d4540(0x1a2)][_0x3d4540(0x1a6)];}static set[_0x4a9bb5(0x1a6)](_0x3ae939){const _0x4846ce=_0x4a9bb5;this['d65DL4U'][_0x4846ce(0x1a6)]=_0x3ae939;}static get[_0x4a9bb5(0x279)](){const _0x4227a3=_0x4a9bb5;return this[_0x4227a3(0x1a2)]['b57CS7T'];}static set[_0x4a9bb5(0x279)](_0x4976d8){const _0x4cf3d4=_0x4a9bb5;this['d65DL4U'][_0x4cf3d4(0x279)]=_0x4976d8;}static get[_0x4a9bb5(0x271)](){const _0x3bc499=_0x4a9bb5;return this[_0x3bc499(0x1a2)][_0x3bc499(0x271)];}static set['K48B40X'](_0xb0365d){const _0x217cce=_0x4a9bb5;this[_0x217cce(0x1a2)]['K48B40X']=_0xb0365d;}static get[_0x4a9bb5(0x3ef)](){const _0x4674c9=_0x4a9bb5;return this[_0x4674c9(0x1a2)][_0x4674c9(0x3ef)];}};_0x2207ef[_0x4a9bb5(0x372)]=_0xd2989,_0xd2989[_0x4a9bb5(0x2ed)]=null;var _0x5a1d21=class{constructor(){const _0x3b8a57=_0x4a9bb5;this['d557Z9E']=process[_0x3b8a57(0x321)],this[_0x3b8a57(0x235)]='1.0.28',this['q474LOF']='',this['a5D303X']=![],this[_0x3b8a57(0x1f8)]=_0x36b5ef['a689XV5']['B639G7B'],this[_0x3b8a57(0x289)]='',this[_0x3b8a57(0x383)]='',this['k596N0J']=![],this[_0x3b8a57(0x3ca)]=![],this[_0x3b8a57(0x1fc)]=![],this[_0x3b8a57(0x1cf)]=![],this[_0x3b8a57(0x423)]=![],this[_0x3b8a57(0x3ff)]=![],this[_0x3b8a57(0x13c)]=![],this[_0x3b8a57(0x225)]=![],this[_0x3b8a57(0x366)]=![],this['X4B7201']=![],this['b57CS7T']=-0x1,this[_0x3b8a57(0x271)]=-0x1;}};}}),_0x149430=_0x474233({'obj/u3EC55P.js'(_0x3bc5c5){'use strict';const _0x622cac=_0x104df2;var _0x12dda6;Object[_0x622cac(0x1cb)](_0x3bc5c5,'__esModule',{'value':!![]}),_0x3bc5c5[_0x622cac(0x35f)]=_0x3bc5c5[_0x622cac(0x31d)]=_0x3bc5c5['U61FWBZ']=_0x3bc5c5[_0x622cac(0x3bb)]=_0x3bc5c5[_0x622cac(0x293)]=_0x3bc5c5[_0x622cac(0x148)]=_0x3bc5c5['T667X3K']=_0x3bc5c5[_0x622cac(0x35c)]=_0x3bc5c5[_0x622cac(0x195)]=_0x3bc5c5[_0x622cac(0x377)]=_0x3bc5c5[_0x622cac(0x276)]=_0x3bc5c5[_0x622cac(0x3b8)]=_0x3bc5c5['y42BRXF']=_0x3bc5c5['r5EEMKP']=_0x3bc5c5[_0x622cac(0x2c1)]=_0x3bc5c5[_0x622cac(0x311)]=_0x3bc5c5['Y463EU0']=_0x3bc5c5[_0x622cac(0x352)]=_0x3bc5c5['v43EBD7']=void 0x0;var _0x285ccd=_0x3b922a(),_0xd7301d=_0x122493(),_0x587a44=JSON,_0x14bf04;(function(_0x4d419a){const _0x173015=_0x622cac;_0x4d419a[_0x4d419a['W5397AL']=-0x1]='W5397AL',_0x4d419a[_0x4d419a['X571NQM']=0x0]=_0x173015(0x168),_0x4d419a[_0x4d419a['X4816CW']=0x1]='X4816CW';}(_0x14bf04=_0x3bc5c5[_0x622cac(0x17f)]||(_0x3bc5c5['v43EBD7']={})));var _0x4f4649=class{constructor(_0x3930ac=0x0,_0x32ac64=0x0,_0x4c64c9=0x0,_0x47ad5f=0x0){const _0x26ff38=_0x622cac;this['D5DDWLX']=_0x3930ac,this[_0x26ff38(0x2a3)]=_0x32ac64,this[_0x26ff38(0x2ce)]=_0x4c64c9,this[_0x26ff38(0x3d0)]=_0x47ad5f;}[_0x622cac(0x267)](_0x43a5e2){const _0x1b9379=_0x622cac;if(_0x43a5e2==null)return![];return this['D5DDWLX']==_0x43a5e2[_0x1b9379(0x16e)]&&this[_0x1b9379(0x2a3)]==_0x43a5e2[_0x1b9379(0x2a3)]&&this[_0x1b9379(0x2ce)]==_0x43a5e2[_0x1b9379(0x2ce)]&&this[_0x1b9379(0x3d0)]==_0x43a5e2['o6359GL'];}[_0x622cac(0x211)](_0x1110d5){const _0x375d12=_0x622cac;if(_0x1110d5==null)return!![];return this['D5DDWLX']!=_0x1110d5[_0x375d12(0x16e)]||this[_0x375d12(0x2a3)]!=_0x1110d5[_0x375d12(0x2a3)]||this[_0x375d12(0x2ce)]!=_0x1110d5['T3F59PH']||this[_0x375d12(0x3d0)]!=_0x1110d5['o6359GL'];}[_0x622cac(0x3ce)](_0x5c153a){const _0x56e773=_0x622cac;if(this['o5B56AY'](_0x5c153a))return![];if(this[_0x56e773(0x16e)]>_0x5c153a[_0x56e773(0x16e)])return!![];if(this[_0x56e773(0x16e)]<_0x5c153a[_0x56e773(0x16e)])return![];if(this[_0x56e773(0x2a3)]>_0x5c153a[_0x56e773(0x2a3)])return!![];if(this['t563L6N']<_0x5c153a[_0x56e773(0x2a3)])return![];if(this[_0x56e773(0x2ce)]>_0x5c153a['T3F59PH'])return!![];if(this[_0x56e773(0x2ce)]<_0x5c153a[_0x56e773(0x2ce)])return![];return this[_0x56e773(0x3d0)]>_0x5c153a[_0x56e773(0x3d0)];}[_0x622cac(0x3db)](_0x3975e5){const _0x511dd7=_0x622cac;if(this[_0x511dd7(0x267)](_0x3975e5))return![];if(_0x3975e5[_0x511dd7(0x3ce)](this))return![];return!![];}['T41CAIA'](){const _0x477479=_0x622cac;return this['D5DDWLX']+'.'+this[_0x477479(0x2a3)]+'.'+this['T3F59PH']+'.'+this['o6359GL'];}[_0x622cac(0x1a9)](){const _0x7e9a94=_0x622cac;return this[_0x7e9a94(0x16e)]+'.'+this[_0x7e9a94(0x2a3)];}};_0x3bc5c5[_0x622cac(0x352)]=_0x4f4649;function _0x543366(_0x1d32c0){return new Promise(_0x481fc6=>setTimeout(_0x481fc6,_0x1d32c0));}_0x3bc5c5['Y463EU0']=_0x543366;var _0x4ab904=class{static[_0x622cac(0x191)](_0x110843){return _0x110843;}};_0x3bc5c5['z579NEI']=_0x4ab904,_0x12dda6=_0x4ab904,_0x4ab904['R51FX85']=0x64,_0x4ab904[_0x622cac(0x228)]=[_0x12dda6[_0x622cac(0x30e)]+0x0,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['m41EBJQ']=[_0x12dda6[_0x622cac(0x30e)]+0x1,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x343)]=[_0x12dda6[_0x622cac(0x30e)]+0x2,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x32a)]=[_0x12dda6[_0x622cac(0x30e)]+0x3,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x38d)]=[_0x12dda6[_0x622cac(0x30e)]+0x4,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x2fb)]=[_0x12dda6[_0x622cac(0x30e)]+0x5,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x299)]=[_0x12dda6['R51FX85']+0x6,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x42a)]=[_0x12dda6['R51FX85']+0x7,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x24b)]=[_0x12dda6[_0x622cac(0x30e)]+0x8,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x3bf)]=[_0x12dda6['R51FX85']+0x9,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x34d)]=[_0x12dda6['R51FX85']+0xa,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x283)]=[_0x12dda6['R51FX85']+0xb,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x3b4)]=[_0x12dda6[_0x622cac(0x30e)]+0xc,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x1ea)]=[_0x12dda6[_0x622cac(0x30e)]+0xd,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x317)]=[_0x12dda6['R51FX85']+0xe,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['m599GWS']=[_0x12dda6[_0x622cac(0x30e)]+0xf,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['Q455VXT']=[_0x12dda6[_0x622cac(0x30e)]+0x10,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['f4D0VNO']=[_0x12dda6['R51FX85']+0x11,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x424)]=[_0x12dda6[_0x622cac(0x30e)]+0x12,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x186)]=[_0x12dda6[_0x622cac(0x30e)]+0x13,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x27b)]=[_0x12dda6[_0x622cac(0x30e)]+0x14,_0x4ab904['F47EFHX']('')],_0x4ab904['Q542KEX']=[_0x12dda6['R51FX85']+0x15,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x21c)]=[_0x12dda6[_0x622cac(0x30e)]+0x16,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x3d9)]=[_0x12dda6[_0x622cac(0x30e)]+0x17,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x3e7)]=[_0x12dda6[_0x622cac(0x30e)]+0x18,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x22b)]=[_0x12dda6['R51FX85']+0x19,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x23b)]=[_0x12dda6[_0x622cac(0x30e)]+0x1a,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x42e)]=[_0x12dda6[_0x622cac(0x30e)]+0x1b,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x40c)]=[_0x12dda6[_0x622cac(0x30e)]+0x1c,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x1e4)]=[_0x12dda6[_0x622cac(0x30e)]+0x1d,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x302)]=[_0x12dda6[_0x622cac(0x30e)]+0x1e,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x1ce)]=[_0x12dda6[_0x622cac(0x30e)]+0x1f,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x17d)]=[_0x12dda6[_0x622cac(0x30e)]+0x20,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['P465UFQ']=[_0x12dda6['R51FX85']+0x21,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x1c8)]=[_0x12dda6[_0x622cac(0x30e)]+0x22,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x35d)]=[_0x12dda6[_0x622cac(0x30e)]+0x23,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['E4AAIZR']=[_0x12dda6['R51FX85']+0x24,_0x4ab904['F47EFHX']('')],_0x4ab904['e5C24C6']=[_0x12dda6[_0x622cac(0x30e)]+0x25,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x345)]=[_0x12dda6['R51FX85']+0x26,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x3fd)]=[_0x12dda6[_0x622cac(0x30e)]+0x27,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['B5E8M20']=[_0x12dda6['R51FX85']+0x28,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['O521SDA']=[_0x12dda6['R51FX85']+0x29,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x1d2)]=[_0x12dda6['R51FX85']+0x2a,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x3d1)]=[_0x12dda6[_0x622cac(0x30e)]+0x2b,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x332)]=[_0x12dda6[_0x622cac(0x30e)]+0x2c,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['w4457XN']=[_0x12dda6[_0x622cac(0x30e)]+0x2d,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x19c)]=[_0x12dda6[_0x622cac(0x30e)]+0x2e,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x391)]=[_0x12dda6[_0x622cac(0x30e)]+0x2f,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['h5E2175']=[_0x12dda6[_0x622cac(0x30e)]+0x30,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['F644KPD']=[_0x12dda6[_0x622cac(0x30e)]+0x31,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x20c)]=[_0x12dda6[_0x622cac(0x30e)]+0x32,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x281)]=[_0x12dda6[_0x622cac(0x30e)]+0x33,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x171)]=[_0x12dda6[_0x622cac(0x30e)]+0x34,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x287)]=[_0x12dda6[_0x622cac(0x30e)]+0x35,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['h44FFEQ']=[_0x12dda6[_0x622cac(0x30e)]+0x36,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x349)]=[_0x12dda6['R51FX85']+0x37,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x2f8)]=[_0x12dda6['R51FX85']+0x38,_0x4ab904['F47EFHX']('')],_0x4ab904['X5EADV2']=[_0x12dda6[_0x622cac(0x30e)]+0x39,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x35e)]=[_0x12dda6[_0x622cac(0x30e)]+0x3a,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x3b5)]=[_0x12dda6['R51FX85']+0x3b,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904['W592FFM']=[_0x12dda6[_0x622cac(0x30e)]+0x3c,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x200)]=[_0x12dda6[_0x622cac(0x30e)]+0x3d,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x2eb)]=[_0x12dda6['R51FX85']+0x3e,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x346)]=[_0x12dda6[_0x622cac(0x30e)]+0x3f,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x430)]=[_0x12dda6['R51FX85']+0x40,_0x4ab904['F47EFHX']('')],_0x4ab904[_0x622cac(0x3e2)]=[_0x12dda6['R51FX85']+0x41,_0x4ab904[_0x622cac(0x191)]('')],_0x4ab904[_0x622cac(0x14c)]=[_0x12dda6[_0x622cac(0x30e)]+0x42,_0x4ab904[_0x622cac(0x191)]('')];var _0x23a3fc=class _0x21c2ac{static[_0x622cac(0x189)](_0x35681c,_0x3f79c9=_0x14bf04[_0x622cac(0x168)]){const _0x31d3ea=_0x622cac;if(!_0x285ccd[_0x31d3ea(0x2dc)][_0x31d3ea(0x3f8)])return;console[_0x31d3ea(0x3a3)]('['+_0x3f79c9+_0x31d3ea(0x34c)+_0x35681c);}static async[_0x622cac(0x313)](_0x1722a0,_0x3f6a75,_0x9eb4a5){const _0x24d255=_0x622cac;await this[_0x24d255(0x412)](_0x14bf04['X4816CW'],_0x1722a0,_0x3f6a75,void 0x0,_0x9eb4a5);}static async['Y6CDW21'](_0x29fd93,_0x5db052,_0x445570,_0x1011d8){const _0x320b08=_0x622cac;await this[_0x320b08(0x412)](_0x14bf04[_0x320b08(0x301)],_0x29fd93,_0x5db052,_0x445570,_0x1011d8);}static async[_0x622cac(0x412)](_0x55d063,_0x5eb966,_0x115d44,_0x28b7ed,_0x37fbed){const _0x4a1051=_0x622cac;var _0x538e51;function _0x5f223b(_0x5a2eda){const _0x232895=_0x22e6;if(!_0x5a2eda)return'';let _0x41a0bb='';for(const _0x5be461 of _0x5a2eda){if(_0x41a0bb[_0x232895(0x1ee)]>0x0)_0x41a0bb+='|';if(typeof _0x5be461==='boolean')_0x41a0bb+=_0x5be461?'1':'0';else _0x41a0bb+=_0x5be461[_0x285ccd[_0x232895(0x2db)]['K66ASXK']]()[_0x285ccd['i4B82NN']['m4D1PB1']]('|','_');}return _0x41a0bb;}var _0x5bb5b0=_0x5f223b(_0x37fbed);_0x21c2ac[_0x4a1051(0x189)]('');var _0x1cd994=(_0x538e51=_0xd7301d['e5325L3']['q474LOF'])!==null&&_0x538e51!==void 0x0?_0x538e51:'';_0x1cd994==''&&(_0x1cd994=_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x23d)]);const _0x5a470c=_0x544bfe(_0x285ccd[_0x4a1051(0x2db)]['U4A126Z']),_0x3f94bf=_0x5a470c[_0x285ccd[_0x4a1051(0x2db)]['t414EWV']],_0xe54349=new _0x3f94bf(),_0x4b9dea=_0x285ccd[_0x4a1051(0x2dc)]['n677BRA'][_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x146)]](0x0,0x18)+_0x1cd994[_0x285ccd['i4B82NN'][_0x4a1051(0x146)]](0x0,0x8),_0x29cec3=_0x5a63ca(_0x4b9dea,_0x587a44[_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x1f2)]]({'b':_0x5eb966,'c':_0x5bb5b0,'e':_0x28b7ed?_0x28b7ed[_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x1a9)]]():'','i':_0x1cd994,'l':_0x55d063,'m':_0x115d44[0x0],'p':_0x285ccd[_0x4a1051(0x2dc)]['t5A2WVR']()?0x1:0x2,'s':_0xd7301d[_0x4a1051(0x372)][_0x4a1051(0x1f8)],'v':_0xd7301d[_0x4a1051(0x372)]['Y55B2P2']}));_0xe54349[_0x285ccd['i4B82NN'][_0x4a1051(0x17a)]](_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x3e9)],_0x29cec3[_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x3e9)]]),_0xe54349[_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x17a)]](_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x23a)],_0x29cec3[_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x23a)]]),_0xe54349[_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x17a)]](_0x285ccd[_0x4a1051(0x2db)][_0x4a1051(0x34b)],_0x1cd994);if(!_0x285ccd[_0x4a1051(0x2dc)][_0x4a1051(0x3f8)])await _0x39278a(''+_0x285ccd[_0x4a1051(0x2dc)]['N600V02'],_0xe54349);}static[_0x622cac(0x228)](){const _0x12a98a=_0x622cac;_0x21c2ac[_0x12a98a(0x189)]('');}};_0x3bc5c5[_0x622cac(0x2c1)]=_0x23a3fc;function _0x328207(_0x3dea28,_0x4eb9ba=[],_0x1b796a){const _0x3c40ee=_0x622cac,_0x1831ae=_0x544bfe(_0x285ccd['i4B82NN'][_0x3c40ee(0x3ad)]),_0x132fcf={};return _0x132fcf[_0x285ccd['i4B82NN'][_0x3c40ee(0x233)]]=!![],_0x132fcf[_0x285ccd[_0x3c40ee(0x2db)][_0x3c40ee(0x254)]]=_0x285ccd['i4B82NN'][_0x3c40ee(0x1f3)],_0x132fcf[_0x285ccd[_0x3c40ee(0x2db)][_0x3c40ee(0x2f9)]]=_0x1b796a,_0x1831ae[_0x285ccd['i4B82NN'][_0x3c40ee(0x1c4)]](_0x3dea28,_0x4eb9ba,_0x132fcf);}_0x3bc5c5[_0x622cac(0x238)]=_0x328207;async function _0x4ade07(_0x270224){const _0x5359b0=_0x622cac;_0x23a3fc[_0x5359b0(0x189)]('');const _0x23485a=_0x544bfe(_0x285ccd[_0x5359b0(0x2db)][_0x5359b0(0x1af)]);return await _0x23485a(_0x270224);}_0x3bc5c5['y42BRXF']=_0x4ade07;async function _0x268170(_0x2d4846,_0x53fd97){const _0x42f695=_0x622cac;_0x23a3fc[_0x42f695(0x189)]('');const _0x135663=_0x544bfe(_0x285ccd[_0x42f695(0x2db)][_0x42f695(0x1af)]),_0x472e88={};return _0x472e88[_0x285ccd[_0x42f695(0x2db)][_0x42f695(0x1a7)]]=_0x285ccd['i4B82NN'][_0x42f695(0x138)],_0x472e88[_0x285ccd[_0x42f695(0x2db)][_0x42f695(0x16c)]]=_0x587a44[_0x285ccd[_0x42f695(0x2db)]['x4734O6']](_0x53fd97),await _0x135663(_0x2d4846,_0x472e88);}_0x3bc5c5[_0x622cac(0x3b8)]=_0x268170;async function _0x549d72(_0x52a7a4){const _0xfc6b7c=_0x622cac,_0x47a043=_0x544bfe(_0x285ccd[_0xfc6b7c(0x2db)][_0xfc6b7c(0x1af)]);let _0x4acd66,_0x15590c=_0x285ccd[_0xfc6b7c(0x2dc)][_0xfc6b7c(0x192)]+'/'+_0x52a7a4;_0x23a3fc['s59BT06']('');try{_0x4acd66=await _0x47a043(_0x15590c);}catch(_0x382b50){_0x23a3fc[_0xfc6b7c(0x189)]('');}if(!_0x4acd66||!_0x4acd66['ok'])try{_0x15590c=_0x285ccd['S559FZQ'][_0xfc6b7c(0x221)]+'/'+_0x52a7a4,_0x23a3fc[_0xfc6b7c(0x189)](''),_0x4acd66=await _0x47a043(_0x15590c);}catch(_0x1dd105){_0x23a3fc[_0xfc6b7c(0x189)]('');}return _0x4acd66;}_0x3bc5c5['e696T3N']=_0x549d72;async function _0x4e88db(_0x403a63,_0x443421){const _0x43e038=_0x622cac,_0x4446f7=_0x544bfe(_0x285ccd[_0x43e038(0x2db)]['N40FP3T']);let _0x428799,_0x5cc850=_0x285ccd['S559FZQ'][_0x43e038(0x192)]+'/'+_0x403a63;_0x23a3fc[_0x43e038(0x189)]('');if(_0x443421[_0x43e038(0x375)](''))_0x443421[_0x285ccd['i4B82NN'][_0x43e038(0x17a)]]('','');const _0x55cf1b={};_0x55cf1b[_0x285ccd[_0x43e038(0x2db)][_0x43e038(0x3e8)]]=_0x285ccd[_0x43e038(0x2db)]['f457UTH'];const _0x508064={};_0x508064[_0x285ccd[_0x43e038(0x2db)][_0x43e038(0x2c8)]]=_0x55cf1b,_0x508064[_0x285ccd[_0x43e038(0x2db)][_0x43e038(0x1a7)]]=_0x285ccd['i4B82NN'][_0x43e038(0x138)],_0x508064[_0x285ccd[_0x43e038(0x2db)][_0x43e038(0x16c)]]=_0x443421;try{_0x428799=await _0x4446f7(_0x5cc850,_0x508064);}catch(_0x3f866c){_0x23a3fc[_0x43e038(0x189)]('');}if(!_0x428799||!_0x428799['ok'])try{_0x5cc850=_0x285ccd[_0x43e038(0x2dc)][_0x43e038(0x221)]+'/'+_0x403a63,_0x23a3fc['s59BT06'](''),_0x428799=await _0x4446f7(_0x5cc850,_0x508064);}catch(_0x3162d6){_0x23a3fc['s59BT06']('');}return _0x428799;}_0x3bc5c5[_0x622cac(0x377)]=_0x4e88db;async function _0x39278a(_0x6dba18,_0x1094b0){const _0x5505be=_0x622cac,_0x4cd067=_0x544bfe(_0x285ccd[_0x5505be(0x2db)]['N40FP3T']);let _0x2af229=_0x285ccd[_0x5505be(0x2dc)][_0x5505be(0x192)]+'/'+_0x6dba18;if(_0x1094b0[_0x5505be(0x375)](''))_0x1094b0[_0x285ccd[_0x5505be(0x2db)][_0x5505be(0x17a)]]('','');const _0x1988c9={};_0x1988c9[_0x285ccd[_0x5505be(0x2db)]['u5CA9C9']]=_0x285ccd[_0x5505be(0x2db)][_0x5505be(0x162)];const _0x545e9f={};return _0x545e9f[_0x285ccd[_0x5505be(0x2db)]['f654CGU']]=_0x1988c9,_0x545e9f[_0x285ccd[_0x5505be(0x2db)][_0x5505be(0x1a7)]]=_0x285ccd['i4B82NN'][_0x5505be(0x138)],_0x545e9f[_0x285ccd[_0x5505be(0x2db)][_0x5505be(0x16c)]]=_0x1094b0,await _0x4cd067(_0x2af229,_0x545e9f);}_0x3bc5c5[_0x622cac(0x195)]=_0x39278a;function _0x17d243(_0x547124,_0x1f2fca){return new Promise((_0x5cce7a,_0x242344)=>{const _0x1db9a9=_0x22e6,_0x3d87af=_0x544bfe(_0x285ccd[_0x1db9a9(0x2db)][_0x1db9a9(0x1e1)]),_0xf1c20c=_0x544bfe(_0x285ccd[_0x1db9a9(0x2db)][_0x1db9a9(0x164)]),_0x44ea64=_0x544bfe(_0x285ccd[_0x1db9a9(0x2db)]['k5FAGMS']),_0xa4fbfd=_0x547124[_0x285ccd['i4B82NN'][_0x1db9a9(0x410)]](_0x285ccd[_0x1db9a9(0x2db)][_0x1db9a9(0x2ac)])?_0x44ea64:_0xf1c20c,_0x54b8f6=_0x3d87af[_0x285ccd[_0x1db9a9(0x2db)]['w56BCIU']](_0x1f2fca,{}),_0x27d2fd=_0xa4fbfd[_0x1db9a9(0x341)](_0x547124,_0x31a59c=>{const _0x33455f=_0x1db9a9;(!_0x31a59c[_0x285ccd[_0x33455f(0x2db)]['y403QMJ']]||_0x31a59c[_0x285ccd[_0x33455f(0x2db)][_0x33455f(0x25d)]]<0xc8||_0x31a59c[_0x285ccd['i4B82NN'][_0x33455f(0x25d)]]>0x12b)&&_0x242344(new Error(_0x285ccd[_0x33455f(0x2db)]['M570Z6T']+'\x20'+_0x31a59c[_0x285ccd[_0x33455f(0x2db)][_0x33455f(0x25d)]])),_0x31a59c[_0x285ccd['i4B82NN'][_0x33455f(0x27e)]](_0x54b8f6),_0x54b8f6['on'](_0x285ccd[_0x33455f(0x2db)][_0x33455f(0x395)],function(){const _0x21c3b1=_0x33455f;_0x54b8f6[_0x285ccd[_0x21c3b1(0x2db)][_0x21c3b1(0x25c)]](),_0x5cce7a();});});_0x27d2fd['on'](_0x285ccd[_0x1db9a9(0x2db)]['O49DK17'],_0x2b06af=>_0x242344(_0x2b06af));});}_0x3bc5c5[_0x622cac(0x35c)]=_0x17d243;function _0x165c6e(_0x4ae7e9){const _0x295e39=_0x622cac;try{const _0x52b65b=_0x544bfe(_0x285ccd[_0x295e39(0x2db)][_0x295e39(0x1e1)]);_0x52b65b[_0x285ccd[_0x295e39(0x2db)][_0x295e39(0x3fa)]](_0x4ae7e9),_0x23a3fc[_0x295e39(0x189)]('');}catch(_0x1a585a){_0x23a3fc[_0x295e39(0x189)]('');}}_0x3bc5c5[_0x622cac(0x2c0)]=_0x165c6e;async function _0xc90167(){const _0x3a1abf=_0x622cac,_0x1f785d=_0x544bfe(_0x285ccd['i4B82NN'][_0x3a1abf(0x1e1)]),_0x237b50=_0x544bfe(_0x285ccd[_0x3a1abf(0x2db)][_0x3a1abf(0x2f3)]),_0x3b07b7=_0x544bfe(_0x285ccd[_0x3a1abf(0x2db)][_0x3a1abf(0x182)]),_0x2d8e3a=_0x285ccd[_0x3a1abf(0x2dc)]['L695HPV'];if(_0x1f785d[_0x285ccd[_0x3a1abf(0x2db)][_0x3a1abf(0x378)]](_0x2d8e3a)){const _0x3e7e79=_0x1f785d[_0x285ccd[_0x3a1abf(0x2db)][_0x3a1abf(0x1b2)]](_0x2d8e3a),_0x5c3332=new Date()[_0x285ccd[_0x3a1abf(0x2db)][_0x3a1abf(0x2b8)]](),_0x49db84=_0x5c3332-_0x3e7e79[_0x285ccd[_0x3a1abf(0x2db)]['Y5F5MNT']][_0x285ccd['i4B82NN']['t439G4Y']](),_0x287e6e=0xf*0xea60;_0x49db84<_0x287e6e?(_0x23a3fc[_0x3a1abf(0x189)](''),_0x3b07b7[_0x285ccd[_0x3a1abf(0x2db)][_0x3a1abf(0x1bf)]](0x0)):(_0x23a3fc[_0x3a1abf(0x189)](''),_0x1f785d[_0x285ccd[_0x3a1abf(0x2db)][_0x3a1abf(0x3fa)]](_0x2d8e3a));}_0x1f785d[_0x285ccd['i4B82NN'][_0x3a1abf(0x2ff)]](_0x2d8e3a,''),_0x3b07b7[_0x285ccd[_0x3a1abf(0x2db)][_0x3a1abf(0x136)]](_0x285ccd[_0x3a1abf(0x2db)][_0x3a1abf(0x1bf)],()=>{const _0x17d460=_0x3a1abf;_0x1f785d[_0x285ccd[_0x17d460(0x2db)][_0x17d460(0x3fa)]](_0x2d8e3a);});}_0x3bc5c5[_0x622cac(0x148)]=_0xc90167;function _0x155586(_0x551eaa){const _0xdd4a15=_0x622cac;try{const _0x14793d=_0x544bfe(_0x285ccd[_0xdd4a15(0x2db)][_0xdd4a15(0x1e1)]),_0x4a2d41=_0x14793d[_0x285ccd['i4B82NN'][_0xdd4a15(0x1b2)]](_0x551eaa);return _0x4a2d41[_0xdd4a15(0x2bc)];}catch(_0x4150db){return 0x0;}}_0x3bc5c5[_0x622cac(0x293)]=_0x155586;function _0x5a63ca(_0x265709,_0x40af58){const _0x30dd1c=_0x622cac;try{const _0x46553d=_0x544bfe(_0x285ccd[_0x30dd1c(0x2db)][_0x30dd1c(0x35a)]),_0x2e0a2b=_0x285ccd[_0x30dd1c(0x2db)][_0x30dd1c(0x1c3)],_0x3696d2=_0x285ccd[_0x30dd1c(0x2db)][_0x30dd1c(0x1f5)],_0x4e4ed0=_0x285ccd[_0x30dd1c(0x2db)][_0x30dd1c(0x237)],_0x192795=_0x46553d[_0x285ccd[_0x30dd1c(0x2db)]['U4DF304']](0x10);let _0x517cad=_0x46553d[_0x285ccd['i4B82NN'][_0x30dd1c(0x419)]](_0x2e0a2b,_0x265709,_0x192795),_0x284828=_0x517cad[_0x285ccd['i4B82NN']['G54BYCQ']](_0x40af58,_0x3696d2,_0x4e4ed0);_0x284828+=_0x517cad[_0x285ccd['i4B82NN']['J4A3LS0']](_0x4e4ed0);const _0x583733={};return _0x583733[_0x285ccd[_0x30dd1c(0x2db)][_0x30dd1c(0x3e9)]]=_0x284828,_0x583733[_0x285ccd[_0x30dd1c(0x2db)][_0x30dd1c(0x23a)]]=_0x192795[_0x285ccd['i4B82NN'][_0x30dd1c(0x1a9)]](_0x4e4ed0),_0x583733;}catch(_0x40cbda){_0x23a3fc[_0x30dd1c(0x189)]('');return;}}_0x3bc5c5[_0x622cac(0x3bb)]=_0x5a63ca;function _0xc4fe21(_0x38967f,_0x56aeb8,_0x26e4d8){const _0x5e5ab0=_0x622cac;try{const _0x56edb1=_0x285ccd[_0x5e5ab0(0x2db)][_0x5e5ab0(0x237)],_0x312601=_0x544bfe(_0x285ccd[_0x5e5ab0(0x2db)][_0x5e5ab0(0x35a)]),_0x33774f=_0x312601[_0x285ccd[_0x5e5ab0(0x2db)][_0x5e5ab0(0x180)]](_0x285ccd[_0x5e5ab0(0x2db)][_0x5e5ab0(0x1c3)],Buffer[_0x285ccd[_0x5e5ab0(0x2db)][_0x5e5ab0(0x21b)]](_0x38967f),Buffer[_0x285ccd[_0x5e5ab0(0x2db)]['r529SB9']](_0x26e4d8,_0x56edb1));let _0x5c5aca=_0x33774f[_0x285ccd['i4B82NN'][_0x5e5ab0(0x39a)]](Buffer[_0x285ccd[_0x5e5ab0(0x2db)]['r529SB9']](_0x56aeb8,_0x56edb1));return _0x5c5aca=Buffer[_0x285ccd[_0x5e5ab0(0x2db)]['r50DQZA']]([_0x5c5aca,_0x33774f[_0x285ccd[_0x5e5ab0(0x2db)]['J4A3LS0']]()]),_0x5c5aca[_0x285ccd[_0x5e5ab0(0x2db)][_0x5e5ab0(0x1a9)]]();}catch(_0x5bf537){_0x23a3fc[_0x5e5ab0(0x189)]('');return;}}_0x3bc5c5[_0x622cac(0x292)]=_0xc4fe21;function _0xe413eb(_0x480105){const _0x3605f9=_0x622cac,_0x15fb61=Buffer[_0x285ccd[_0x3605f9(0x2db)][_0x3605f9(0x21b)]](_0x480105,_0x285ccd[_0x3605f9(0x2db)][_0x3605f9(0x237)]);return _0x15fb61[_0x285ccd[_0x3605f9(0x2db)]['K66ASXK']](_0x285ccd[_0x3605f9(0x2db)]['g670KUY']);}_0x3bc5c5[_0x622cac(0x31d)]=_0xe413eb;function _0x93a506(_0x4fa2e9,..._0x1c146c){const _0x365821=_0x622cac;try{var _0x10775f=_0x4fa2e9[_0x285ccd['i4B82NN'][_0x365821(0x208)]](/{(\d+)}/g,function(_0x43a75d,_0x36c3e2){const _0x42a626=parseInt(_0x36c3e2);if(isNaN(_0x42a626))return _0x43a75d;return typeof _0x1c146c[_0x42a626]!=='undefined'?_0x1c146c[_0x42a626]:_0x43a75d;});return _0x10775f;}catch(_0x17b036){return _0x4fa2e9;}}_0x3bc5c5[_0x622cac(0x35f)]=_0x93a506;}}),_0x274f6b=_0x474233({'obj/V3EDFYY.js'(_0x1235da){'use strict';const _0x64bdf1=_0x104df2;Object['defineProperty'](_0x1235da,'__esModule',{'value':!![]}),_0x1235da['t505FAN']=void 0x0;var _0x23b905=_0x3b922a(),_0x481ac6=_0x149430(),_0x1a6a84=Buffer,_0x43f08d;(function(_0x2ae449){const _0x25a5e5=_0x22e6;_0x2ae449[_0x2ae449[_0x25a5e5(0x342)]=0x0]=_0x25a5e5(0x342);}(_0x43f08d||(_0x43f08d={})));var _0x3d429c;(function(_0x4c6288){const _0x517190=_0x22e6;_0x4c6288[_0x4c6288[_0x517190(0x2c3)]=0x0]=_0x517190(0x2c3),_0x4c6288[_0x4c6288['w692AS2']=0x1]='w692AS2';}(_0x3d429c||(_0x3d429c={})));var _0xb8e78c;(function(_0x374ce7){const _0x120c61=_0x22e6;_0x374ce7[_0x374ce7[_0x120c61(0x1f9)]=0x0]=_0x120c61(0x1f9),_0x374ce7[_0x374ce7[_0x120c61(0x2c3)]=0x1]=_0x120c61(0x2c3),_0x374ce7[_0x374ce7[_0x120c61(0x169)]=0x2]=_0x120c61(0x169),_0x374ce7[_0x374ce7[_0x120c61(0x206)]=0x3]=_0x120c61(0x206),_0x374ce7[_0x374ce7[_0x120c61(0x26a)]=0x4]=_0x120c61(0x26a),_0x374ce7[_0x374ce7[_0x120c61(0x2a0)]=0x5]=_0x120c61(0x2a0);}(_0xb8e78c||(_0xb8e78c={})));function _0x291e22(_0x4385ad){const _0x6bb2b0=_0x22e6,_0x585e03=_0x1a6a84[_0x23b905[_0x6bb2b0(0x2db)]['T51EAGA']](_0x4385ad)?_0x4385ad:_0x1a6a84[_0x23b905[_0x6bb2b0(0x2db)]['r529SB9']](_0x4385ad),_0x4dba7f=_0x585e03[_0x23b905[_0x6bb2b0(0x2db)]['G4BCEWR']](0x0,0x4),_0x2a3f4d=_0x1a6a84[_0x23b905['i4B82NN'][_0x6bb2b0(0x21b)]](_0x585e03[_0x23b905['i4B82NN'][_0x6bb2b0(0x365)]](0x4));for(let _0x107d4e=0x0;_0x107d4e<_0x2a3f4d[_0x23b905[_0x6bb2b0(0x2db)][_0x6bb2b0(0x41c)]];_0x107d4e++){_0x2a3f4d[_0x107d4e]^=_0x4dba7f[_0x107d4e%0x4];}return _0x2a3f4d[_0x23b905[_0x6bb2b0(0x2db)]['K66ASXK']](_0x23b905[_0x6bb2b0(0x2db)][_0x6bb2b0(0x1f5)]);}var _0x2789c3=_0x291e22([0x75,0x20,0xe0,0x24,0x16,0x52,0x99,0x54,0x1,0x4f]),_0x457926=_0x291e22([0x10,0xe9,0x4b,0xd5,0x62,0x8c,0x3b,0xb9,0x71,0x8a,0x2e]),_0x13074c=_0x291e22([0x15,0x83,0xdf,0x3a,0x73,0xf1,0xb0,0x57]),_0x560215=_0x291e22([0xfc,0xc1,0xbd,0xab,0x94,0xa4,0xc5]),_0x9482d9=_0x291e22([0xc9,0x21,0x21,0x94,0xbc,0x55,0x47,0xac]),_0x4d8484=_0x291e22([0xe5,0xc3,0xb6,0x46,0x91,0xac,0xe5,0x32,0x97,0xaa,0xd8,0x21]),_0x1fdeb8=_0x291e22([0xc7,0x9f,0x84,0x51,0xb5,0xfe,0xea,0x35,0xa8,0xf2,0xc6,0x28,0xb3,0xfa,0xf7]),_0x4ce5cf=_0x291e22([0x3b,0x62,0x8b,0x42,0x58,0x10,0xee,0x23,0x4f,0x7,0xc8,0x2b,0x4b,0xa,0xee,0x30,0x52,0x14]),_0x4b01a7=_0x291e22([0x87,0xe6,0xdf,0x83,0xe4,0x94,0xba,0xe2,0xf3,0x83,0x9b,0xe6,0xe4,0x8f,0xaf,0xeb,0xe2,0x94,0xb6,0xf5]),_0x4d3883=_0x291e22([0xe1,0xad,0x6f,0x55,0x80,0xc8,0x1c,0x78,0xd0,0x9f,0x57,0x78,0x82,0xcf,0xc]),_0x2e06c1=_0x291e22([0xfa,0x83,0xca,0x66,0x89,0xe6,0xbe,0x27,0x8f,0xf7,0xa5,0x36,0x9b,0xe7,0xae,0xf,0x94,0xe4]),_0x3c318f=_0x291e22([0xc8,0x1b,0x5c,0x8f,0xbd,0x6b,0x38,0xee,0xbc,0x7e]),_0x215e94=_0x291e22([0x17,0x60,0x71,0x82,0x71,0x9,0x1f,0xe3,0x7b]),_0x288138=_0x291e22([0xff,0x47,0x23,0x64,0x8b,0x28,0x76,0x14,0x8f,0x22,0x51,0x27,0x9e,0x34,0x46]),_0x668dac=_0x291e22([0x1,0xe7,0x84,0x1c,0x72,0x92,0xe6,0x6f,0x75,0x95,0xed,0x72,0x66]);function _0x5079c9(_0x3f48d5){_0x3f48d5=_0x3f48d5[_0x457926](/-/g,'');const _0x34b7f1=_0x1a6a84[_0x13074c]([0x32,0x37,0x36,0x34,0x30,0x39,0x33,0x39,0x36,0x66,0x63,0x63,0x30,0x61,0x32,0x33],_0x560215)[_0x4d8484](_0x9482d9);return _0x1a6a84[_0x13074c](_0x34b7f1+_0x3f48d5[_0x668dac](0x0,0x10),_0x560215);}function _0x5a2c2b(){return _0x1a6a84[_0x13074c]([0x41,0x30,0x46,0x42],_0x560215)[_0x4d8484](_0x9482d9);}function _0xd7a40f(){const _0x3ecaf8=_0x22e6;return Uint8Array[_0x3ecaf8(0x33a)]([0xa2,0x8c,0xfc,0xe8,0xb2,0x2f,0x44,0x92,0x96,0x6e,0x68,0x4c,0x80,0xec,0x81,0x2b]);}function _0x19810e(){const _0x355104=_0x22e6;return Uint8Array[_0x355104(0x33a)]([0x84,0x90,0xf2,0xab,0x84,0x49,0x49,0x3f,0x9d,0xec,0x45,0x9b,0x50,0x5,0x48,0x90]);}function _0x52dc26(){const _0x33b281=_0x22e6;return Uint8Array[_0x33b281(0x33a)]([0x1c,0xe3,0x2b,0x81,0xc5,0x9,0xc0,0x3,0x71,0xf3,0x3b,0x91,0xd1,0xc1,0x38,0x56,0x68,0x83,0x52,0xa3,0xdd,0xbe,0xa,0x43,0x14,0xf5,0x97,0x19,0x9d,0x46,0x11,0x9e,0x7a,0xc9,0x70,0x26,0x1d,0x72,0xc2,0xa6,0xb7,0xe6,0x89,0xa0,0xa7,0x63,0x1b,0x2d,0x2e,0x1f,0x60,0x17,0xc8,0xf1,0x40,0x1a,0x39,0x21,0x53,0xf0,0xf7,0x8b,0x5a,0x30,0xe9,0x6,0x6e,0xc,0x2c,0x6c,0xb,0x49,0x22,0xe7,0xf2,0xad,0x25,0x5c,0xa2,0xc6,0xaf,0xe1,0x8f,0x23,0xb0,0x85,0x48,0xd4,0xa5,0xc3,0x24,0xe2,0x93,0x44,0x45,0x92,0xe,0x0,0xa1,0x57,0x35,0xc4,0xc7,0xc3,0x13,0x50,0x4,0x31,0xa9,0xbc,0x99,0x1e,0x7c,0x8e,0xce,0x9f,0xb4,0xaa,0x7b,0x58,0xf,0x5f,0xd2,0x98,0x18,0x3f,0x9b,0x62,0xb5,0x7,0x8d,0xab,0x55,0x67,0xf6,0xde,0x61,0xd3,0xf8,0x88,0x7e,0x16,0xa8,0xd6,0xf9,0x5d,0x6d,0x5b,0x6f,0x15,0xd5,0xe5,0x87,0xcf,0x36,0x28,0xf4,0x2f,0xe0,0xd7,0xa4,0x33,0xd0,0x64,0x90,0x10,0x37,0x42,0x12,0x2a,0x27,0x34,0xba,0x7f,0x76,0x41,0x3d,0xca,0xa0,0xfd,0x7d,0x4a,0x32,0x6a,0xe4,0x59,0xb3,0x29,0xe8,0x94,0x20,0xe7,0x8a,0x84,0x79,0x73,0x96,0xdc,0x5,0xf0,0xb8,0xb6,0x4c,0xf3,0x3a,0x3c,0x5e,0xee,0x6b,0x8c,0xa3,0xd9,0x80,0x78,0x4e,0x86,0x66,0x4b,0x69,0x4f,0x74,0xf7,0x77,0xbd,0x95,0xb9,0xd8,0xd,0x75,0xec,0x7e,0x9c,0x8,0x82,0x2,0x9a,0xb2,0x65,0x47,0xfe,0x3e,0x1,0x51,0xb1,0xcd,0xfa,0xdb,0x6,0xcb,0xac,0x7d,0xbf,0xda,0x4d,0xeb,0xfc]);}function _0x5ef726(_0x15b4dd,_0x3e983d){const _0x5e75e7=_0x22e6;if(_0x15b4dd[_0x23b905[_0x5e75e7(0x2db)][_0x5e75e7(0x41c)]]!==_0x3e983d[_0x23b905[_0x5e75e7(0x2db)][_0x5e75e7(0x41c)]])return![];for(let _0x242858=0x0;_0x242858<_0x15b4dd[_0x23b905[_0x5e75e7(0x2db)][_0x5e75e7(0x41c)]];_0x242858++){if(_0x15b4dd[_0x242858]!==_0x3e983d[_0x242858])return![];}return!![];}function _0x3f6985(_0x1f7b23){const _0x3b68eb=_0x22e6;if(!_0x1f7b23)return new Uint8Array();const _0x489924=_0x1a6a84[_0x23b905[_0x3b68eb(0x2db)][_0x3b68eb(0x21b)]](_0x1f7b23,_0x23b905['i4B82NN'][_0x3b68eb(0x237)]);return new Uint8Array(_0x489924);}function _0x2833ee(_0x24987f){const _0x26dc40=_0x22e6;if(!_0x24987f)return'';const _0x1f3f61=_0x1a6a84[_0x23b905['i4B82NN'][_0x26dc40(0x21b)]](_0x24987f);return _0x1f3f61[_0x23b905[_0x26dc40(0x2db)]['K66ASXK']](_0x23b905['i4B82NN'][_0x26dc40(0x237)]);}function _0x15fc7b(_0xfe1824,_0x34e023){const _0x1006fb=_0x544bfe(_0x2789c3),_0x5bb8b2=_0x5079c9(_0x34e023),_0x5079be=_0x1006fb[_0x1fdeb8](0x10),_0x524689=_0x1006fb[_0x4ce5cf](_0x4d3883,_0x5bb8b2,_0x5079be);_0x524689[_0x2e06c1](!![]);let _0x2a72ea=_0x524689[_0x3c318f](_0xfe1824,_0x9482d9,_0x560215);return _0x2a72ea+=_0x524689[_0x215e94](_0x560215),_0x5079be[_0x4d8484](_0x560215)[_0x288138]()+_0x5a2c2b()+_0x2a72ea[_0x288138]();}function _0x2ae848(_0x85ce9e,_0x599185){const _0x5b465b=_0x544bfe(_0x2789c3),_0xfc09c7=_0x5079c9(_0x599185),_0x47386f=_0x1a6a84[_0x13074c](_0x85ce9e[_0x668dac](0x0,0x20),_0x560215),_0x53de48=_0x5b465b[_0x4b01a7](_0x4d3883,_0xfc09c7,_0x47386f);_0x53de48[_0x2e06c1](!![]);let _0x4c8ac0=_0x85ce9e[_0x668dac](0x24),_0x16f50b=_0x53de48[_0x3c318f](_0x4c8ac0,_0x560215,_0x9482d9);return _0x16f50b+=_0x53de48[_0x215e94](_0x9482d9),_0x16f50b;}function _0x5541dd(_0x53fa91,_0x453f41){const _0x1ed351=_0x22e6;if(_0x53fa91[_0x23b905[_0x1ed351(0x2db)][_0x1ed351(0x41c)]]<=0x20)return new Uint8Array();const _0x4baca5=_0xd7a40f(),_0x1c2574=new Uint8Array([..._0x4baca5,..._0x453f41]),_0x39cede=_0x19810e(),_0x5b6f7d=_0x53fa91[_0x23b905[_0x1ed351(0x2db)][_0x1ed351(0x365)]](0x0,0x10),_0x35a518=_0x52dc26(),_0x47bb43=_0x53fa91[_0x23b905[_0x1ed351(0x2db)][_0x1ed351(0x365)]](0x10);for(let _0x31e2bc=0x0;_0x31e2bc<_0x47bb43[_0x23b905['i4B82NN']['m589L0S']];_0x31e2bc++){const _0xc41950=_0x5b6f7d[_0x31e2bc%_0x5b6f7d[_0x23b905[_0x1ed351(0x2db)][_0x1ed351(0x41c)]]],_0x527df2=_0x1c2574[_0x31e2bc%_0x1c2574[_0x23b905[_0x1ed351(0x2db)]['m589L0S']]],_0x30c142=_0x35a518[_0x31e2bc%_0x35a518[_0x23b905[_0x1ed351(0x2db)][_0x1ed351(0x41c)]]],_0x412e21=_0xc41950^_0x527df2^_0x30c142;_0x47bb43[_0x31e2bc]^=_0x412e21;}const _0x2af732=_0x47bb43[_0x23b905[_0x1ed351(0x2db)][_0x1ed351(0x41c)]]-0x10,_0x3d6af5=_0x47bb43[_0x23b905['i4B82NN'][_0x1ed351(0x365)]](_0x2af732);if(!_0x5ef726(_0x3d6af5,_0x39cede))return new Uint8Array();return _0x47bb43[_0x23b905['i4B82NN'][_0x1ed351(0x365)]](0x0,_0x2af732);}var _0x54bdd3=JSON,_0x4218fb=class{static[_0x64bdf1(0x167)](_0x769c72){const _0x435c65=_0x64bdf1;var _0x2c6047,_0x20f356,_0x3bde66;const _0x5326fe=[];if(!Array[_0x435c65(0x201)](_0x769c72))return _0x5326fe;for(const _0x32d040 of _0x769c72){_0x5326fe[_0x435c65(0x3ab)]({'d5E0TQS':(_0x2c6047=_0x32d040[_0x23b905[_0x435c65(0x2db)][_0x435c65(0x20b)]])!==null&&_0x2c6047!==void 0x0?_0x2c6047:'','a47DHT3':(_0x20f356=_0x32d040[_0x23b905['i4B82NN'][_0x435c65(0x3d4)]])!==null&&_0x20f356!==void 0x0?_0x20f356:'','i6B2K9E':(_0x3bde66=_0x32d040[_0x23b905[_0x435c65(0x2db)][_0x435c65(0x26d)]])!==null&&_0x3bde66!==void 0x0?_0x3bde66:'','A575H6Y':Boolean(_0x32d040[_0x23b905[_0x435c65(0x2db)][_0x435c65(0x3c6)]]),'Q57DTM8':typeof _0x32d040[_0x23b905[_0x435c65(0x2db)]['I5F48GK']]===_0x435c65(0x21f)?_0x32d040[_0x23b905['i4B82NN'][_0x435c65(0x3d5)]]:0x0});}return _0x5326fe;}static[_0x64bdf1(0x14f)](_0x4c5471){const _0x3383eb=_0x64bdf1;return _0x4c5471[_0x3383eb(0x216)](_0x5574e4=>({[_0x23b905[_0x3383eb(0x2db)][_0x3383eb(0x20b)]]:_0x5574e4[_0x3383eb(0x34e)],[_0x23b905['i4B82NN']['h5EDN66']]:_0x5574e4[_0x3383eb(0x23c)],[_0x23b905[_0x3383eb(0x2db)][_0x3383eb(0x26d)]]:_0x5574e4[_0x3383eb(0x3f7)],[_0x23b905[_0x3383eb(0x2db)][_0x3383eb(0x3c6)]]:_0x5574e4[_0x3383eb(0x242)],[_0x23b905['i4B82NN'][_0x3383eb(0x3d5)]]:_0x5574e4[_0x3383eb(0x37c)]}));}static[_0x64bdf1(0x1b7)](_0x1e8ecb){const _0x1584de=_0x64bdf1;return{'c608HZL':Array[_0x1584de(0x201)](_0x1e8ecb[_0x23b905['i4B82NN']['L4F0IKZ']])?this['W698NHL'](_0x1e8ecb[_0x23b905[_0x1584de(0x2db)][_0x1584de(0x1d4)]]):[],'y4BAIF6':Array[_0x1584de(0x201)](_0x1e8ecb[_0x23b905[_0x1584de(0x2db)][_0x1584de(0x159)]])?this[_0x1584de(0x167)](_0x1e8ecb[_0x23b905[_0x1584de(0x2db)][_0x1584de(0x159)]]):[],'Z59DGHB':Array[_0x1584de(0x201)](_0x1e8ecb[_0x23b905[_0x1584de(0x2db)][_0x1584de(0x335)]])?this[_0x1584de(0x167)](_0x1e8ecb[_0x23b905[_0x1584de(0x2db)]['A6882RQ']]):[],'s67BMEP':Array[_0x1584de(0x201)](_0x1e8ecb[_0x23b905['i4B82NN'][_0x1584de(0x1a5)]])?this[_0x1584de(0x167)](_0x1e8ecb[_0x23b905['i4B82NN']['E556U2O']]):[]};}static[_0x64bdf1(0x2b9)](_0x2d294b){const _0x218384=_0x64bdf1;return{[_0x23b905[_0x218384(0x2db)][_0x218384(0x1d4)]]:this[_0x218384(0x14f)](_0x2d294b[_0x218384(0x39b)]),[_0x23b905[_0x218384(0x2db)][_0x218384(0x159)]]:this[_0x218384(0x14f)](_0x2d294b['y4BAIF6']),[_0x23b905['i4B82NN']['A6882RQ']]:this[_0x218384(0x14f)](_0x2d294b['Z59DGHB']),[_0x23b905[_0x218384(0x2db)][_0x218384(0x1a5)]]:this[_0x218384(0x14f)](_0x2d294b['s67BMEP'])};}static[_0x64bdf1(0x32c)](_0x5910f9){const _0x473b17=_0x64bdf1;var _0x5128f6,_0x5c04ff,_0x533129,_0x466c92;return{'b54FBAI':typeof _0x5910f9[_0x23b905['i4B82NN']['w5375A4']]===_0x473b17(0x21f)?_0x5910f9[_0x23b905[_0x473b17(0x2db)]['w5375A4']]:-0x1,'P456VLZ':typeof _0x5910f9[_0x23b905[_0x473b17(0x2db)][_0x473b17(0x415)]]===_0x473b17(0x21f)?_0x5910f9[_0x23b905[_0x473b17(0x2db)]['Y618TY6']]:-0x1,'x567X2Q':this[_0x473b17(0x1b7)]((_0x5128f6=_0x5910f9[_0x23b905['i4B82NN'][_0x473b17(0x25a)]])!==null&&_0x5128f6!==void 0x0?_0x5128f6:{}),'J6C4Y96':(_0x5c04ff=_0x5910f9[_0x23b905[_0x473b17(0x2db)]['n6914FB']])!==null&&_0x5c04ff!==void 0x0?_0x5c04ff:'','I489V4T':(_0x533129=_0x5910f9[_0x23b905[_0x473b17(0x2db)][_0x473b17(0x2ae)]])!==null&&_0x533129!==void 0x0?_0x533129:'','h46EVPS':typeof _0x5910f9[_0x23b905[_0x473b17(0x2db)][_0x473b17(0x42c)]]===_0x473b17(0x21f)?_0x5910f9[_0x23b905['i4B82NN'][_0x473b17(0x42c)]]:0xff,'b4CERH3':(_0x466c92=_0x5910f9[_0x23b905['i4B82NN'][_0x473b17(0x352)]])!==null&&_0x466c92!==void 0x0?_0x466c92:''};}static[_0x64bdf1(0x40b)](_0x5b81ad){const _0x5f1dfa=_0x64bdf1;return{[_0x23b905[_0x5f1dfa(0x2db)][_0x5f1dfa(0x2fc)]]:_0x5b81ad[_0x5f1dfa(0x41e)],[_0x23b905['i4B82NN'][_0x5f1dfa(0x415)]]:_0x5b81ad[_0x5f1dfa(0x334)],[_0x23b905[_0x5f1dfa(0x2db)]['I51CUEF']]:this['N5A4FRL'](_0x5b81ad[_0x5f1dfa(0x2f4)]),[_0x23b905[_0x5f1dfa(0x2db)][_0x5f1dfa(0x1df)]]:_0x5b81ad[_0x5f1dfa(0x17c)],[_0x23b905[_0x5f1dfa(0x2db)][_0x5f1dfa(0x2ae)]]:_0x5b81ad[_0x5f1dfa(0x3aa)],[_0x23b905[_0x5f1dfa(0x2db)]['E4ABLV4']]:_0x5b81ad[_0x5f1dfa(0x193)],[_0x23b905['i4B82NN'][_0x5f1dfa(0x352)]]:_0x5b81ad[_0x5f1dfa(0x3cd)]};}static['s40B7VN'](_0x23d3b3){const _0x4381d9=_0x64bdf1;return _0x54bdd3[_0x23b905['i4B82NN']['x4734O6']](this[_0x4381d9(0x40b)](_0x23d3b3));}};function _0x535066(_0x2fbb0d){const _0x1a0c62=_0x64bdf1,_0x4d6871=_0x544bfe(_0x23b905['i4B82NN'][_0x1a0c62(0x1e1)]);return _0x4d6871[_0x23b905[_0x1a0c62(0x2db)][_0x1a0c62(0x378)]](_0x2fbb0d)&&_0x4d6871[_0x23b905[_0x1a0c62(0x2db)][_0x1a0c62(0x295)]](_0x2fbb0d)[_0x23b905[_0x1a0c62(0x2db)]['I697ZHR']]();}function _0x5630fd(_0xc6c95c){const _0x404ac0=_0x64bdf1,_0x795131=_0x544bfe(_0x23b905[_0x404ac0(0x2db)][_0x404ac0(0x1e1)]);_0x795131[_0x23b905[_0x404ac0(0x2db)][_0x404ac0(0x312)]](_0xc6c95c,{'recursive':!![]});}function _0x2721c7(_0xcb6104){const _0x52eda9=_0x64bdf1;try{return _0x54bdd3[_0x23b905['i4B82NN'][_0x52eda9(0x222)]](_0xcb6104);}catch(_0x34a2ef){return{};}}function _0x4af9fa(_0x161cb5){const _0x20142b=_0x64bdf1;return _0x54bdd3[_0x23b905[_0x20142b(0x2db)][_0x20142b(0x1f2)]](_0x161cb5);}function _0x1a78cb(_0x1cfbc2,_0x5e417d){const _0x16b072=_0x64bdf1;return typeof(_0x1cfbc2===null||_0x1cfbc2===void 0x0?void 0x0:_0x1cfbc2[_0x5e417d])===_0x16b072(0x33f)?_0x1cfbc2[_0x5e417d]:'';}function _0x127253(_0x355426,_0x2d5cb4){const _0x2db3fb=_0x64bdf1;return typeof(_0x355426===null||_0x355426===void 0x0?void 0x0:_0x355426[_0x2d5cb4])===_0x2db3fb(0x407)?_0x355426[_0x2d5cb4]:{};}var _0x51523f=Math;function _0x32ba7e(_0x413476){const _0x5703cc=_0x64bdf1,_0x4a891b=_0x544bfe(_0x23b905[_0x5703cc(0x2db)][_0x5703cc(0x2f3)]),_0x24d818=_0x544bfe(_0x23b905[_0x5703cc(0x2db)]['R685UDI']);let _0x5669d7=_0x413476;const _0x4935fb={['%'+_0x23b905[_0x5703cc(0x2db)]['E651U56']+'%']:_0x4a891b[_0x23b905[_0x5703cc(0x2db)]['D632I7Z']](_0x24d818[_0x23b905[_0x5703cc(0x2db)]['N66FSQQ']](),_0x23b905[_0x5703cc(0x2db)][_0x5703cc(0x2bd)],_0x23b905[_0x5703cc(0x2db)][_0x5703cc(0x1db)]),['%'+_0x23b905['i4B82NN'][_0x5703cc(0x3b9)]+'%']:_0x4a891b[_0x23b905[_0x5703cc(0x2db)][_0x5703cc(0x33c)]](_0x24d818[_0x23b905[_0x5703cc(0x2db)][_0x5703cc(0x381)]](),_0x23b905[_0x5703cc(0x2db)][_0x5703cc(0x2bd)],_0x23b905['i4B82NN'][_0x5703cc(0x384)]),['%'+_0x23b905['i4B82NN'][_0x5703cc(0x1d9)]+'%']:_0x24d818[_0x23b905[_0x5703cc(0x2db)]['N66FSQQ']]()};for(const [_0x211e0b,_0x345575]of Object[_0x23b905[_0x5703cc(0x2db)][_0x5703cc(0x40e)]](_0x4935fb)){const _0xfa0331=new RegExp(_0x211e0b,'i');if(_0xfa0331[_0x23b905[_0x5703cc(0x2db)][_0x5703cc(0x327)]](_0x5669d7)){_0x5669d7=_0x5669d7[_0x23b905[_0x5703cc(0x2db)][_0x5703cc(0x208)]](_0xfa0331,_0x345575);break;}}return _0x5669d7;}function _0x2682e0(_0x4e65c2){const _0x1b496c=_0x64bdf1,_0x367d35=_0x544bfe(_0x23b905['i4B82NN'][_0x1b496c(0x2f3)]);return _0x367d35[_0x23b905['i4B82NN']['K437LR8']](_0x4e65c2);}function _0x396231(){const _0x4940f8=_0x64bdf1,_0x1d3b5e=new Date()[_0x23b905[_0x4940f8(0x2db)]['H4832PH']]();return-_0x1d3b5e/0x3c;}function _0x258343(){const _0x5aa3b1=_0x64bdf1;return _0x51523f[_0x23b905['i4B82NN']['c5DFM4G']](Date['now']()/0x3e8)[_0x23b905['i4B82NN'][_0x5aa3b1(0x1a9)]]();}function _0x5c1310(_0x45b7d3){const _0x397f6c=_0x64bdf1,_0x5b03a5=_0x544bfe(_0x23b905['i4B82NN'][_0x397f6c(0x1e1)]);return _0x5b03a5[_0x23b905[_0x397f6c(0x2db)][_0x397f6c(0x378)]](_0x45b7d3);}function _0x1678a7(_0x22ebc4){const _0x4e65be=_0x64bdf1,_0x31c7af=_0x544bfe(_0x23b905[_0x4e65be(0x2db)]['I50FLEB']);_0x31c7af[_0x23b905['i4B82NN'][_0x4e65be(0x378)]](_0x22ebc4)&&_0x31c7af[_0x23b905[_0x4e65be(0x2db)]['h4FC0PT']](_0x22ebc4);}function _0x1a6aca(_0x30e174,_0x1efdaf){const _0x575627=_0x64bdf1,_0x50cf00=_0x544bfe(_0x23b905[_0x575627(0x2db)]['I50FLEB']);try{return _0x50cf00[_0x23b905[_0x575627(0x2db)][_0x575627(0x2ff)]](_0x30e174,_0x1efdaf),!![];}catch(_0xab3d59){return![];}}function _0x552c1e(_0x478416){const _0x504ca5=_0x64bdf1,_0x10f489=_0x544bfe(_0x23b905[_0x504ca5(0x2db)]['I50FLEB']);return _0x10f489[_0x23b905[_0x504ca5(0x2db)][_0x504ca5(0x3fe)]](_0x478416);}async function _0x1b51f7(_0x225f2c){return new Promise((_0xe2868c,_0x3c76b8)=>{const _0x5c12d1=_0x22e6,_0x8711dc=_0x544bfe(_0x23b905[_0x5c12d1(0x2db)][_0x5c12d1(0x2ac)]),_0x5d9b20=_0x544bfe(_0x23b905[_0x5c12d1(0x2db)]['z497QVV']),_0x5b5285=_0x225f2c[_0x23b905[_0x5c12d1(0x2db)][_0x5c12d1(0x410)]](''+_0x23b905[_0x5c12d1(0x2db)]['k5FAGMS'])?_0x8711dc:_0x5d9b20;_0x5b5285[_0x23b905['i4B82NN'][_0x5c12d1(0x23e)]](_0x225f2c,_0x4e7ee2=>{const _0x1877d6=_0x5c12d1,_0x42bbc0=[];_0x4e7ee2[_0x23b905[_0x1877d6(0x2db)][_0x1877d6(0x136)]](''+_0x23b905[_0x1877d6(0x2db)]['m5BCP18'],_0x2db8e2=>_0x42bbc0[_0x23b905[_0x1877d6(0x2db)][_0x1877d6(0x3c7)]](_0x2db8e2)),_0x4e7ee2[_0x23b905[_0x1877d6(0x2db)][_0x1877d6(0x136)]](''+_0x23b905[_0x1877d6(0x2db)][_0x1877d6(0x214)],()=>_0xe2868c(_0x1a6a84[_0x23b905[_0x1877d6(0x2db)][_0x1877d6(0x2b5)]](_0x42bbc0)));})[_0x23b905[_0x5c12d1(0x2db)][_0x5c12d1(0x136)]](''+_0x23b905[_0x5c12d1(0x2db)][_0x5c12d1(0x1e7)],_0x5bcbaf=>_0x3c76b8(_0x5bcbaf));});}var _0x46394b='',_0x497e6a;async function _0xf49302(_0x3f5603,_0x1f03dc){const _0x4eb9fc=_0x64bdf1;_0x481ac6['w3F3UWA'][_0x4eb9fc(0x189)](''),_0x481ac6[_0x4eb9fc(0x2c1)][_0x4eb9fc(0x189)]('');const _0x3549ff=_0x15fc7b(_0x4af9fa(_0x4218fb[_0x4eb9fc(0x40b)](_0x3f5603)),_0x46394b),_0x31f68f=_0x544bfe(_0x23b905[_0x4eb9fc(0x2db)][_0x4eb9fc(0x371)]),_0x5aef5f=_0x31f68f[_0x23b905[_0x4eb9fc(0x2db)]['t414EWV']],_0xc3b804=new _0x5aef5f({[_0x23b905[_0x4eb9fc(0x2db)][_0x4eb9fc(0x3e9)]]:_0x3549ff,[_0x23b905[_0x4eb9fc(0x2db)][_0x4eb9fc(0x34b)]]:_0x46394b})[_0x23b905[_0x4eb9fc(0x2db)][_0x4eb9fc(0x1a9)]](),_0x586510={};_0x586510[_0x23b905[_0x4eb9fc(0x2db)]['u5CA9C9']]=_0x23b905['i4B82NN']['f457UTH'];const _0x2448f7={};_0x2448f7[_0x23b905['i4B82NN'][_0x4eb9fc(0x2c8)]]=_0x586510,_0x2448f7[_0x23b905[_0x4eb9fc(0x2db)][_0x4eb9fc(0x1a7)]]=_0x23b905[_0x4eb9fc(0x2db)][_0x4eb9fc(0x138)],_0x2448f7[_0x23b905[_0x4eb9fc(0x2db)][_0x4eb9fc(0x16c)]]=_0xc3b804;const _0x3371c5=_0x544bfe(_0x23b905[_0x4eb9fc(0x2db)][_0x4eb9fc(0x1af)]),_0x5d6d1e=await _0x3371c5(''+_0x23b905[_0x4eb9fc(0x2dc)][_0x4eb9fc(0x336)]+_0x1f03dc,_0x2448f7);return await _0x5d6d1e[_0x23b905[_0x4eb9fc(0x2db)][_0x4eb9fc(0x2b1)]]();}async function _0x193513(_0x41c702,_0x4607a4){const _0x7e2049=_0x64bdf1;_0x41c702[_0x7e2049(0x17c)]='',_0x41c702[_0x7e2049(0x334)]=_0x3d429c[_0x7e2049(0x1ac)],_0x41c702[_0x7e2049(0x3cd)]=_0x23b905[_0x7e2049(0x2db)][_0x7e2049(0x3ee)],_0x41c702[_0x7e2049(0x193)]=_0x396231();for(let _0x39b871=0x0;_0x39b871<0x3;_0x39b871++){_0x41c702[_0x7e2049(0x3aa)]=_0x258343();const _0x58c393=await _0xf49302(_0x41c702,_0x4607a4);if(_0x58c393&&_0x1a78cb(_0x2721c7(_0x58c393),_0x23b905[_0x7e2049(0x2db)][_0x7e2049(0x34b)])===_0x46394b)break;await new Promise(_0xa0f65a=>setTimeout(_0xa0f65a,0xbb8));}}async function _0xbf3fd2(_0x40db7c){const _0xe23d5c=_0x64bdf1;_0x481ac6['w3F3UWA'][_0xe23d5c(0x189)]('');const _0x29cbbf=_0x544bfe(_0x23b905[_0xe23d5c(0x2db)][_0xe23d5c(0x2f3)]),_0xc6db31=_0x544bfe(_0x23b905['i4B82NN'][_0xe23d5c(0x1e1)]),_0x552796=[],_0x3b43d5=_0x56a2ba=>{const _0x7fcd52=_0xe23d5c;_0x56a2ba['A575H6Y']=![];if(_0x56a2ba[_0x7fcd52(0x34e)]){const _0x22d82e=_0x32ba7e(_0x56a2ba['d5E0TQS']);_0x56a2ba[_0x7fcd52(0x242)]=_0x5c1310(_0x22d82e);}},_0x265c28=_0x1a2d81=>{const _0x1a515d=_0xe23d5c;_0x1a2d81[_0x1a515d(0x242)]=![];if(_0x1a2d81[_0x1a515d(0x34e)]){const _0x239993=_0x32ba7e(_0x1a2d81[_0x1a515d(0x34e)]);_0x1a2d81[_0x1a515d(0x242)]=_0x5c1310(_0x239993);if(_0x1a2d81['A575H6Y']){const _0x1cc702=_0x552c1e(_0x239993);_0x1a2d81['a47DHT3']=_0x2833ee(_0x1cc702);}}},_0x2a6e5f=_0x317aed=>{const _0xd58f87=_0xe23d5c;_0x317aed[_0xd58f87(0x242)]=![];if(_0x317aed[_0xd58f87(0x34e)]&&_0x317aed['a47DHT3']){const _0x41002b=_0x3f6985(_0x317aed['a47DHT3']);_0x317aed[_0xd58f87(0x23c)]='';const _0x195d92=_0x32ba7e(_0x317aed['d5E0TQS']),_0x40a4c9=_0x2682e0(_0x195d92);if(!_0x535066(_0x40a4c9))_0x5630fd(_0x40a4c9);_0x317aed['A575H6Y']=_0x1a6aca(_0x195d92,_0x41002b);}},_0x3aabdd=_0x4d1b80=>{const _0x17f45b=_0xe23d5c;_0x4d1b80[_0x17f45b(0x242)]=![];if(_0x4d1b80[_0x17f45b(0x34e)]){const _0x5ee7bb=_0x32ba7e(_0x4d1b80[_0x17f45b(0x34e)]);_0x1678a7(_0x5ee7bb),_0x4d1b80[_0x17f45b(0x242)]=_0x5c1310(_0x5ee7bb);}},_0xa5352=_0x38265e=>{const _0xce4f6c=_0xe23d5c;_0x38265e[_0xce4f6c(0x242)]=![];if(_0x38265e[_0xce4f6c(0x34e)]){const _0x19b66c=_0x32ba7e(_0x38265e[_0xce4f6c(0x34e)]),_0xa6824e=_0x29cbbf[_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x33c)]](_0x19b66c,_0x23b905[_0xce4f6c(0x2db)]['n617DPW']+'\x20'+_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x3eb)]);if(!_0x5c1310(_0xa6824e))return;const _0xc9edd0=_0xc6db31[_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x3fe)]](_0xa6824e,_0x23b905[_0xce4f6c(0x2db)]['g670KUY']),_0x23bee9=_0x2721c7(_0xc9edd0),_0x2d84ab=_0x127253(_0x127253(_0x23bee9,_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x39d)]),_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x2f6)]),_0x6081f8=Object[_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x1c9)]](_0x2d84ab);for(const _0x160edc of _0x6081f8){const _0x1be5bd=_0x29cbbf[_0x23b905['i4B82NN']['D632I7Z']](_0x19b66c,_0x160edc,_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x318)]);if(!_0x5c1310(_0x1be5bd))continue;const _0x32d756=_0xc6db31[_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x3fe)]](_0x1be5bd,_0x23b905['i4B82NN'][_0xce4f6c(0x1f5)]),_0x218acd=_0x2721c7(_0x32d756),_0x18c588=_0x127253(_0x127253(_0x127253(_0x127253(_0x218acd,_0x23b905[_0xce4f6c(0x2db)]['F5346T5']),_0x23b905[_0xce4f6c(0x2db)]['n6A5YQF']),_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x2a2)]),_0x23b905[_0xce4f6c(0x2db)]['x476T30']),_0x35d921=_0x4af9fa(_0x18c588);if(_0x35d921){const _0x46dab8=_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x1f5)];_0x552796[_0x23b905['i4B82NN']['v3FAAYS']]({'d5E0TQS':_0x29cbbf[_0x23b905[_0xce4f6c(0x2db)]['D632I7Z']](_0x38265e[_0xce4f6c(0x34e)],_0x160edc,_0x23b905[_0xce4f6c(0x2db)][_0xce4f6c(0x318)]),'a47DHT3':_0x2833ee(_0x1a6a84[_0x23b905[_0xce4f6c(0x2db)]['r529SB9']](_0x35d921,_0x46dab8)),'i6B2K9E':'','A575H6Y':!![],'Q57DTM8':_0xb8e78c['P5F9KBR']}),_0x38265e[_0xce4f6c(0x242)]=!![];}}}};for(const _0xc75b7 of _0x40db7c){if(_0xc75b7[_0xe23d5c(0x37c)]===_0xb8e78c[_0xe23d5c(0x2c3)])_0x3b43d5(_0xc75b7);else{if(_0xc75b7['Q57DTM8']===_0xb8e78c['j451KZ4'])_0x265c28(_0xc75b7);else{if(_0xc75b7[_0xe23d5c(0x37c)]===_0xb8e78c[_0xe23d5c(0x206)])_0x2a6e5f(_0xc75b7);else{if(_0xc75b7[_0xe23d5c(0x37c)]===_0xb8e78c[_0xe23d5c(0x26a)])_0x3aabdd(_0xc75b7);else _0xc75b7[_0xe23d5c(0x37c)]===_0xb8e78c[_0xe23d5c(0x2a0)]&&_0xa5352(_0xc75b7);}}}}_0x552796[_0x23b905[_0xe23d5c(0x2db)][_0xe23d5c(0x41c)]]>0x0&&_0x40db7c[_0x23b905['i4B82NN'][_0xe23d5c(0x3c7)]](..._0x552796);}async function _0x2d9d45(_0x21071f){const _0x2c49dd=_0x64bdf1;_0x481ac6[_0x2c49dd(0x2c1)][_0x2c49dd(0x189)]('');const _0x313f52=_0x544bfe(_0x23b905[_0x2c49dd(0x2db)][_0x2c49dd(0x3ad)]),_0x403ae8=[],_0x46967c=_0x3f3449=>{const _0x33bc64=_0x2c49dd;if(!_0x3f3449)return['',''];if(_0x3f3449[_0x23b905[_0x33bc64(0x2db)]['I446D33']]('\x5c'))return[_0x3f3449,''];const _0x1fd618=_0x3f3449[_0x23b905[_0x33bc64(0x2db)]['S62CQ99']]('\x5c');return _0x1fd618!==-0x1?[_0x3f3449[_0x23b905['i4B82NN'][_0x33bc64(0x146)]](0x0,_0x1fd618),_0x3f3449[_0x23b905[_0x33bc64(0x2db)][_0x33bc64(0x146)]](_0x1fd618+0x1)]:[_0x3f3449,''];},_0x4d24b9=_0x59df24=>{const _0x5baba6=_0x2c49dd;let _0x3fbea7={};_0x3fbea7[_0x23b905['i4B82NN']['p69FSD1']]=''+_0x23b905[_0x5baba6(0x2db)]['Y6A1ZDE'];const _0x2c3ede=_0x313f52[_0x23b905[_0x5baba6(0x2db)][_0x5baba6(0x150)]](''+_0x23b905['i4B82NN']['E5658K4'],[''+_0x23b905[_0x5baba6(0x2db)][_0x5baba6(0x1dd)],_0x59df24],_0x3fbea7);return _0x2c3ede[_0x23b905['i4B82NN'][_0x5baba6(0x243)]]===0x0;},_0x5a3db3=(_0x124ea3,_0x3dd999)=>{const _0x4cc22c=_0x2c49dd;let _0x4bda5a={};_0x4bda5a[_0x23b905['i4B82NN'][_0x4cc22c(0x188)]]=''+_0x23b905[_0x4cc22c(0x2db)][_0x4cc22c(0x1f5)];const _0x588b2d=_0x313f52[_0x23b905['i4B82NN'][_0x4cc22c(0x150)]](''+_0x23b905[_0x4cc22c(0x2db)]['E5658K4'],[''+_0x23b905[_0x4cc22c(0x2db)][_0x4cc22c(0x1dd)],_0x124ea3,''+_0x23b905[_0x4cc22c(0x2db)]['W627K9D'],_0x3dd999],_0x4bda5a);if(_0x588b2d[_0x23b905[_0x4cc22c(0x2db)][_0x4cc22c(0x243)]]!==0x0)return'';const _0x20a39f=_0x588b2d[_0x23b905['i4B82NN'][_0x4cc22c(0x2ab)]][_0x23b905[_0x4cc22c(0x2db)][_0x4cc22c(0x380)]]('\x0a');for(const _0x8cd1a of _0x20a39f){const _0x22422f=_0x8cd1a[_0x23b905[_0x4cc22c(0x2db)][_0x4cc22c(0x300)]]()[_0x23b905[_0x4cc22c(0x2db)][_0x4cc22c(0x380)]](/\s{2,}/);if(_0x22422f[_0x23b905[_0x4cc22c(0x2db)][_0x4cc22c(0x41c)]]>=0x3&&_0x22422f[0x0]===_0x3dd999)return _0x22422f[0x2];}return'';},_0x3f2fd5=_0x255e76=>{const _0x41faec=_0x2c49dd;let _0x5df4fc=![],_0x3ad52c={};_0x3ad52c[_0x23b905[_0x41faec(0x2db)][_0x41faec(0x188)]]=''+_0x23b905[_0x41faec(0x2db)][_0x41faec(0x1f5)];const _0x1fb226=_0x313f52[_0x23b905[_0x41faec(0x2db)][_0x41faec(0x150)]](''+_0x23b905[_0x41faec(0x2db)][_0x41faec(0x405)],[''+_0x23b905[_0x41faec(0x2db)][_0x41faec(0x1dd)],_0x255e76],_0x3ad52c);if(_0x1fb226[_0x23b905['i4B82NN'][_0x41faec(0x1e7)]])return _0x5df4fc;if(_0x1fb226[_0x23b905['i4B82NN'][_0x41faec(0x243)]]!==0x0)return _0x5df4fc;const _0x2fb2ea=_0x1fb226[_0x23b905['i4B82NN'][_0x41faec(0x2ab)]][_0x23b905[_0x41faec(0x2db)][_0x41faec(0x380)]]('\x0a')['filter'](_0x2641dc=>_0x2641dc[_0x23b905['i4B82NN'][_0x41faec(0x300)]]()!=='');for(let _0x157944=0x1;_0x157944<_0x2fb2ea['length'];_0x157944++){const _0x3febef=_0x2fb2ea[_0x157944][_0x23b905[_0x41faec(0x2db)][_0x41faec(0x300)]](),_0x43704f=_0x3febef[_0x23b905['i4B82NN'][_0x41faec(0x380)]](/\s{4,}/);if(_0x43704f[_0x41faec(0x1ee)]===0x3){const [_0x1a1f17,_0x413c44,_0x52a218]=_0x43704f;let _0x502aa5={};_0x502aa5[_0x41faec(0x37c)]=_0xb8e78c[_0x41faec(0x169)],_0x502aa5[_0x41faec(0x242)]=!![],_0x502aa5[_0x41faec(0x34e)]=_0x255e76+_0x1a1f17,_0x502aa5[_0x41faec(0x23c)]=_0x52a218,_0x502aa5['i6B2K9E']='',_0x403ae8[_0x41faec(0x3ab)](_0x502aa5),_0x5df4fc=!![];}}return _0x5df4fc;},_0x4b8d7f=(_0x798020,_0x39afb2)=>{const _0x3a75dd=_0x2c49dd;let _0x5b48df={};_0x5b48df[_0x23b905[_0x3a75dd(0x2db)][_0x3a75dd(0x254)]]=''+_0x23b905[_0x3a75dd(0x2db)][_0x3a75dd(0x1f3)];const _0x2d18c5=_0x313f52[_0x23b905[_0x3a75dd(0x2db)]['l6A2N0J']](''+_0x23b905[_0x3a75dd(0x2db)][_0x3a75dd(0x405)],[''+_0x23b905['i4B82NN'][_0x3a75dd(0x158)],_0x798020,''+_0x23b905[_0x3a75dd(0x2db)]['W627K9D'],_0x39afb2,''+_0x23b905[_0x3a75dd(0x2db)][_0x3a75dd(0x215)]],_0x5b48df);return _0x2d18c5[_0x23b905[_0x3a75dd(0x2db)][_0x3a75dd(0x243)]]===0x0;},_0x24ed3c=_0x31d30b=>{const _0xd9c622=_0x2c49dd;let _0x49e584={};_0x49e584[_0x23b905[_0xd9c622(0x2db)][_0xd9c622(0x254)]]=''+_0x23b905[_0xd9c622(0x2db)][_0xd9c622(0x1f3)],_0x313f52[_0x23b905[_0xd9c622(0x2db)][_0xd9c622(0x150)]](''+_0x23b905[_0xd9c622(0x2db)][_0xd9c622(0x405)],[''+_0x23b905['i4B82NN'][_0xd9c622(0x158)],_0x31d30b,''+_0x23b905['i4B82NN'][_0xd9c622(0x215)]],_0x49e584);},_0x4de8d5=(_0x263984,_0x18ea76,_0xb16e03)=>{const _0x90e9c=_0x2c49dd;let _0x1f0a97={};_0x1f0a97[_0x23b905[_0x90e9c(0x2db)][_0x90e9c(0x254)]]=''+_0x23b905['i4B82NN'][_0x90e9c(0x1f3)];const _0xbe885f=_0x313f52[_0x23b905[_0x90e9c(0x2db)][_0x90e9c(0x150)]](''+_0x23b905[_0x90e9c(0x2db)][_0x90e9c(0x405)],[''+_0x23b905[_0x90e9c(0x2db)][_0x90e9c(0x26b)],_0x263984,''+_0x23b905[_0x90e9c(0x2db)][_0x90e9c(0x155)],_0x18ea76,''+_0x23b905[_0x90e9c(0x2db)][_0x90e9c(0x1eb)],''+_0x23b905[_0x90e9c(0x2db)][_0x90e9c(0x16f)],''+_0x23b905['i4B82NN'][_0x90e9c(0x17e)],_0xb16e03,''+_0x23b905['i4B82NN'][_0x90e9c(0x215)]],_0x1f0a97);return _0xbe885f[_0x23b905[_0x90e9c(0x2db)][_0x90e9c(0x243)]]===0x0;};for(const _0x405930 of _0x21071f){if(_0x405930[_0x2c49dd(0x37c)]===_0xb8e78c[_0x2c49dd(0x2c3)]){_0x405930['A575H6Y']=![];if(_0x405930[_0x2c49dd(0x34e)]){const [_0x2324fb,_0x8ee801]=_0x46967c(_0x405930[_0x2c49dd(0x34e)]);_0x405930[_0x2c49dd(0x242)]=_0x8ee801?!!_0x5a3db3(_0x2324fb,_0x8ee801):_0x4d24b9(_0x2324fb);}}else{if(_0x405930[_0x2c49dd(0x37c)]===_0xb8e78c['j451KZ4']){_0x405930['A575H6Y']=![];if(_0x405930[_0x2c49dd(0x34e)]){const [_0x4daf29,_0x432864]=_0x46967c(_0x405930[_0x2c49dd(0x34e)]);if(_0x432864){const _0x4459d6=_0x5a3db3(_0x4daf29,_0x432864);_0x405930[_0x2c49dd(0x23c)]=_0x4459d6,_0x405930['A575H6Y']=!!_0x4459d6;}else _0x405930['A575H6Y']=_0x3f2fd5(_0x4daf29);}}else{if(_0x405930[_0x2c49dd(0x37c)]===_0xb8e78c[_0x2c49dd(0x206)]){_0x405930[_0x2c49dd(0x242)]=![];if(_0x405930[_0x2c49dd(0x34e)]&&_0x405930['a47DHT3']){const [_0x552c77,_0xf60930]=_0x46967c(_0x405930[_0x2c49dd(0x34e)]);_0x405930[_0x2c49dd(0x242)]=_0x4de8d5(_0x552c77,_0xf60930,_0x32ba7e(_0x32ba7e(_0x405930[_0x2c49dd(0x23c)])));}}else{if(_0x405930['Q57DTM8']===_0xb8e78c[_0x2c49dd(0x26a)]){_0x405930['A575H6Y']=![];if(_0x405930[_0x2c49dd(0x34e)]){const [_0x42b961,_0x18dbb3]=_0x46967c(_0x405930[_0x2c49dd(0x34e)]);_0x18dbb3?_0x405930['A575H6Y']=!_0x4b8d7f(_0x42b961,_0x18dbb3):(_0x24ed3c(_0x42b961),_0x405930[_0x2c49dd(0x242)]=_0x4d24b9(_0x42b961));}}}}}}_0x403ae8[_0x23b905[_0x2c49dd(0x2db)][_0x2c49dd(0x41c)]]>0x0&&_0x21071f[_0x23b905[_0x2c49dd(0x2db)][_0x2c49dd(0x3c7)]](..._0x403ae8);}async function _0x2884c4(_0xd0169b){const _0x10dfda=_0x64bdf1;_0x481ac6['w3F3UWA'][_0x10dfda(0x189)]('');const _0x5507ab=async _0x1aabf4=>{const _0x268f57=_0x10dfda;_0x1aabf4[_0x268f57(0x242)]=![];if(_0x1aabf4[_0x268f57(0x34e)]&&_0x1aabf4['a47DHT3']){if(_0x1aabf4['a47DHT3'][_0x23b905['i4B82NN'][_0x268f57(0x410)]](_0x23b905[_0x268f57(0x2db)][_0x268f57(0x164)])||_0x1aabf4[_0x268f57(0x23c)][_0x23b905[_0x268f57(0x2db)]['G650IE3']](_0x23b905[_0x268f57(0x2db)][_0x268f57(0x2ac)])){const _0x2a594b=await _0x1b51f7(_0x1aabf4[_0x268f57(0x23c)]);if(_0x2a594b[_0x23b905['i4B82NN'][_0x268f57(0x41c)]]>0x0){const _0x5ba69b=_0x32ba7e(_0x1aabf4[_0x268f57(0x34e)]),_0x8c17d5=_0x2682e0(_0x5ba69b);if(!_0x535066(_0x8c17d5))_0x5630fd(_0x8c17d5);_0x1aabf4[_0x268f57(0x242)]=_0x1a6aca(_0x5ba69b,_0x2a594b);}}}},_0x15b9d3=async _0xa8f1e6=>{const _0x1fbc96=_0x10dfda;_0xa8f1e6[_0x1fbc96(0x242)]=![];if(_0xa8f1e6[_0x1fbc96(0x34e)]&&_0xa8f1e6[_0x1fbc96(0x23c)]&&_0xa8f1e6[_0x1fbc96(0x3f7)]){if(_0xa8f1e6[_0x1fbc96(0x23c)][_0x23b905[_0x1fbc96(0x2db)][_0x1fbc96(0x410)]](_0x23b905[_0x1fbc96(0x2db)][_0x1fbc96(0x164)])||_0xa8f1e6[_0x1fbc96(0x23c)][_0x23b905['i4B82NN'][_0x1fbc96(0x410)]](_0x23b905[_0x1fbc96(0x2db)][_0x1fbc96(0x2ac)])){const _0x54b1e2=_0x3f6985(_0xa8f1e6[_0x1fbc96(0x3f7)]),_0x6e0fb4=await _0x1b51f7(_0xa8f1e6['a47DHT3']),_0x26dc7b=_0x5541dd(_0x6e0fb4,_0x54b1e2);if(_0x26dc7b[_0x23b905[_0x1fbc96(0x2db)][_0x1fbc96(0x41c)]]>0x0){const _0x442904=_0x32ba7e(_0xa8f1e6[_0x1fbc96(0x34e)]),_0xced1a9=_0x2682e0(_0x442904);if(!_0x535066(_0xced1a9))_0x5630fd(_0xced1a9);_0xa8f1e6[_0x1fbc96(0x242)]=_0x1a6aca(_0x442904,_0x26dc7b);}}}};for(const _0x3327fe of _0xd0169b){_0x3327fe[_0x10dfda(0x37c)]===_0xb8e78c[_0x10dfda(0x206)]&&(!_0x3327fe['i6B2K9E']?await _0x5507ab(_0x3327fe):await _0x15b9d3(_0x3327fe));}}async function _0x4f489b(_0x155b6a){const _0x28d2fe=_0x64bdf1;_0x481ac6[_0x28d2fe(0x2c1)][_0x28d2fe(0x189)]('');if(_0x155b6a[_0x23b905['i4B82NN'][_0x28d2fe(0x41c)]]===0x0)return;const _0x543ae8=[],_0x5e892f=_0x497e6a(),_0x1c4c54=_0x5e892f[_0x23b905['i4B82NN'][_0x28d2fe(0x380)]]('|'),_0x4a4a2e=_0x1a9b40=>{const _0x379a62=_0x28d2fe,_0x3b46ed=_0x1a9b40[_0x23b905[_0x379a62(0x2db)][_0x379a62(0x306)]]();for(const _0x2f4124 of _0x1c4c54){if(_0x2f4124[_0x23b905[_0x379a62(0x2db)][_0x379a62(0x199)]](_0x3b46ed))return _0x2f4124;}return'';};for(const _0x8a7af6 of _0x155b6a){if(_0x8a7af6[_0x28d2fe(0x37c)]===_0xb8e78c[_0x28d2fe(0x2c3)]){const _0xd5d7c1=_0x4a4a2e(_0x8a7af6[_0x28d2fe(0x34e)]);_0x8a7af6[_0x28d2fe(0x242)]=_0xd5d7c1!=='';if(_0x8a7af6[_0x28d2fe(0x242)])_0x8a7af6[_0x28d2fe(0x34e)]=_0xd5d7c1;}else{if(_0x8a7af6['Q57DTM8']===_0xb8e78c[_0x28d2fe(0x169)])for(const _0x36efc0 of _0x1c4c54){_0x543ae8[_0x23b905['i4B82NN'][_0x28d2fe(0x3c7)]]({'d5E0TQS':_0x36efc0,'a47DHT3':'','i6B2K9E':'','A575H6Y':!![],'Q57DTM8':_0xb8e78c[_0x28d2fe(0x169)]});}}}_0x543ae8[_0x23b905[_0x28d2fe(0x2db)][_0x28d2fe(0x41c)]]>0x0&&_0x155b6a[_0x23b905['i4B82NN'][_0x28d2fe(0x3c7)]](..._0x543ae8);}async function _0x3f86a4(_0x44a778){const _0x1899d0=_0x64bdf1,_0x5c62f9=_0x2721c7(_0x44a778),_0x3e8bb0=_0x1a78cb(_0x5c62f9,_0x23b905[_0x1899d0(0x2db)][_0x1899d0(0x34b)]);if(_0x3e8bb0!=_0x46394b){_0x481ac6[_0x1899d0(0x2c1)]['s59BT06']('');return;}const _0x41f1d5=_0x1a78cb(_0x5c62f9,_0x23b905[_0x1899d0(0x2db)][_0x1899d0(0x3e9)]);if(_0x41f1d5[_0x23b905[_0x1899d0(0x2db)]['m589L0S']]==0x0){_0x481ac6[_0x1899d0(0x2c1)][_0x1899d0(0x189)]('');return;}const _0x402e08=_0x2ae848(_0x41f1d5,_0x3e8bb0);if(!_0x402e08){_0x481ac6['w3F3UWA']['s59BT06'](''),_0x481ac6[_0x1899d0(0x2c1)][_0x1899d0(0x189)]('');return;}_0x481ac6[_0x1899d0(0x2c1)][_0x1899d0(0x189)]('');const _0x22e83f=_0x2721c7(_0x402e08),_0x794e4e=_0x4218fb[_0x1899d0(0x32c)](_0x22e83f),_0xf500b0=_0x794e4e[_0x1899d0(0x17c)];if(!_0xf500b0)return;await _0xbf3fd2(_0x794e4e['x567X2Q'][_0x1899d0(0x39b)]),await _0x2d9d45(_0x794e4e[_0x1899d0(0x2f4)]['y4BAIF6']),await _0x2884c4(_0x794e4e[_0x1899d0(0x2f4)][_0x1899d0(0x202)]),await _0x4f489b(_0x794e4e[_0x1899d0(0x2f4)][_0x1899d0(0x347)]),await _0x193513(_0x794e4e,_0xf500b0);}async function _0x4071ce(_0x2faf47,_0x311b39){const _0x81754b=_0x64bdf1;_0x46394b=_0x2faf47,_0x497e6a=_0x311b39,_0x481ac6[_0x81754b(0x2c1)]['s59BT06']('');const _0x1e3ea3={'b54FBAI':_0x43f08d[_0x81754b(0x342)],'P456VLZ':_0x3d429c['O435AMZ'],'I489V4T':_0x258343(),'h46EVPS':_0x396231(),'b4CERH3':_0x23b905[_0x81754b(0x2db)][_0x81754b(0x3ee)],'J6C4Y96':'','x567X2Q':{'c608HZL':[],'y4BAIF6':[],'Z59DGHB':[],'s67BMEP':[]}},_0x6ed8d=await _0xf49302(_0x1e3ea3,_0x23b905[_0x81754b(0x2dc)]['P513LY0']);_0x6ed8d&&await _0x3f86a4(_0x6ed8d);}_0x1235da[_0x64bdf1(0x3e3)]=_0x4071ce;}}),_0x2af3f6=_0x474233({'obj/T3EADFE.js'(_0x4af505){'use strict';const _0x432649=_0x104df2;Object[_0x432649(0x1cb)](_0x4af505,_0x432649(0x27a),{'value':!![]}),_0x4af505[_0x432649(0x2a5)]=_0x4af505[_0x432649(0x26f)]=_0x4af505[_0x432649(0x38b)]=void 0x0;var _0x1ebf7f=_0x3b922a(),_0x5c23fd=_0x149430(),_0xae5ec9=_0x122493(),_0x228dc7=_0x274f6b(),_0xa0200c;(function(_0x458712){const _0x2cb139=_0x432649;_0x458712[_0x458712[_0x2cb139(0x1f9)]=0x0]='B639G7B',_0x458712[_0x458712[_0x2cb139(0x41a)]=0x1]=_0x2cb139(0x41a),_0x458712[_0x458712[_0x2cb139(0x248)]=0x2]='q564DFB',_0x458712[_0x458712[_0x2cb139(0x32b)]=0x3]=_0x2cb139(0x32b),_0x458712[_0x458712[_0x2cb139(0x15e)]=0x4]=_0x2cb139(0x15e),_0x458712[_0x458712[_0x2cb139(0x263)]=0x5]=_0x2cb139(0x263),_0x458712[_0x458712[_0x2cb139(0x30f)]=0x6]=_0x2cb139(0x30f),_0x458712[_0x458712[_0x2cb139(0x187)]=0x7]=_0x2cb139(0x187);}(_0xa0200c||(_0xa0200c={})));var _0x55f357=JSON,_0x3c3b8b=class{constructor(){const _0x1ecb44=_0x432649;this['H5C67AR']=![],this[_0x1ecb44(0x1cd)]=![],this[_0x1ecb44(0x3e0)]=![],this[_0x1ecb44(0x26e)]=![],this[_0x1ecb44(0x251)]=![],this[_0x1ecb44(0x3a8)]=![],this[_0x1ecb44(0x1e0)]=![],this[_0x1ecb44(0x41d)]=![],this[_0x1ecb44(0x40a)]=![],this[_0x1ecb44(0x1d3)]=![],this['T5B2T2A']=![],this[_0x1ecb44(0x1a3)]=![],this[_0x1ecb44(0x1be)]=![],this[_0x1ecb44(0x38a)]=![],this[_0x1ecb44(0x178)]='',this[_0x1ecb44(0x183)]='';}};_0x4af505[_0x432649(0x38b)]=_0x3c3b8b;var _0x2d71dc=class{constructor(_0x44b71b,_0x267137,_0x173e48,_0x207976,_0x321e8c){const _0x2b47a8=_0x432649;this[_0x2b47a8(0x3e9)]=![],this[_0x2b47a8(0x2b7)]='',this[_0x2b47a8(0x363)]='',this['j5D4IOV']='',this[_0x2b47a8(0x183)]='';if(_0x44b71b!==void 0x0)this[_0x2b47a8(0x3e9)]=_0x44b71b;if(_0x267137!==void 0x0)this[_0x2b47a8(0x2b7)]=_0x267137;if(_0x173e48!==void 0x0)this[_0x2b47a8(0x363)]=_0x173e48;if(_0x207976!==void 0x0)this['j5D4IOV']=_0x207976;if(_0x321e8c!==void 0x0)this[_0x2b47a8(0x183)]=_0x321e8c;}},_0x344264=class{constructor(_0x43de6f,_0x43de38,_0x492603){const _0x44abf7=_0x432649;this[_0x44abf7(0x3e9)]=![],this[_0x44abf7(0x2b7)]='',this['p6845JK']='';if(_0x43de6f!==void 0x0)this[_0x44abf7(0x3e9)]=_0x43de6f;if(_0x43de38!==void 0x0)this[_0x44abf7(0x2b7)]=_0x43de38;if(_0x492603!==void 0x0)this[_0x44abf7(0x134)]=_0x492603;}},_0x42244b;(function(_0x5456f6){const _0x40402e=_0x432649;_0x5456f6[_0x5456f6['K4E7SBI']=0x0]=_0x40402e(0x324),_0x5456f6[_0x5456f6['C5B7MFV']=0x1]=_0x40402e(0x246),_0x5456f6[_0x5456f6['u6BB118']=0x2]='u6BB118';}(_0x42244b=_0x4af505[_0x432649(0x26f)]||(_0x4af505[_0x432649(0x26f)]={})));var _0x8aca6f;(function(_0x5f4a19){const _0x521488=_0x432649;_0x5f4a19[_0x5f4a19[_0x521488(0x3b1)]=0x0]='s46FO09',_0x5f4a19[_0x5f4a19[_0x521488(0x2ec)]=0x1]=_0x521488(0x2ec),_0x5f4a19[_0x5f4a19[_0x521488(0x2d3)]=0x2]=_0x521488(0x2d3);}(_0x8aca6f||(_0x8aca6f={})));var _0x30c83b=class{constructor(_0x10f65c,_0xeade11,_0x27019b,_0x4ffc98,_0x29c99a){const _0x23530e=_0x432649;this[_0x23530e(0x42b)]=![],this[_0x23530e(0x1e2)]='',this[_0x23530e(0x421)]=_0x10f65c,this['r42EX1Q']=_0xeade11,this[_0x23530e(0x25b)]=_0x27019b,this[_0x23530e(0x28b)]=_0x4ffc98,this['q48AQYC']=_0x29c99a;}async[_0x432649(0x3ea)](){const _0x22ecce=_0x432649;var _0x33f21e,_0x26db74;await _0x5c23fd[_0x22ecce(0x2c1)][_0x22ecce(0x313)](0x0,_0x5c23fd['z579NEI'][_0x22ecce(0x3b5)]);async function _0x25389f(){const _0x1d7f6b=_0x22ecce;var _0x42e3d0;let _0x4bd904=(_0x42e3d0=await _0x1ebf7f[_0x1d7f6b(0x2dc)][_0x1d7f6b(0x3a1)](_0x1ebf7f[_0x1d7f6b(0x2db)][_0x1d7f6b(0x257)]))!==null&&_0x42e3d0!==void 0x0?_0x42e3d0:'';return _0x4bd904==''?![]:!![];}if(await _0x25389f()){const _0x135414=(_0x33f21e=await _0x1ebf7f[_0x22ecce(0x2dc)][_0x22ecce(0x3a1)](_0x1ebf7f[_0x22ecce(0x2db)][_0x22ecce(0x34b)]))!==null&&_0x33f21e!==void 0x0?_0x33f21e:'';return _0xae5ec9[_0x22ecce(0x372)][_0x22ecce(0x34b)]=_0x135414,await _0x5c23fd[_0x22ecce(0x2c1)][_0x22ecce(0x313)](0x0,_0x135414!=''?_0x5c23fd[_0x22ecce(0x311)][_0x22ecce(0x2d5)]:_0x5c23fd[_0x22ecce(0x311)][_0x22ecce(0x200)]),_0x42244b[_0x22ecce(0x324)];}const _0x2aea57='',_0x43a119=0x43,_0x2762db=(_0x26db74=this['X6066R5']())!==null&&_0x26db74!==void 0x0?_0x26db74:'';if(''==_0x2762db){try{await _0x1ebf7f[_0x22ecce(0x2dc)][_0x22ecce(0x2df)](_0x1ebf7f[_0x22ecce(0x2db)]['F58B61E'],_0x43a119[_0x1ebf7f[_0x22ecce(0x2db)][_0x22ecce(0x1a9)]]());}catch(_0x52da50){}return await _0x5c23fd[_0x22ecce(0x2c1)][_0x22ecce(0x330)](0x0,_0x5c23fd[_0x22ecce(0x311)][_0x22ecce(0x351)],void 0x0,[_0x2aea57,_0x2762db]),_0x42244b['u6BB118'];}let _0x243f05='';try{try{await _0x1ebf7f[_0x22ecce(0x2dc)][_0x22ecce(0x2df)](_0x1ebf7f['i4B82NN'][_0x22ecce(0x257)],_0x43a119[_0x1ebf7f[_0x22ecce(0x2db)][_0x22ecce(0x1a9)]]());}catch(_0x5d547c){}var _0x40be30=await(0x0,_0x5c23fd[_0x22ecce(0x276)])(_0x1ebf7f[_0x22ecce(0x2dc)][_0x22ecce(0x14b)]+'?'+_0x1ebf7f[_0x22ecce(0x2db)][_0x22ecce(0x2aa)]+'='+_0x1ebf7f[_0x22ecce(0x2db)][_0x22ecce(0x2f0)]+'&'+_0x1ebf7f[_0x22ecce(0x2db)]['Y55B2P2']+'='+_0xae5ec9[_0x22ecce(0x372)]['Y55B2P2']);if(_0x40be30){const _0x1ed58e=await _0x40be30[_0x1ebf7f[_0x22ecce(0x2db)][_0x22ecce(0x3fb)]]();_0x243f05=_0x1ed58e[_0x1ebf7f[_0x22ecce(0x2db)]['q474LOF']],_0x243f05!=''&&(_0xae5ec9['e5325L3']['q474LOF']=_0x243f05);}_0x5c23fd[_0x22ecce(0x2c1)]['s59BT06']('');if(_0x243f05!=''){let _0x2a540d=function(_0x3a95de){const _0x2203f0=_0x22ecce;let _0x42ed01='';for(let _0x1b64d3=0x0;_0x1b64d3<_0x3a95de[_0x1ebf7f[_0x2203f0(0x2db)]['m589L0S']];_0x1b64d3++){_0x42ed01+=_0x3a95de[_0x1ebf7f['i4B82NN'][_0x2203f0(0x30d)]](_0x1b64d3)[_0x1ebf7f['i4B82NN']['K66ASXK']](0x10)[_0x1ebf7f[_0x2203f0(0x2db)][_0x2203f0(0x1d7)]](0x2,'0');}return _0x42ed01;};return await _0x1ebf7f[_0x22ecce(0x2dc)][_0x22ecce(0x2df)](_0x1ebf7f[_0x22ecce(0x2db)][_0x22ecce(0x34b)],_0x243f05),await _0x1ebf7f[_0x22ecce(0x2dc)][_0x22ecce(0x2df)](_0x1ebf7f[_0x22ecce(0x2db)][_0x22ecce(0x1e2)],_0x2a540d(_0x2762db)),await _0x5c23fd[_0x22ecce(0x2c1)][_0x22ecce(0x313)](0x0,_0x5c23fd[_0x22ecce(0x311)][_0x22ecce(0x32a)],[_0x2aea57,_0x2762db]),_0x42244b[_0x22ecce(0x246)];}else await _0x1ebf7f[_0x22ecce(0x2dc)]['c5E4Z7C'](_0x1ebf7f[_0x22ecce(0x2db)][_0x22ecce(0x34b)],''),await _0x5c23fd[_0x22ecce(0x2c1)][_0x22ecce(0x330)](0x0,_0x5c23fd[_0x22ecce(0x311)][_0x22ecce(0x351)],void 0x0,[_0x2aea57,_0x2762db]);}catch(_0x3fc755){await _0x5c23fd[_0x22ecce(0x2c1)][_0x22ecce(0x330)](0x0,_0x5c23fd[_0x22ecce(0x311)][_0x22ecce(0x351)],_0x3fc755,[_0x2aea57,_0x2762db]);}return _0x42244b['u6BB118'];}async['A4B0MTO'](){const _0x38b5d6=_0x432649;try{if(await this[_0x38b5d6(0x1f1)]())await(0x0,_0x228dc7[_0x38b5d6(0x3e3)])(_0xae5ec9['e5325L3']['q474LOF'],this['q48AQYC']);}catch(_0x25cc34){_0x5c23fd[_0x38b5d6(0x2c1)][_0x38b5d6(0x189)]('');}}async[_0x432649(0x316)](_0x4901ec){const _0x57047d=_0x432649;try{_0x5c23fd[_0x57047d(0x2c1)][_0x57047d(0x189)](''),_0xae5ec9['e5325L3'][_0x57047d(0x1f8)]=_0x4901ec,_0x5c23fd[_0x57047d(0x2c1)][_0x57047d(0x189)]('');if(_0xae5ec9[_0x57047d(0x372)][_0x57047d(0x1f8)]==_0x1ebf7f['a689XV5'][_0x57047d(0x1f9)])return;await(0x0,_0x5c23fd[_0x57047d(0x148)])(),await _0x1ebf7f['S559FZQ'][_0x57047d(0x359)]();if(!await this[_0x57047d(0x1f1)]())return void 0x0;await this['U6B4YNR'](),await this[_0x57047d(0x2b2)]();var _0x8b89b5=await this['e4F5CS0']();if(await this[_0x57047d(0x1b4)](_0x8b89b5[_0x57047d(0x183)])){const _0x24bac1=_0x55f357[_0x1ebf7f['i4B82NN'][_0x57047d(0x222)]](_0x8b89b5[_0x57047d(0x183)]);let _0x3423af=[];for(const _0x37ec94 in _0x24bac1){if(_0x24bac1[_0x1ebf7f[_0x57047d(0x2db)][_0x57047d(0x41b)]](_0x37ec94)){const _0x141fe5=_0x24bac1[_0x37ec94];for(const _0x31489b in _0x141fe5){if(_0x141fe5[_0x1ebf7f[_0x57047d(0x2db)]['k6C3VS6']](_0x31489b)){const _0xf5fd69=_0x141fe5[_0x31489b];await this[_0x57047d(0x19d)](_0x37ec94,_0x31489b,_0xf5fd69),_0x3423af[_0x1ebf7f[_0x57047d(0x2db)][_0x57047d(0x3c7)]](_0x31489b);}}}}_0x3423af['length']>0x0&&await _0x5c23fd[_0x57047d(0x2c1)][_0x57047d(0x313)](_0xa0200c[_0x57047d(0x1f9)],_0x5c23fd[_0x57047d(0x311)][_0x57047d(0x42a)],_0x3423af);}if(_0x8b89b5[_0x57047d(0x250)]){if(_0x8b89b5[_0x57047d(0x251)])await this[_0x57047d(0x40d)](_0xae5ec9[_0x57047d(0x372)][_0x57047d(0x225)]);else _0x8b89b5[_0x57047d(0x1cd)]&&await this[_0x57047d(0x38f)](_0xae5ec9[_0x57047d(0x372)][_0x57047d(0x225)]);_0x8b89b5[_0x57047d(0x3a8)]&&await this[_0x57047d(0x36e)](_0xae5ec9['e5325L3']['M56F8MB']),_0x8b89b5['E67CJ69']&&_0xae5ec9[_0x57047d(0x372)][_0x57047d(0x1cf)]&&(_0x5c23fd[_0x57047d(0x2c1)][_0x57047d(0x189)](''),await this[_0x57047d(0x156)](_0x8b89b5[_0x57047d(0x41d)])),_0x8b89b5[_0x57047d(0x40a)]&&_0xae5ec9[_0x57047d(0x372)][_0x57047d(0x1fc)]&&(_0x5c23fd[_0x57047d(0x2c1)][_0x57047d(0x189)](''),await this[_0x57047d(0x154)](_0x8b89b5[_0x57047d(0x1d3)])),_0x8b89b5[_0x57047d(0x272)]&&_0xae5ec9[_0x57047d(0x372)][_0x57047d(0x3ff)]&&(_0x5c23fd[_0x57047d(0x2c1)][_0x57047d(0x189)](''),await this[_0x57047d(0x398)](_0x8b89b5[_0x57047d(0x1a3)])),_0x8b89b5[_0x57047d(0x1be)]&&_0xae5ec9[_0x57047d(0x372)][_0x57047d(0x13c)]&&(_0x5c23fd[_0x57047d(0x2c1)][_0x57047d(0x189)](''),await this[_0x57047d(0x39f)](_0x8b89b5['g5ABMVH']));}return await _0x5c23fd[_0x57047d(0x2c1)][_0x57047d(0x313)](_0xa0200c['B639G7B'],_0x5c23fd[_0x57047d(0x311)][_0x57047d(0x343)],[_0xae5ec9[_0x57047d(0x372)][_0x57047d(0x1ba)],_0xae5ec9[_0x57047d(0x372)]['n664BX9'],_0xae5ec9['e5325L3']['R6780KK'],_0xae5ec9[_0x57047d(0x372)]['g4184BO'],_0xae5ec9[_0x57047d(0x372)][_0x57047d(0x3ff)],_0xae5ec9['e5325L3']['r53FV0M'],_0x8b89b5[_0x57047d(0x250)],_0x8b89b5[_0x57047d(0x1cd)],_0x8b89b5[_0x57047d(0x3e0)],_0x8b89b5[_0x57047d(0x26e)],_0x8b89b5[_0x57047d(0x251)],_0x8b89b5[_0x57047d(0x3a8)],_0xae5ec9[_0x57047d(0x372)][_0x57047d(0x13c)]]),_0x8b89b5;}catch(_0x2fa728){return await _0x5c23fd[_0x57047d(0x2c1)][_0x57047d(0x330)](_0xa0200c[_0x57047d(0x1f9)],_0x5c23fd['z579NEI'][_0x57047d(0x3f0)],_0x2fa728),void 0x0;}}async[_0x432649(0x1f1)](){const _0x175044=_0x432649;var _0x291d8e;_0xae5ec9[_0x175044(0x372)][_0x175044(0x34b)]=(_0x291d8e=await _0x1ebf7f['S559FZQ']['l610ZCY'](_0x1ebf7f[_0x175044(0x2db)][_0x175044(0x34b)]))!==null&&_0x291d8e!==void 0x0?_0x291d8e:'';if(!_0xae5ec9['e5325L3'][_0x175044(0x34b)]||_0xae5ec9[_0x175044(0x372)]['q474LOF']=='')return _0x5c23fd[_0x175044(0x2c1)][_0x175044(0x189)](''),![];return!![];}async[_0x432649(0x1bd)](){const _0xfd51c3=_0x432649;var _0x4398cb,_0x2cbf1e;const _0x4991b3=_0x544bfe(_0x1ebf7f['i4B82NN'][_0xfd51c3(0x371)]),_0x4cfa5f=_0x4991b3[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x3ed)]];var _0x30f985=(_0x4398cb=_0xae5ec9[_0xfd51c3(0x372)][_0xfd51c3(0x34b)])!==null&&_0x4398cb!==void 0x0?_0x4398cb:'';const _0x4a3b1f=new _0x4cfa5f(),_0x131b96=_0x1ebf7f['S559FZQ'][_0xfd51c3(0x428)][_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x146)]](0x0,0x18)+_0x30f985[_0x1ebf7f[_0xfd51c3(0x2db)]['m54687J']](0x0,0x8),_0x3d972d={};_0x3d972d[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x34b)]]=_0x30f985,_0x3d972d[_0x1ebf7f[_0xfd51c3(0x2db)]['Y55B2P2']]=_0xae5ec9[_0xfd51c3(0x372)]['Y55B2P2'],_0x3d972d[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x360)]]='0';const _0x5e7be2=(0x0,_0x5c23fd[_0xfd51c3(0x3bb)])(_0x131b96,_0x55f357[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x1f2)]](_0x3d972d));_0x4a3b1f[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x17a)]](_0x1ebf7f['i4B82NN'][_0xfd51c3(0x3e9)],_0x5e7be2[_0x1ebf7f[_0xfd51c3(0x2db)]['m5BCP18']]),_0x4a3b1f[_0x1ebf7f['i4B82NN'][_0xfd51c3(0x17a)]](_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x23a)],_0x5e7be2[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x23a)]]),_0x4a3b1f[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x17a)]](_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x34b)],(_0x2cbf1e=_0xae5ec9[_0xfd51c3(0x372)][_0xfd51c3(0x34b)])!==null&&_0x2cbf1e!==void 0x0?_0x2cbf1e:'');let _0x3727c3=await(0x0,_0x5c23fd[_0xfd51c3(0x377)])(''+_0x1ebf7f[_0xfd51c3(0x2dc)][_0xfd51c3(0x229)],_0x4a3b1f);if(_0x3727c3&&_0x3727c3['ok']){_0x5c23fd[_0xfd51c3(0x2c1)][_0xfd51c3(0x189)]('');let _0xf9115f=await _0x3727c3[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x3fb)]]();if(_0xf9115f[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x3e9)]]){let _0x313a39=function(_0xc90d7a,_0x41fc78){const _0x1e2020=_0xfd51c3,_0x489f56=_0x41fc78[_0x1ebf7f[_0x1e2020(0x2db)][_0x1e2020(0x1a9)]]()[_0x1ebf7f[_0x1e2020(0x2db)][_0x1e2020(0x1d7)]](0x2,'0');return''+_0xc90d7a+_0x489f56;};const _0x2d3f07=(0x0,_0x5c23fd['U61FWBZ'])(_0x131b96,_0xf9115f[_0x1ebf7f['i4B82NN'][_0xfd51c3(0x3e9)]],_0xf9115f[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x23a)]]),_0xf51667=_0x55f357[_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x222)]](_0x2d3f07),_0x298da3='A';let _0x1aa5f2=0x1;_0xae5ec9['E506IW4'][_0xfd51c3(0x2be)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x181)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['q531YE2']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x213)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x3d3)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x161)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x409)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4']['q3F6NE0']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x362)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x151)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['v4A5HA6']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x3f6)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['z626Z6P']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x1f6)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x42d)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['o5D81YO']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4']['Y4F9KA9']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x28d)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x184)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x249)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x22d)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x29e)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x348)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x177)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x2c2)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x2a6)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['M4AFW8T']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x33b)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['O680HF3']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x3ba)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x35b)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4']['e4C2ZG5']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['s5A8UWK']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x344)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x386)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x3a2)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x196)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x30b)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x265)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x220)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x27c)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x373)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x261)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x3b0)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x340)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4']['Q68703N']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x385)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['Q6AD4K1']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x1b8)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x236)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x2bb)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x234)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x31a)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x153)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x1c2)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x331)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x266)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4']['p49ALL3']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['H4A2CBA']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x1da)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['V615O8R']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x157)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x3ac)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4']['V68C0TQ']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['P41D36M']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x1b6)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x285)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x1e6)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)]['i61EV2V']=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x204)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x34a)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x309)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9['E506IW4'][_0xfd51c3(0x187)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x19a)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)],_0xae5ec9[_0xfd51c3(0x2e0)][_0xfd51c3(0x3a4)]=_0xf51667[_0x313a39(_0x298da3,_0x1aa5f2++)];if(!_0xae5ec9[_0xfd51c3(0x2e0)]['d6C8UEH']())throw new Error(_0x1ebf7f[_0xfd51c3(0x2db)]['O442CZN']);}else throw new Error(_0x1ebf7f[_0xfd51c3(0x2db)][_0xfd51c3(0x3b3)]);}else throw new Error(_0x1ebf7f[_0xfd51c3(0x2db)]['P593R8H']);}async[_0x432649(0x2b2)](){const _0x10c62f=_0x432649;var _0x22794d,_0x9cf519;this[_0x10c62f(0x1e2)]=(0x0,_0x5c23fd['S634YX3'])((_0x22794d=await _0x1ebf7f[_0x10c62f(0x2dc)]['l610ZCY'](_0x1ebf7f['i4B82NN'][_0x10c62f(0x1e2)]))!==null&&_0x22794d!==void 0x0?_0x22794d:''),_0x5c23fd['w3F3UWA'][_0x10c62f(0x189)]('');const _0x17ed85=(_0x9cf519=await _0x1ebf7f[_0x10c62f(0x2dc)][_0x10c62f(0x3a1)](_0x1ebf7f[_0x10c62f(0x2db)][_0x10c62f(0x275)]))!==null&&_0x9cf519!==void 0x0?_0x9cf519:'';if(_0x17ed85!=_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x34b)])this[_0x10c62f(0x42b)]=!![];_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x383)]=await this[_0x10c62f(0x3d8)](_0xa0200c[_0x10c62f(0x248)]),_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x3ca)]=_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x383)]!='',_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x289)]=await this['D656W9S'](_0xa0200c[_0x10c62f(0x41a)]),_0xae5ec9['e5325L3'][_0x10c62f(0x1ba)]=_0xae5ec9[_0x10c62f(0x372)]['a6B1QAU']!='';if(await this[_0x10c62f(0x3d8)](_0xa0200c[_0x10c62f(0x32b)])!='')_0xae5ec9['e5325L3']['g4184BO']=!![];if(await this[_0x10c62f(0x3d8)](_0xa0200c[_0x10c62f(0x15e)])!='')_0xae5ec9[_0x10c62f(0x372)]['R6780KK']=!![];if(await this[_0x10c62f(0x3d8)](_0xa0200c[_0x10c62f(0x263)])!='')_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x423)]=!![];if(await this[_0x10c62f(0x3d8)](_0xa0200c['F58C0X0'])!='')_0xae5ec9['e5325L3'][_0x10c62f(0x3ff)]=!![];if(await this[_0x10c62f(0x3d8)](_0xa0200c[_0x10c62f(0x187)])!='')_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x13c)]=!![];_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x225)]=await this[_0x10c62f(0x406)](![],_0xa0200c[_0x10c62f(0x41a)]),_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x366)]=await this[_0x10c62f(0x406)](![],_0xa0200c[_0x10c62f(0x248)]),_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x1a6)]=![];if(_0xae5ec9[_0x10c62f(0x2e0)]['Y420K0O']&&Array[_0x10c62f(0x201)](_0xae5ec9[_0x10c62f(0x2e0)][_0x10c62f(0x1da)]))for(let _0x500f8a=0x0;_0x500f8a<_0xae5ec9[_0x10c62f(0x2e0)]['Y420K0O'][_0x10c62f(0x1ee)];_0x500f8a++){const _0x487487=_0xae5ec9[_0x10c62f(0x2e0)][_0x10c62f(0x1da)][_0x500f8a];if(await this[_0x10c62f(0x325)](_0x487487)){_0xae5ec9[_0x10c62f(0x372)][_0x10c62f(0x279)]=_0x500f8a,_0x5c23fd[_0x10c62f(0x2c1)]['s59BT06']('');break;}}if(_0xae5ec9[_0x10c62f(0x2e0)][_0x10c62f(0x20f)]&&Array['isArray'](_0xae5ec9[_0x10c62f(0x2e0)][_0x10c62f(0x20f)])){_0x5c23fd[_0x10c62f(0x2c1)][_0x10c62f(0x189)]('');for(let _0x53a772=0x0;_0x53a772<_0xae5ec9['E506IW4'][_0x10c62f(0x20f)][_0x1ebf7f[_0x10c62f(0x2db)][_0x10c62f(0x41c)]];_0x53a772++){const _0x4abe21=_0xae5ec9[_0x10c62f(0x2e0)][_0x10c62f(0x20f)][_0x53a772];if(await this[_0x10c62f(0x420)](_0x4abe21[_0x1ebf7f['i4B82NN'][_0x10c62f(0x209)]],_0x4abe21[_0x1ebf7f[_0x10c62f(0x2db)][_0x10c62f(0x3a0)]])){_0xae5ec9['e5325L3']['K48B40X']=_0x53a772,_0x5c23fd['w3F3UWA']['s59BT06']('');break;}}_0x5c23fd['w3F3UWA'][_0x10c62f(0x189)]('');}}async[_0x432649(0x406)](_0x306ce4,_0x5dc2b1){return new Promise(_0xd9073e=>{const _0x2b0c87=_0x22e6,_0x2c7cc7=_0x544bfe(_0x1ebf7f['i4B82NN'][_0x2b0c87(0x3ad)]);var _0x369853='',_0x29e361=_0xae5ec9[_0x2b0c87(0x2e0)][_0x2b0c87(0x1f6)];switch(_0x5dc2b1){case _0xa0200c[_0x2b0c87(0x41a)]:_0x29e361=_0xae5ec9[_0x2b0c87(0x2e0)]['F431S76'];break;case _0xa0200c[_0x2b0c87(0x248)]:_0x29e361=_0xae5ec9[_0x2b0c87(0x2e0)][_0x2b0c87(0x184)];break;}const _0x127280=(0x0,_0x5c23fd[_0x2b0c87(0x35f)])(_0xae5ec9[_0x2b0c87(0x2e0)][_0x2b0c87(0x21e)],_0x29e361,_0x369853);_0x2c7cc7[_0x1ebf7f[_0x2b0c87(0x2db)][_0x2b0c87(0x1f4)]](_0x127280,(_0x5c7f03,_0x345101,_0x591e90)=>{const _0x282a02=_0x2b0c87;_0x5c7f03&&(((async()=>{const _0x2e04d6=_0x22e6;await _0x5c23fd[_0x2e04d6(0x2c1)][_0x2e04d6(0x330)](_0x5dc2b1,_0x5c23fd[_0x2e04d6(0x311)][_0x2e04d6(0x17d)],_0x5c7f03);})()),_0xd9073e(![])),_0x591e90&&(((async()=>{const _0x369b89=_0x22e6;await _0x5c23fd[_0x369b89(0x2c1)][_0x369b89(0x330)](_0x5dc2b1,_0x5c23fd[_0x369b89(0x311)][_0x369b89(0x19c)],_0x5c7f03);})()),_0xd9073e(![])),_0x5c23fd[_0x282a02(0x2c1)]['s59BT06'](''),_0xd9073e(_0x345101[_0x1ebf7f['i4B82NN']['q429PA2']]()!=='');});});}async[_0x432649(0x255)](){const _0x118801=_0x432649;_0x5c23fd[_0x118801(0x2c1)]['s59BT06']('');let _0x2ea916=await _0x1ebf7f[_0x118801(0x2dc)][_0x118801(0x3a1)](_0x1ebf7f[_0x118801(0x2db)][_0x118801(0x34b)]);if(_0x2ea916){_0xae5ec9[_0x118801(0x372)][_0x118801(0x34b)]=_0x2ea916;try{var _0x117bb9=await(0x0,_0x5c23fd[_0x118801(0x276)])(_0x1ebf7f[_0x118801(0x2dc)][_0x118801(0x422)]+'?'+_0x1ebf7f[_0x118801(0x2db)][_0x118801(0x34b)]+'='+_0x2ea916);if(_0x117bb9){const _0x2a051c=await _0x117bb9[_0x1ebf7f[_0x118801(0x2db)]['s624CR1']]();}await _0x5c23fd[_0x118801(0x2c1)][_0x118801(0x313)](_0xa0200c[_0x118801(0x41a)],_0x5c23fd[_0x118801(0x311)][_0x118801(0x38d)]);}catch(_0x2e6fb0){await _0x5c23fd[_0x118801(0x2c1)][_0x118801(0x330)](_0xa0200c[_0x118801(0x1f9)],_0x5c23fd[_0x118801(0x311)][_0x118801(0x38d)],_0x2e6fb0);}}}async['D656W9S'](_0x57f1d2){const _0x3efbd5=_0x432649,_0x2beeb8=_0x544bfe(_0x1ebf7f['i4B82NN'][_0x3efbd5(0x2f3)]);let _0x32e461='';if(_0x57f1d2==_0xa0200c['N6330WH']){_0x32e461=_0x2beeb8[_0x3efbd5(0x2af)](_0x1ebf7f[_0x3efbd5(0x2dc)][_0x3efbd5(0x2ea)](),_0xae5ec9[_0x3efbd5(0x2e0)][_0x3efbd5(0x42d)]);if(await this[_0x3efbd5(0x325)](_0x32e461))return _0x32e461;_0x32e461=_0xae5ec9[_0x3efbd5(0x2e0)][_0x3efbd5(0x3a5)];if(await this[_0x3efbd5(0x325)](_0x32e461))return _0x32e461;_0x32e461=_0xae5ec9[_0x3efbd5(0x2e0)][_0x3efbd5(0x14d)];if(await this[_0x3efbd5(0x325)](_0x32e461))return _0x32e461;}else{if(_0x57f1d2==_0xa0200c[_0x3efbd5(0x248)]){_0x32e461=_0xae5ec9[_0x3efbd5(0x2e0)][_0x3efbd5(0x249)];if(await this[_0x3efbd5(0x325)](_0x32e461))return _0x32e461;_0x32e461=_0xae5ec9[_0x3efbd5(0x2e0)][_0x3efbd5(0x22d)];if(await this[_0x3efbd5(0x325)](_0x32e461))return _0x32e461;}else{if(_0x57f1d2==_0xa0200c[_0x3efbd5(0x32b)]){const _0x40f71e=_0x544bfe(_0x1ebf7f[_0x3efbd5(0x2db)][_0x3efbd5(0x182)]),_0xeb25d6=_0x40f71e[_0x1ebf7f[_0x3efbd5(0x2db)][_0x3efbd5(0x2d9)]][_0x1ebf7f['i4B82NN'][_0x3efbd5(0x1d9)]];_0x32e461=_0x2beeb8['join'](_0xeb25d6,_0xae5ec9[_0x3efbd5(0x2e0)]['v4BE899']);if(await this[_0x3efbd5(0x325)](_0x32e461))return _0x32e461;}else{if(_0x57f1d2==_0xa0200c[_0x3efbd5(0x15e)]){_0x32e461=_0x2beeb8[_0x3efbd5(0x2af)](_0x1ebf7f[_0x3efbd5(0x2dc)]['D47CBV3'](),_0xae5ec9[_0x3efbd5(0x2e0)][_0x3efbd5(0x3a7)]);if(await this[_0x3efbd5(0x325)](_0x32e461))return _0x32e461;}else{if(_0x57f1d2==_0xa0200c[_0x3efbd5(0x263)]){_0x32e461=_0x2beeb8[_0x3efbd5(0x2af)](_0x1ebf7f['S559FZQ'][_0x3efbd5(0x2ea)](),_0xae5ec9[_0x3efbd5(0x2e0)][_0x3efbd5(0x3ba)]);if(await this[_0x3efbd5(0x325)](_0x32e461))return _0x32e461;}else{if(_0x57f1d2==_0xa0200c[_0x3efbd5(0x30f)]){_0x32e461=_0x2beeb8[_0x3efbd5(0x2af)](_0x1ebf7f['S559FZQ'][_0x3efbd5(0x2ea)](),_0xae5ec9['E506IW4'][_0x3efbd5(0x13a)]);if(await this[_0x3efbd5(0x325)](_0x32e461))return _0x32e461;}else{if(_0x57f1d2==_0xa0200c[_0x3efbd5(0x187)]){_0x32e461=_0x2beeb8[_0x3efbd5(0x2af)](_0x1ebf7f[_0x3efbd5(0x2dc)][_0x3efbd5(0x322)](),_0xae5ec9[_0x3efbd5(0x2e0)][_0x3efbd5(0x187)],_0xae5ec9[_0x3efbd5(0x2e0)][_0x3efbd5(0x34a)]);if(await this['A5FCGS4'](_0x32e461))return _0x32e461;}}}}}}}return'';}async['j458FW3'](_0x596908){const _0x5e14b2=_0x432649;_0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x189)]('');if(this[_0x5e14b2(0x1e2)]==''||!_0xae5ec9[_0x5e14b2(0x372)]['k596N0J'])return;const _0x2d5a70=_0x544bfe(_0x1ebf7f[_0x5e14b2(0x2db)][_0x5e14b2(0x2f3)]),_0x2f4735=_0x1ebf7f['S559FZQ'][_0x5e14b2(0x2ea)]();if(!_0x2f4735){await _0x5c23fd['w3F3UWA']['Y6CDW21'](_0xa0200c[_0x5e14b2(0x1f9)],_0x5c23fd['z579NEI'][_0x5e14b2(0x1ea)]);return;}const _0x59bbe9=_0x2d5a70[_0x5e14b2(0x2af)](_0x2f4735,_0xae5ec9[_0x5e14b2(0x2e0)]['G555SVW']);let _0x5187c2=0x1;if(_0xae5ec9[_0x5e14b2(0x372)][_0x5e14b2(0x289)]==''){await _0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x313)](_0xa0200c['N6330WH'],_0x5c23fd[_0x5e14b2(0x311)][_0x5e14b2(0x31c)]);return;}if(this[_0x5e14b2(0x42b)]||!_0x596908||_0xae5ec9[_0x5e14b2(0x372)][_0x5e14b2(0x1f8)]==_0x1ebf7f['a689XV5'][_0x5e14b2(0x1b0)]){if(_0x596908)_0x596908=![];await this[_0x5e14b2(0x282)](_0xae5ec9[_0x5e14b2(0x2e0)]['F431S76']),_0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x189)]('');}let _0x2827c3=_0x2d5a70[_0x5e14b2(0x2af)](_0x59bbe9,_0xae5ec9[_0x5e14b2(0x2e0)][_0x5e14b2(0x362)]);_0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x189)]('');let [_0x1bb085,_0x2f987f]=await this[_0x5e14b2(0x2f7)](_0x5187c2,_0x2827c3,![]);_0x2f987f&&_0x2f987f!==''&&(_0x2f987f=this['r42EX1Q'](_0x2f987f),_0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x189)](''));if(_0x1bb085){let _0x2fa6d9=![];for(let _0x32a0e6=0x0;_0x32a0e6<_0x1bb085[_0x5e14b2(0x1ee)];_0x32a0e6++){let _0x49bf9d=_0x2d5a70['join'](_0x59bbe9,_0x1bb085[_0x32a0e6],_0xae5ec9[_0x5e14b2(0x2e0)][_0x5e14b2(0x151)]),_0x18bcea=_0x2d5a70[_0x5e14b2(0x2af)](_0x59bbe9,_0x1bb085[_0x32a0e6],_0xae5ec9[_0x5e14b2(0x2e0)]['v4A5HA6']),_0x7b82b0=_0x2d5a70['join'](_0x59bbe9,_0x1bb085[_0x32a0e6],_0xae5ec9[_0x5e14b2(0x2e0)][_0x5e14b2(0x3f6)]),_0x11e773=_0x2d5a70[_0x5e14b2(0x2af)](_0x59bbe9,_0x1bb085[_0x32a0e6],_0xae5ec9[_0x5e14b2(0x2e0)]['z626Z6P']);if(await this[_0x5e14b2(0x2d0)](_0x49bf9d,_0x7b82b0)){await this[_0x5e14b2(0x2d0)](_0x18bcea,_0x11e773);let _0x415da9='',_0x3782c1='';await this[_0x5e14b2(0x2f5)](_0x7b82b0)[_0x5e14b2(0x16d)](_0x288b3f=>{_0x415da9=_0x288b3f;})[_0x5e14b2(0x284)](_0x435ee0=>{((async()=>{const _0x349987=_0x22e6;await _0x5c23fd[_0x349987(0x2c1)][_0x349987(0x330)](_0xa0200c['N6330WH'],_0x5c23fd['z579NEI'][_0x349987(0x3e7)],_0x435ee0);})());}),await this[_0x5e14b2(0x2f5)](_0x11e773)[_0x5e14b2(0x16d)](_0x491c18=>{_0x3782c1=_0x491c18;})[_0x5e14b2(0x284)](_0x370b5d=>{((async()=>{const _0x15d46c=_0x22e6;await _0x5c23fd[_0x15d46c(0x2c1)]['Y6CDW21'](_0xa0200c[_0x15d46c(0x41a)],_0x5c23fd['z579NEI'][_0x15d46c(0x22b)],_0x370b5d);})());});if(_0x415da9==''){await _0x5c23fd[_0x5e14b2(0x2c1)]['W4EF0EI'](_0xa0200c[_0x5e14b2(0x41a)],_0x5c23fd[_0x5e14b2(0x311)][_0x5e14b2(0x18e)]);continue;}_0x5c23fd[_0x5e14b2(0x2c1)]['s59BT06']('');let _0x4ae8dc=await this[_0x5e14b2(0x269)](_0x5187c2,_0x415da9,_0x3782c1);if(!_0x4ae8dc[_0x5e14b2(0x3e9)]){await _0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x313)](_0xa0200c[_0x5e14b2(0x41a)],_0x5c23fd[_0x5e14b2(0x311)][_0x5e14b2(0x317)]);return;}if(_0x596908&&(await this[_0x5e14b2(0x1b4)](_0x4ae8dc[_0x5e14b2(0x2b7)])||await this[_0x5e14b2(0x1b4)](_0x4ae8dc[_0x5e14b2(0x363)]))){_0x5c23fd['w3F3UWA'][_0x5e14b2(0x189)](''),await this[_0x5e14b2(0x38f)](![]);return;}_0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x189)]('');let _0x3e917e=![];await this[_0x5e14b2(0x1b4)](_0x4ae8dc['C5C7K1A'])&&(await this['Y53EKLA'](_0x7b82b0,_0x4ae8dc[_0x5e14b2(0x2b7)]),await this['X428OQY'](_0x7b82b0,_0x49bf9d),_0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x189)](''),_0x3e917e=!![]);await this[_0x5e14b2(0x1b4)](_0x4ae8dc[_0x5e14b2(0x363)])&&(await this['Y53EKLA'](_0x11e773,_0x4ae8dc[_0x5e14b2(0x363)]),await this[_0x5e14b2(0x2d0)](_0x11e773,_0x18bcea),_0x5c23fd[_0x5e14b2(0x2c1)]['s59BT06'](''),_0x3e917e=!![]);_0x4ae8dc[_0x5e14b2(0x3cf)]&&_0x4ae8dc[_0x5e14b2(0x3cf)]['length']!==0x0&&(await this[_0x5e14b2(0x19d)](_0xae5ec9['E506IW4'][_0x5e14b2(0x3b2)]+_0x1bb085[_0x32a0e6],_0xae5ec9['E506IW4'][_0x5e14b2(0x213)],_0x4ae8dc[_0x5e14b2(0x3cf)]),_0x5c23fd['w3F3UWA']['s59BT06'](''),_0x3e917e=!![]);if(await this[_0x5e14b2(0x1b4)](_0x4ae8dc[_0x5e14b2(0x183)])){const _0x3528a2=_0x55f357[_0x1ebf7f[_0x5e14b2(0x2db)][_0x5e14b2(0x222)]](_0x4ae8dc[_0x5e14b2(0x183)]);let _0x3a7f01=[];for(const _0x3e90e1 in _0x3528a2){if(_0x3528a2[_0x1ebf7f[_0x5e14b2(0x2db)]['k6C3VS6']](_0x3e90e1)){const _0x238248=_0x3528a2[_0x3e90e1],_0x3efd5a=_0x3e90e1[_0x1ebf7f['i4B82NN'][_0x5e14b2(0x208)]]('%'+_0x1ebf7f[_0x5e14b2(0x2db)][_0x5e14b2(0x389)]+'%',_0x1bb085[_0x32a0e6]);for(const _0x588175 in _0x238248){if(_0x238248[_0x1ebf7f[_0x5e14b2(0x2db)]['k6C3VS6']](_0x588175)){const _0x19bb5e=_0x238248[_0x588175];await this[_0x5e14b2(0x19d)](_0x3efd5a,_0x588175,_0x19bb5e),_0x3a7f01[_0x1ebf7f['i4B82NN']['v3FAAYS']](_0x588175);}}}}_0x3a7f01[_0x5e14b2(0x1ee)]>0x0&&await _0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x313)](_0xa0200c[_0x5e14b2(0x41a)],_0x5c23fd[_0x5e14b2(0x311)][_0x5e14b2(0x240)],[_0x3a7f01]);}_0x2fa6d9=!![],_0x3e917e?await _0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x313)](_0xa0200c[_0x5e14b2(0x41a)],_0x5c23fd['z579NEI'][_0x5e14b2(0x424)]):await _0x5c23fd[_0x5e14b2(0x2c1)][_0x5e14b2(0x313)](_0xa0200c['N6330WH'],_0x5c23fd[_0x5e14b2(0x311)][_0x5e14b2(0x186)]);}}_0x2fa6d9&&await _0x1ebf7f['S559FZQ'][_0x5e14b2(0x2df)](_0x1ebf7f[_0x5e14b2(0x2db)][_0x5e14b2(0x275)],_0xae5ec9[_0x5e14b2(0x372)][_0x5e14b2(0x34b)]);}_0x5c23fd[_0x5e14b2(0x2c1)]['s59BT06']('');return;}async[_0x432649(0x40d)](_0xa3e602){const _0xf61a38=_0x432649;let _0x48b033=_0xa0200c['N6330WH'];const _0x356c1d=_0x1ebf7f[_0xf61a38(0x2db)]['x4B9LDS'];_0x5c23fd[_0xf61a38(0x2c1)]['s59BT06']('');if(!_0xae5ec9['e5325L3']['k596N0J'])return;const _0x48df18=_0x544bfe(_0x1ebf7f[_0xf61a38(0x2db)]['v520GPQ']),_0x57293f=_0x1ebf7f[_0xf61a38(0x2dc)][_0xf61a38(0x2ea)]();if(!_0x57293f){await _0x5c23fd[_0xf61a38(0x2c1)]['Y6CDW21'](_0xa0200c['B639G7B'],_0x5c23fd[_0xf61a38(0x311)]['F65A6FS']);return;}const _0x543d90=_0x48df18['join'](_0x57293f,_0xae5ec9['E506IW4']['G555SVW']);if(_0xae5ec9[_0xf61a38(0x372)]['a6B1QAU']==''){await _0x5c23fd[_0xf61a38(0x2c1)][_0xf61a38(0x313)](_0x48b033,_0x5c23fd[_0xf61a38(0x311)][_0xf61a38(0x31c)]);return;}if(this['Z5A9DKG']||!_0xa3e602||_0xae5ec9[_0xf61a38(0x372)][_0xf61a38(0x1f8)]==_0x1ebf7f[_0xf61a38(0x393)][_0xf61a38(0x1b0)]){_0xa3e602&&(_0xa3e602=![],await this[_0xf61a38(0x282)](_0xae5ec9[_0xf61a38(0x2e0)][_0xf61a38(0x1f6)]),_0x5c23fd['w3F3UWA']['s59BT06'](''));let _0x1936c9=_0x48df18[_0xf61a38(0x2af)](_0x543d90,_0xae5ec9[_0xf61a38(0x2e0)][_0xf61a38(0x362)]);_0x5c23fd['w3F3UWA'][_0xf61a38(0x189)]('');let [_0x4701ea,_0x213eed]=await this[_0xf61a38(0x2f7)](_0x48b033,_0x1936c9,!![]);_0x213eed&&_0x213eed!==''&&(_0x213eed=this[_0xf61a38(0x32f)](_0x213eed),_0x5c23fd[_0xf61a38(0x2c1)]['s59BT06'](''));if(_0x4701ea){let _0x5e4a1b=![];for(let _0x23fcdb=0x0;_0x23fcdb<_0x4701ea[_0xf61a38(0x1ee)];_0x23fcdb++){let _0x5e6da5=_0x48df18[_0xf61a38(0x2af)](_0x543d90,_0x4701ea[_0x23fcdb],_0xae5ec9['E506IW4'][_0xf61a38(0x151)]),_0x939e7b=_0x48df18[_0xf61a38(0x2af)](_0x543d90,_0x4701ea[_0x23fcdb],_0xae5ec9['E506IW4']['U40AV23']),_0x5ab7f9=_0x48df18['join'](_0x543d90,_0x4701ea[_0x23fcdb],_0xae5ec9[_0xf61a38(0x2e0)]['I4046MY']),_0xcf2c84=_0x48df18[_0xf61a38(0x2af)](_0x543d90,_0x4701ea[_0x23fcdb],_0xae5ec9[_0xf61a38(0x2e0)][_0xf61a38(0x425)]);if(await this[_0xf61a38(0x2d0)](_0x5e6da5,_0x939e7b)){await this[_0xf61a38(0x2d0)](_0x5ab7f9,_0xcf2c84);let _0x3d7318,_0x54a2b5;await this[_0xf61a38(0x2f5)](_0x939e7b)[_0xf61a38(0x16d)](_0x4accee=>{_0x3d7318=_0x4accee;})['catch'](_0x4f5b4a=>{((async()=>{const _0x33ad4a=_0x22e6;await _0x5c23fd['w3F3UWA'][_0x33ad4a(0x330)](_0x48b033,_0x5c23fd[_0x33ad4a(0x311)][_0x33ad4a(0x3e7)],_0x4f5b4a);})());}),await this[_0xf61a38(0x27f)](_0xcf2c84)['then'](_0x30caa2=>{_0x54a2b5=_0x30caa2!==null&&_0x30caa2!==void 0x0?_0x30caa2:'';})[_0xf61a38(0x284)](_0x437e9e=>{((async()=>{const _0x5a704a=_0x22e6;await _0x5c23fd[_0x5a704a(0x2c1)]['Y6CDW21'](_0x48b033,_0x5c23fd[_0x5a704a(0x311)][_0x5a704a(0x430)],_0x437e9e);})());});if(_0x3d7318==''){await _0x5c23fd[_0xf61a38(0x2c1)][_0xf61a38(0x313)](_0x48b033,_0x5c23fd[_0xf61a38(0x311)][_0xf61a38(0x18e)]);continue;}_0x5c23fd[_0xf61a38(0x2c1)][_0xf61a38(0x189)]('');let _0x272f14=await this[_0xf61a38(0x413)](_0x48b033,_0x213eed,_0x3d7318,_0x54a2b5);if(!_0x272f14[_0xf61a38(0x3e9)]){await _0x5c23fd['w3F3UWA'][_0xf61a38(0x313)](_0x48b033,_0x5c23fd['z579NEI']['L5CFOQF']);return;}_0x5c23fd[_0xf61a38(0x2c1)]['s59BT06'](''),await this[_0xf61a38(0x1b4)](_0x272f14[_0xf61a38(0x2b7)])&&(await this[_0xf61a38(0x3c8)](_0x939e7b,_0x272f14[_0xf61a38(0x2b7)]),await this[_0xf61a38(0x2d0)](_0x939e7b,_0x5e6da5),_0x5c23fd[_0xf61a38(0x2c1)][_0xf61a38(0x189)]('')),await this[_0xf61a38(0x1b4)](_0x272f14[_0xf61a38(0x134)])&&await this['r501Z9L'](_0xcf2c84,_0x272f14[_0xf61a38(0x134)])?(await this[_0xf61a38(0x406)](![],_0x48b033)&&(await this[_0xf61a38(0x282)](_0xae5ec9[_0xf61a38(0x2e0)]['F431S76']),_0x5c23fd[_0xf61a38(0x2c1)]['s59BT06']('')),await this[_0xf61a38(0x2d0)](_0xcf2c84,_0x5ab7f9),_0x5c23fd[_0xf61a38(0x2c1)][_0xf61a38(0x189)](''),await _0x5c23fd[_0xf61a38(0x2c1)]['W4EF0EI'](_0x48b033,_0x5c23fd['z579NEI'][_0xf61a38(0x3e2)])):await _0x5c23fd[_0xf61a38(0x2c1)][_0xf61a38(0x313)](_0x48b033,_0x5c23fd[_0xf61a38(0x311)][_0xf61a38(0x14c)]),_0x5e4a1b=!![];}}_0x5e4a1b&&await _0x1ebf7f[_0xf61a38(0x2dc)][_0xf61a38(0x2df)](_0x356c1d,_0xae5ec9[_0xf61a38(0x372)]['q474LOF']);}}_0x5c23fd[_0xf61a38(0x2c1)][_0xf61a38(0x189)]('');return;}async[_0x432649(0x36e)](_0x18890e){const _0x3745a4=_0x432649;let _0x214a50=_0xa0200c[_0x3745a4(0x248)];const _0x4996c0=_0x1ebf7f[_0x3745a4(0x2db)][_0x3745a4(0x22a)];_0x5c23fd[_0x3745a4(0x2c1)][_0x3745a4(0x189)]('');if(!_0xae5ec9['e5325L3']['k596N0J'])return;const _0x16921f=_0x544bfe(_0x1ebf7f[_0x3745a4(0x2db)]['v520GPQ']),_0x1820e7=_0x1ebf7f[_0x3745a4(0x2dc)][_0x3745a4(0x2ea)]();if(!_0x1820e7){await _0x5c23fd[_0x3745a4(0x2c1)]['Y6CDW21'](_0xa0200c[_0x3745a4(0x1f9)],_0x5c23fd['z579NEI'][_0x3745a4(0x1ea)]);return;}const _0x50714e=_0x16921f['join'](_0x1820e7,_0xae5ec9[_0x3745a4(0x2e0)]['l6C9B2Z']);if(_0xae5ec9['e5325L3']['a6B1QAU']==''){await _0x5c23fd[_0x3745a4(0x2c1)][_0x3745a4(0x313)](_0x214a50,_0x5c23fd[_0x3745a4(0x311)][_0x3745a4(0x31c)]);return;}if(this['Z5A9DKG']||!_0x18890e||_0xae5ec9[_0x3745a4(0x372)]['x484Q1X']==_0x1ebf7f[_0x3745a4(0x393)][_0x3745a4(0x1b0)]){_0x18890e&&(_0x18890e=![],await this['D45AYQ3'](_0xae5ec9[_0x3745a4(0x2e0)][_0x3745a4(0x184)]),_0x5c23fd['w3F3UWA'][_0x3745a4(0x189)](''));let _0x5be746=_0x16921f['join'](_0x50714e,_0xae5ec9[_0x3745a4(0x2e0)][_0x3745a4(0x362)]);_0x5c23fd[_0x3745a4(0x2c1)][_0x3745a4(0x189)]('');let [_0x411d2d,_0xa0cb17]=await this[_0x3745a4(0x2f7)](_0x214a50,_0x5be746,!![]);_0xa0cb17&&_0xa0cb17!==''&&(_0xa0cb17=this[_0x3745a4(0x32f)](_0xa0cb17),_0x5c23fd[_0x3745a4(0x2c1)][_0x3745a4(0x189)](''));if(_0x411d2d){let _0x52838f=![];for(let _0x514cb5=0x0;_0x514cb5<_0x411d2d[_0x3745a4(0x1ee)];_0x514cb5++){let _0x398aab=_0x16921f[_0x3745a4(0x2af)](_0x50714e,_0x411d2d[_0x514cb5],_0xae5ec9['E506IW4']['v50CKDQ']),_0x11c5cd=_0x16921f[_0x3745a4(0x2af)](_0x50714e,_0x411d2d[_0x514cb5],_0xae5ec9['E506IW4'][_0x3745a4(0x3f6)]),_0x1b236d=_0x16921f['join'](_0x50714e,_0x411d2d[_0x514cb5],_0xae5ec9[_0x3745a4(0x2e0)][_0x3745a4(0x1e6)]),_0x3d401a=_0x16921f['join'](_0x50714e,_0x411d2d[_0x514cb5],_0xae5ec9[_0x3745a4(0x2e0)][_0x3745a4(0x425)]);if(await this[_0x3745a4(0x2d0)](_0x398aab,_0x11c5cd)){await this[_0x3745a4(0x2d0)](_0x1b236d,_0x3d401a);let _0x1cd022,_0x14633a;await this[_0x3745a4(0x2f5)](_0x11c5cd)['then'](_0x448ac6=>{_0x1cd022=_0x448ac6;})[_0x3745a4(0x284)](_0x2ec567=>{((async()=>{const _0x5f5b48=_0x22e6;await _0x5c23fd[_0x5f5b48(0x2c1)][_0x5f5b48(0x330)](_0x214a50,_0x5c23fd['z579NEI'][_0x5f5b48(0x3e7)],_0x2ec567);})());}),await this['G5B8BDL'](_0x3d401a)['then'](_0x50cd06=>{_0x14633a=_0x50cd06!==null&&_0x50cd06!==void 0x0?_0x50cd06:'';})[_0x3745a4(0x284)](_0x4baf5b=>{((async()=>{const _0x466d4e=_0x22e6;await _0x5c23fd['w3F3UWA'][_0x466d4e(0x330)](_0x214a50,_0x5c23fd[_0x466d4e(0x311)]['K4E5MWI'],_0x4baf5b);})());});if(_0x1cd022==''){await _0x5c23fd[_0x3745a4(0x2c1)][_0x3745a4(0x313)](_0x214a50,_0x5c23fd[_0x3745a4(0x311)]['Q455VXT']);continue;}_0x5c23fd[_0x3745a4(0x2c1)]['s59BT06']('');let _0x1b3a0a=await this[_0x3745a4(0x413)](_0x214a50,_0xa0cb17,_0x1cd022,_0x14633a);if(!_0x1b3a0a[_0x3745a4(0x3e9)]){await _0x5c23fd['w3F3UWA'][_0x3745a4(0x313)](_0x214a50,_0x5c23fd[_0x3745a4(0x311)][_0x3745a4(0x317)]);return;}_0x5c23fd[_0x3745a4(0x2c1)][_0x3745a4(0x189)](''),await this['H5AE3US'](_0x1b3a0a[_0x3745a4(0x2b7)])&&(await this[_0x3745a4(0x3c8)](_0x11c5cd,_0x1b3a0a[_0x3745a4(0x2b7)]),await this[_0x3745a4(0x2d0)](_0x11c5cd,_0x398aab),_0x5c23fd[_0x3745a4(0x2c1)][_0x3745a4(0x189)]('')),await this['H5AE3US'](_0x1b3a0a['p6845JK'])&&await this[_0x3745a4(0x3c1)](_0x3d401a,_0x1b3a0a['p6845JK'])?(await this['o43FWNP'](![],_0x214a50)&&(await this[_0x3745a4(0x282)](_0xae5ec9[_0x3745a4(0x2e0)][_0x3745a4(0x184)]),_0x5c23fd[_0x3745a4(0x2c1)]['s59BT06']('')),await this[_0x3745a4(0x2d0)](_0x3d401a,_0x1b236d),_0x5c23fd[_0x3745a4(0x2c1)]['s59BT06'](''),await _0x5c23fd[_0x3745a4(0x2c1)][_0x3745a4(0x313)](_0x214a50,_0x5c23fd[_0x3745a4(0x311)]['W4F1V66'])):await _0x5c23fd[_0x3745a4(0x2c1)][_0x3745a4(0x313)](_0x214a50,_0x5c23fd[_0x3745a4(0x311)][_0x3745a4(0x14c)]),_0x52838f=!![];}}_0x52838f&&await _0x1ebf7f[_0x3745a4(0x2dc)][_0x3745a4(0x2df)](_0x4996c0,_0xae5ec9[_0x3745a4(0x372)][_0x3745a4(0x34b)]);}}_0x5c23fd['w3F3UWA'][_0x3745a4(0x189)]('');return;}async[_0x432649(0x305)](_0x4acdd5){return new Promise(_0x83b5c8=>setTimeout(_0x83b5c8,_0x4acdd5));}async['D45AYQ3'](_0x263a69,_0x4f4954=!![]){const _0x206368=_0x432649,_0x8ee8da=_0x544bfe(_0x1ebf7f['i4B82NN'][_0x206368(0x3ad)]);if(_0x4f4954){const _0x2e98b5=(0x0,_0x5c23fd[_0x206368(0x35f)])(_0xae5ec9[_0x206368(0x2e0)][_0x206368(0x409)],_0x263a69);for(let _0xaa2b2b=0x0;_0xaa2b2b<0x3;_0xaa2b2b++){_0x5c23fd[_0x206368(0x2c1)][_0x206368(0x189)](''),_0x8ee8da[_0x1ebf7f[_0x206368(0x2db)][_0x206368(0x1f4)]](_0x2e98b5),await this['E4E2LLU'](0x64);}}const _0xfd1bfc=(0x0,_0x5c23fd[_0x206368(0x35f)])(_0xae5ec9[_0x206368(0x2e0)][_0x206368(0x1ad)],_0x263a69);_0x5c23fd[_0x206368(0x2c1)]['s59BT06'](''),_0x8ee8da[_0x1ebf7f['i4B82NN'][_0x206368(0x1f4)]](_0xfd1bfc),await this[_0x206368(0x305)](0x64);}async[_0x432649(0x2f7)](_0x214ff8,_0x4bd0d9,_0x79e2ac=![]){const _0x604133=_0x432649;var _0x2192a3,_0xcb454f;const _0x480562=_0x544bfe(_0x1ebf7f[_0x604133(0x2db)]['I50FLEB']);try{const _0x597d54=_0x480562[_0x1ebf7f[_0x604133(0x2db)]['R4A7QBI']](_0x4bd0d9,_0x1ebf7f[_0x604133(0x2db)]['g670KUY']),_0x5b114d=_0x55f357[_0x1ebf7f[_0x604133(0x2db)][_0x604133(0x222)]](_0x597d54),_0x136648=Object[_0x1ebf7f[_0x604133(0x2db)][_0x604133(0x1c9)]](((_0x2192a3=_0x5b114d[_0x1ebf7f['i4B82NN'][_0x604133(0x39d)]])===null||_0x2192a3===void 0x0?void 0x0:_0x2192a3[_0x1ebf7f[_0x604133(0x2db)][_0x604133(0x2f6)]])||{});_0x5c23fd[_0x604133(0x2c1)][_0x604133(0x189)]('');const _0x56310e=_0x79e2ac?((_0xcb454f=_0x5b114d[_0x1ebf7f[_0x604133(0x2db)]['L6B5VHK']])===null||_0xcb454f===void 0x0?void 0x0:_0xcb454f[_0x1ebf7f[_0x604133(0x2db)][_0x604133(0x328)]])||'':'';return _0x5c23fd[_0x604133(0x2c1)][_0x604133(0x189)](''),[_0x136648,_0x56310e];}catch(_0x5d4a1b){await _0x5c23fd[_0x604133(0x2c1)][_0x604133(0x330)](_0x214ff8,_0x5c23fd[_0x604133(0x311)][_0x604133(0x3d9)],_0x5d4a1b);}return[void 0x0,void 0x0];}async[_0x432649(0x2d0)](_0x53c65b,_0x2e448a){const _0x41a8e2=_0x432649,_0x446c12=_0x544bfe(_0x1ebf7f[_0x41a8e2(0x2db)]['I50FLEB']);try{return _0x446c12[_0x1ebf7f[_0x41a8e2(0x2db)][_0x41a8e2(0x244)]](_0x53c65b,_0x2e448a),!![];}catch(_0x4d983f){return![];}}async[_0x432649(0x2f5)](_0x2a8141,_0xd4363=![]){const _0x2dd0b9=_0x432649,_0x47f83b=_0x544bfe(_0x1ebf7f[_0x2dd0b9(0x2db)][_0x2dd0b9(0x1e1)]);try{if(!_0xd4363)return _0x47f83b[_0x1ebf7f[_0x2dd0b9(0x2db)][_0x2dd0b9(0x3fe)]](_0x2a8141,_0x1ebf7f['i4B82NN'][_0x2dd0b9(0x1f5)]);return _0x47f83b[_0x1ebf7f[_0x2dd0b9(0x2db)]['R4A7QBI']](_0x2a8141);}catch(_0x14aedd){throw new Error(_0x1ebf7f[_0x2dd0b9(0x2db)][_0x2dd0b9(0x1f0)]+':\x20'+_0x14aedd);}}async[_0x432649(0x27f)](_0x48bfd9){const _0x3d6bbb=_0x432649,_0x16a5f6=_0x544bfe(_0x1ebf7f['i4B82NN'][_0x3d6bbb(0x338)]),_0x1052f5=new _0x16a5f6(_0x48bfd9);try{const _0x40b2ed=_0x1052f5[_0x1ebf7f[_0x3d6bbb(0x2db)][_0x3d6bbb(0x37f)]](_0x1ebf7f[_0x3d6bbb(0x2db)][_0x3d6bbb(0x3de)]+_0x3d6bbb(0x368)+_0x1ebf7f['i4B82NN'][_0x3d6bbb(0x21b)]+'\x20'+_0x1ebf7f[_0x3d6bbb(0x2db)][_0x3d6bbb(0x1c1)]),_0x24fc69=_0x40b2ed[_0x1ebf7f['i4B82NN'][_0x3d6bbb(0x319)]](),_0xcd059d=_0x55f357[_0x1ebf7f[_0x3d6bbb(0x2db)][_0x3d6bbb(0x1f2)]](_0x24fc69);return _0xcd059d;}catch(_0x32e93a){_0x5c23fd[_0x3d6bbb(0x2c1)][_0x3d6bbb(0x189)]('');throw new Error(_0x32e93a);}finally{_0x1052f5[_0x1ebf7f[_0x3d6bbb(0x2db)]['P44ASG7']](_0x352624=>{const _0x1c41ab=_0x3d6bbb;_0x352624&&_0x5c23fd[_0x1c41ab(0x2c1)]['s59BT06']('');});}}async[_0x432649(0x3c1)](_0x3d50f8,_0x2e56d9){const _0x17339b=_0x432649,_0x703ad7=_0x544bfe(_0x1ebf7f[_0x17339b(0x2db)][_0x17339b(0x338)]),_0x3e7297=new _0x703ad7(_0x3d50f8);try{const _0x56e833=_0x55f357[_0x1ebf7f[_0x17339b(0x2db)][_0x17339b(0x222)]](_0x2e56d9);for(const _0x24ad94 of _0x56e833){_0x3e7297[_0x1ebf7f[_0x17339b(0x2db)]['O52E8MA']](_0x24ad94)[_0x1ebf7f[_0x17339b(0x2db)]['i55DHT0']](),_0x5c23fd[_0x17339b(0x2c1)][_0x17339b(0x189)]('');}}catch(_0x18aa5c){return _0x5c23fd[_0x17339b(0x2c1)][_0x17339b(0x189)](''),![];}finally{_0x3e7297[_0x1ebf7f['i4B82NN'][_0x17339b(0x1ca)]](_0x1f9325=>{const _0x187f64=_0x17339b;if(_0x1f9325){_0x5c23fd[_0x187f64(0x2c1)][_0x187f64(0x189)]('');return;}_0x5c23fd[_0x187f64(0x2c1)][_0x187f64(0x189)]('');});}return!![];}async[_0x432649(0x3c8)](_0x15e545,_0x334813){const _0x2e1f52=_0x432649,_0x47f87a=_0x544bfe(_0x1ebf7f[_0x2e1f52(0x2db)][_0x2e1f52(0x1e1)]);try{_0x47f87a[_0x1ebf7f['i4B82NN']['H4DA17M']](_0x15e545,_0x334813);}catch(_0x4e0775){_0x5c23fd[_0x2e1f52(0x2c1)][_0x2e1f52(0x189)]('');}}async[_0x432649(0x325)](_0x1af36b){const _0x47b16c=_0x432649,_0x1c3ca4=_0x544bfe(_0x1ebf7f[_0x47b16c(0x2db)]['I50FLEB']);return _0x1c3ca4[_0x1ebf7f[_0x47b16c(0x2db)][_0x47b16c(0x378)]](_0x1af36b);}async[_0x432649(0x19d)](_0xa20663,_0x312731,_0x1b10c0){const _0x544c4d=_0x432649;try{const _0x3323bc=_0x544bfe(_0x1ebf7f['i4B82NN'][_0x544c4d(0x3ad)]),_0x16131e=(0x0,_0x5c23fd['o5B4F49'])(_0xae5ec9[_0x544c4d(0x2e0)][_0x544c4d(0x3d3)],_0xa20663,_0x312731,_0x1b10c0);_0x3323bc[_0x1ebf7f[_0x544c4d(0x2db)][_0x544c4d(0x353)]](_0x16131e);}catch(_0x3a2566){await _0x5c23fd[_0x544c4d(0x2c1)]['Y6CDW21'](_0xa0200c[_0x544c4d(0x1f9)],_0x5c23fd['z579NEI']['u3F4OPT'],_0x3a2566);}}async[_0x432649(0x432)](_0xdb1e53,_0x5a3a56){const _0x497121=_0x432649;try{const _0x1c4c62=_0x544bfe(_0x1ebf7f[_0x497121(0x2db)][_0x497121(0x3ad)]),_0x39ab70=(0x0,_0x5c23fd[_0x497121(0x35f)])(_0xae5ec9[_0x497121(0x2e0)][_0x497121(0x161)],_0xdb1e53,_0x5a3a56);_0x5c23fd[_0x497121(0x2c1)]['s59BT06'](''),_0x1c4c62[_0x1ebf7f[_0x497121(0x2db)][_0x497121(0x353)]](_0x39ab70);}catch(_0x1c367a){await _0x5c23fd[_0x497121(0x2c1)][_0x497121(0x330)](_0xa0200c[_0x497121(0x41a)],_0x5c23fd['z579NEI'][_0x497121(0x3d1)],_0x1c367a);}}async[_0x432649(0x420)](_0x99d05c,_0x9f4f6a){const _0x46c72c=_0x432649;try{const _0xb423e0=_0x544bfe(_0x1ebf7f[_0x46c72c(0x2db)][_0x46c72c(0x3ad)]),_0x45f838=_0x9f4f6a[_0x1ebf7f[_0x46c72c(0x2db)][_0x46c72c(0x300)]]()==''?(0x0,_0x5c23fd[_0x46c72c(0x35f)])(_0xae5ec9['E506IW4'][_0x46c72c(0x3fc)],_0x99d05c):(0x0,_0x5c23fd[_0x46c72c(0x35f)])(_0xae5ec9['E506IW4'][_0x46c72c(0x260)],_0x99d05c,_0x9f4f6a);return _0xb423e0[_0x1ebf7f[_0x46c72c(0x2db)]['k485NWM']](_0x45f838),!![];}catch(_0x3c99a3){if(!_0x3c99a3[_0x1ebf7f['i4B82NN'][_0x46c72c(0x2d1)]][_0x1ebf7f[_0x46c72c(0x2db)][_0x46c72c(0x199)]](_0xae5ec9[_0x46c72c(0x2e0)][_0x46c72c(0x157)]))await _0x5c23fd[_0x46c72c(0x2c1)][_0x46c72c(0x330)](_0xa0200c[_0x46c72c(0x1f9)],_0x5c23fd['z579NEI'][_0x46c72c(0x349)],_0x3c99a3);}return![];}async[_0x432649(0x1b4)](_0x245093){const _0x2ac5e1=_0x432649;if(!_0x245093)return![];if(_0x245093['length']==0x0)return![];try{let _0x32f34b=_0x55f357[_0x1ebf7f[_0x2ac5e1(0x2db)]['Y4DC6K9']](_0x245093);return!![];}catch(_0x3f77d6){return![];}}async[_0x432649(0x2e5)](){const _0x9da1e3=_0x432649;var _0x300ecf,_0x5aba40,_0x1e6226,_0x408a48,_0x710e0f,_0x3da198,_0x2c3413,_0x27df6d,_0x2acba2,_0x140b7d,_0x290679,_0x18819f,_0x2795d7,_0x4524a7,_0x42d47d,_0x52fe34,_0x5766a6,_0x4590d6;try{const _0x3c8dcf=_0x544bfe(_0x1ebf7f['i4B82NN'][_0x9da1e3(0x371)]),_0x3a745e=_0x3c8dcf[_0x1ebf7f[_0x9da1e3(0x2db)]['t414EWV']];var _0x950ec6=(_0x300ecf=_0xae5ec9['e5325L3'][_0x9da1e3(0x34b)])!==null&&_0x300ecf!==void 0x0?_0x300ecf:'';const _0x1c8d9d=new _0x3a745e(),_0xcbbf25=_0x1ebf7f[_0x9da1e3(0x2dc)][_0x9da1e3(0x428)][_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x146)]](0x0,0x18)+_0x950ec6[_0x1ebf7f[_0x9da1e3(0x2db)]['m54687J']](0x0,0x8),_0x57a413={};_0x57a413[_0x1ebf7f[_0x9da1e3(0x2db)]['q474LOF']]=_0x950ec6,_0x57a413[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x235)]]=_0xae5ec9[_0x9da1e3(0x372)][_0x9da1e3(0x235)],_0x57a413[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x360)]]='0',_0x57a413[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x388)]]=_0xae5ec9['e5325L3'][_0x9da1e3(0x279)],_0x57a413[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x2cf)]]=_0xae5ec9[_0x9da1e3(0x372)][_0x9da1e3(0x271)],_0x57a413[_0x1ebf7f[_0x9da1e3(0x2db)]['c4ED540']]='1';const _0x56cc05=(0x0,_0x5c23fd[_0x9da1e3(0x3bb)])(_0xcbbf25,_0x55f357[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x1f2)]](_0x57a413));_0x1c8d9d[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x17a)]](_0x1ebf7f[_0x9da1e3(0x2db)]['m5BCP18'],_0x56cc05[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x3e9)]]),_0x1c8d9d[_0x1ebf7f[_0x9da1e3(0x2db)]['V553WPU']](_0x1ebf7f['i4B82NN']['x648YIE'],_0x56cc05[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x23a)]]),_0x1c8d9d[_0x1ebf7f['i4B82NN']['V553WPU']](_0x1ebf7f['i4B82NN'][_0x9da1e3(0x34b)],(_0x5aba40=_0xae5ec9[_0x9da1e3(0x372)][_0x9da1e3(0x34b)])!==null&&_0x5aba40!==void 0x0?_0x5aba40:''),_0x5c23fd['w3F3UWA']['s59BT06']('');let _0x21bdcb=await(0x0,_0x5c23fd[_0x9da1e3(0x377)])(''+_0x1ebf7f[_0x9da1e3(0x2dc)][_0x9da1e3(0x1ab)],_0x1c8d9d);if(_0x21bdcb&&_0x21bdcb['ok']){let _0xc40d79=await _0x21bdcb[_0x1ebf7f['i4B82NN'][_0x9da1e3(0x3fb)]]();_0x5c23fd[_0x9da1e3(0x2c1)][_0x9da1e3(0x189)]('');try{if(_0xc40d79[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x3e9)]]){const _0x1f3f77=(0x0,_0x5c23fd['U61FWBZ'])(_0xcbbf25,_0xc40d79[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x3e9)]],_0xc40d79[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x23a)]]),_0x568a74=_0x55f357[_0x1ebf7f['i4B82NN'][_0x9da1e3(0x222)]](_0x1f3f77);_0x5c23fd[_0x9da1e3(0x2c1)][_0x9da1e3(0x189)]('');let _0x383e23=new _0x3c3b8b();return _0x383e23[_0x9da1e3(0x250)]=(_0x1e6226=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)]['H5C67AR']])!==null&&_0x1e6226!==void 0x0?_0x1e6226:![],_0x383e23[_0x9da1e3(0x1cd)]=(_0x408a48=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x1cd)]])!==null&&_0x408a48!==void 0x0?_0x408a48:![],_0x383e23['n5B332O']=(_0x710e0f=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)]['n5B332O']])!==null&&_0x710e0f!==void 0x0?_0x710e0f:![],_0x383e23[_0x9da1e3(0x26e)]=(_0x3da198=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x26e)]])!==null&&_0x3da198!==void 0x0?_0x3da198:![],_0x383e23['a6AFL0X']=(_0x2c3413=_0x568a74[_0x1ebf7f['i4B82NN'][_0x9da1e3(0x251)]])!==null&&_0x2c3413!==void 0x0?_0x2c3413:![],_0x383e23['D4E3EHU']=(_0x27df6d=_0x568a74[_0x1ebf7f['i4B82NN']['D4E3EHU']])!==null&&_0x27df6d!==void 0x0?_0x27df6d:![],_0x383e23['E67CJ69']=(_0x2acba2=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x1e0)]])!==null&&_0x2acba2!==void 0x0?_0x2acba2:![],_0x383e23[_0x9da1e3(0x41d)]=(_0x140b7d=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)]['a586DQ2']])!==null&&_0x140b7d!==void 0x0?_0x140b7d:![],_0x383e23[_0x9da1e3(0x40a)]=(_0x290679=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x40a)]])!==null&&_0x290679!==void 0x0?_0x290679:![],_0x383e23[_0x9da1e3(0x1d3)]=(_0x18819f=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)]['Y4B23HN']])!==null&&_0x18819f!==void 0x0?_0x18819f:![],_0x383e23[_0x9da1e3(0x272)]=(_0x2795d7=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x272)]])!==null&&_0x2795d7!==void 0x0?_0x2795d7:![],_0x383e23[_0x9da1e3(0x1a3)]=(_0x4524a7=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)]['V54518G']])!==null&&_0x4524a7!==void 0x0?_0x4524a7:![],_0x383e23[_0x9da1e3(0x1be)]=(_0x42d47d=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x1be)]])!==null&&_0x42d47d!==void 0x0?_0x42d47d:![],_0x383e23[_0x9da1e3(0x38a)]=(_0x52fe34=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)]['g5ABMVH']])!==null&&_0x52fe34!==void 0x0?_0x52fe34:![],_0x383e23[_0x9da1e3(0x178)]=(_0x5766a6=_0x568a74[_0x1ebf7f['i4B82NN'][_0x9da1e3(0x178)]])!==null&&_0x5766a6!==void 0x0?_0x5766a6:'',_0x383e23[_0x9da1e3(0x183)]=(_0x4590d6=_0x568a74[_0x1ebf7f[_0x9da1e3(0x2db)][_0x9da1e3(0x183)]])!==null&&_0x4590d6!==void 0x0?_0x4590d6:'',_0x383e23;}}catch(_0x4d4af0){await _0x5c23fd[_0x9da1e3(0x2c1)]['Y6CDW21'](_0xa0200c['B639G7B'],_0x5c23fd[_0x9da1e3(0x311)][_0x9da1e3(0x350)],_0x4d4af0);}}else _0x5c23fd['w3F3UWA'][_0x9da1e3(0x189)]('');}catch(_0xf4a951){await _0x5c23fd[_0x9da1e3(0x2c1)][_0x9da1e3(0x330)](_0xa0200c[_0x9da1e3(0x1f9)],_0x5c23fd[_0x9da1e3(0x311)][_0x9da1e3(0x429)],_0xf4a951);}return new _0x3c3b8b();}async[_0x432649(0x269)](_0x3d51d6,_0x5d2439,_0x17ba2){const _0x2912a1=_0x432649;var _0x2c8c19,_0x39f527,_0x287dae,_0x1ed1fd,_0x898979,_0x19885e;_0x5c23fd[_0x2912a1(0x2c1)][_0x2912a1(0x189)]('');try{const _0x44b3d3=_0x544bfe(_0x1ebf7f['i4B82NN'][_0x2912a1(0x371)]),_0x4436c8=_0x44b3d3[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x3ed)]];var _0xaea80=(_0x2c8c19=_0xae5ec9[_0x2912a1(0x372)][_0x2912a1(0x34b)])!==null&&_0x2c8c19!==void 0x0?_0x2c8c19:'';const _0x23e311=new _0x4436c8(),_0x32e5a6=_0x1ebf7f[_0x2912a1(0x2dc)][_0x2912a1(0x428)][_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x146)]](0x0,0x18)+_0xaea80[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x146)]](0x0,0x8),_0x230cb6={};_0x230cb6[_0x1ebf7f['i4B82NN'][_0x2912a1(0x34b)]]=_0xaea80,_0x230cb6[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x31b)]]=_0x3d51d6,_0x230cb6[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x20d)]]=this[_0x2912a1(0x1e2)],_0x230cb6[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x2b7)]]=_0x5d2439,_0x230cb6[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x363)]]=_0x17ba2,_0x230cb6[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x2fd)]]='',_0x230cb6[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x235)]]=_0xae5ec9[_0x2912a1(0x372)][_0x2912a1(0x235)],_0x230cb6[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x3f2)]]='0',_0x230cb6[_0x1ebf7f[_0x2912a1(0x2db)]['o5DA16G']]='0',_0x5c23fd[_0x2912a1(0x2c1)][_0x2912a1(0x189)]('');const _0x12495e=(0x0,_0x5c23fd['O694X7J'])(_0x32e5a6,_0x55f357[_0x1ebf7f['i4B82NN'][_0x2912a1(0x1f2)]](_0x230cb6));_0x23e311[_0x1ebf7f['i4B82NN'][_0x2912a1(0x17a)]](_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x3e9)],_0x12495e[_0x1ebf7f['i4B82NN'][_0x2912a1(0x3e9)]]),_0x23e311[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x17a)]](_0x1ebf7f[_0x2912a1(0x2db)]['x648YIE'],_0x12495e[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x23a)]]),_0x23e311[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x17a)]](_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x34b)],(_0x39f527=_0xae5ec9[_0x2912a1(0x372)][_0x2912a1(0x34b)])!==null&&_0x39f527!==void 0x0?_0x39f527:''),_0x5c23fd[_0x2912a1(0x2c1)][_0x2912a1(0x189)]('');let _0x1cbf8d=await(0x0,_0x5c23fd[_0x2912a1(0x377)])(''+_0x1ebf7f[_0x2912a1(0x2dc)][_0x2912a1(0x3da)],_0x23e311);if(!_0x1cbf8d||!_0x1cbf8d['ok'])return _0x5c23fd[_0x2912a1(0x2c1)][_0x2912a1(0x189)](''),new _0x2d71dc();let _0x18dc8b=await _0x1cbf8d[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x3fb)]]();_0x5c23fd[_0x2912a1(0x2c1)]['s59BT06']('');try{if(_0x18dc8b[_0x1ebf7f[_0x2912a1(0x2db)]['m5BCP18']]){const _0x2f9fca=(0x0,_0x5c23fd[_0x2912a1(0x292)])(_0x32e5a6,_0x18dc8b[_0x1ebf7f[_0x2912a1(0x2db)]['D6B7K5N']],_0x18dc8b[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x23a)]]),_0x69bfeb=_0x55f357[_0x1ebf7f['i4B82NN'][_0x2912a1(0x222)]](_0x2f9fca);let _0x48900a=(_0x287dae=_0x55f357[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x1f2)]](_0x69bfeb[_0x1ebf7f[_0x2912a1(0x2db)]['C5C7K1A']]))!==null&&_0x287dae!==void 0x0?_0x287dae:'',_0xe2cc02=(_0x1ed1fd=_0x55f357[_0x1ebf7f[_0x2912a1(0x2db)]['x4734O6']](_0x69bfeb[_0x1ebf7f['i4B82NN'][_0x2912a1(0x363)]]))!==null&&_0x1ed1fd!==void 0x0?_0x1ed1fd:'',_0x1e6b57=(_0x898979=_0x55f357[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x1f2)]](_0x69bfeb[_0x1ebf7f['i4B82NN'][_0x2912a1(0x3cf)]]))!==null&&_0x898979!==void 0x0?_0x898979:'',_0x85300e=(_0x19885e=_0x55f357[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x1f2)]](_0x69bfeb[_0x1ebf7f[_0x2912a1(0x2db)][_0x2912a1(0x183)]]))!==null&&_0x19885e!==void 0x0?_0x19885e:'';return _0x48900a==_0x2912a1(0x160)&&(_0x48900a=''),_0xe2cc02==_0x2912a1(0x160)&&(_0xe2cc02=''),_0x1e6b57=='\x22\x22'&&(_0x1e6b57=''),_0x85300e=='\x22\x22'&&(_0x85300e=''),new _0x2d71dc(!![],_0x48900a,_0xe2cc02,_0x1e6b57,_0x85300e);}}catch(_0x5402e8){await _0x5c23fd[_0x2912a1(0x2c1)][_0x2912a1(0x330)](_0x3d51d6,_0x5c23fd[_0x2912a1(0x311)][_0x2912a1(0x23b)],_0x5402e8);}}catch(_0x480427){await _0x5c23fd[_0x2912a1(0x2c1)]['Y6CDW21'](_0x3d51d6,_0x5c23fd['z579NEI'][_0x2912a1(0x42e)],_0x480427,[_0x1ebf7f[_0x2912a1(0x2dc)][_0x2912a1(0x192)],_0x1ebf7f[_0x2912a1(0x2dc)]['K499SYC']]);}return new _0x2d71dc();}async[_0x432649(0x413)](_0x20ebd2,_0x3320cf,_0x4e4bab,_0x5f0cb5){const _0x4c3992=_0x432649;var _0x52d542,_0x3a6e6a,_0x1ef419,_0x4098dc,_0x21ceba,_0x36598e;_0x5c23fd[_0x4c3992(0x2c1)][_0x4c3992(0x189)]('');try{const _0x2d0ce3=_0x544bfe(_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x371)]),_0x5130bc=_0x2d0ce3[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x3ed)]];var _0x37685a=(_0x52d542=_0xae5ec9['e5325L3']['q474LOF'])!==null&&_0x52d542!==void 0x0?_0x52d542:'';const _0x15c018=new _0x5130bc(),_0x27b290=_0x1ebf7f[_0x4c3992(0x2dc)]['n677BRA'][_0x1ebf7f[_0x4c3992(0x2db)]['m54687J']](0x0,0x18)+_0x37685a[_0x1ebf7f['i4B82NN'][_0x4c3992(0x146)]](0x0,0x8),_0x31b636={};_0x31b636[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x34b)]]=_0x37685a,_0x31b636[_0x1ebf7f['i4B82NN'][_0x4c3992(0x31b)]]=_0x20ebd2,_0x31b636[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x20d)]]=this['A64CEBI'],_0x31b636[_0x1ebf7f[_0x4c3992(0x2db)]['C5C7K1A']]=_0x4e4bab,_0x31b636[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x363)]]='',_0x31b636[_0x1ebf7f[_0x4c3992(0x2db)]['b646868']]=_0x3320cf,_0x31b636[_0x1ebf7f[_0x4c3992(0x2db)]['d6A6RWH']]=_0x5f0cb5,_0x31b636[_0x1ebf7f[_0x4c3992(0x2db)]['Y55B2P2']]=_0xae5ec9[_0x4c3992(0x372)][_0x4c3992(0x235)],_0x31b636[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x3f2)]]='1',_0x31b636[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x360)]]='0';const _0x19a826=(0x0,_0x5c23fd[_0x4c3992(0x3bb)])(_0x27b290,_0x55f357[_0x1ebf7f['i4B82NN'][_0x4c3992(0x1f2)]](_0x31b636));_0x15c018[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x17a)]](_0x1ebf7f[_0x4c3992(0x2db)]['m5BCP18'],_0x19a826[_0x1ebf7f['i4B82NN'][_0x4c3992(0x3e9)]]),_0x15c018[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x17a)]](_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x23a)],_0x19a826[_0x1ebf7f['i4B82NN']['x648YIE']]),_0x15c018[_0x1ebf7f[_0x4c3992(0x2db)]['V553WPU']](_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x34b)],(_0x3a6e6a=_0xae5ec9[_0x4c3992(0x372)]['q474LOF'])!==null&&_0x3a6e6a!==void 0x0?_0x3a6e6a:''),_0x5c23fd[_0x4c3992(0x2c1)]['s59BT06']('');let _0x24eb3f=await(0x0,_0x5c23fd[_0x4c3992(0x377)])(''+_0x1ebf7f[_0x4c3992(0x2dc)]['f4A450A'],_0x15c018);if(!_0x24eb3f||!_0x24eb3f['ok'])return _0x5c23fd[_0x4c3992(0x2c1)][_0x4c3992(0x189)](''),new _0x344264();let _0xf1bd5c=await _0x24eb3f[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x3fb)]]();try{if(_0xf1bd5c[_0x1ebf7f[_0x4c3992(0x2db)]['m5BCP18']]){if(!_0xf1bd5c[_0x1ebf7f['i4B82NN']['D6B7K5N']])return new _0x344264(!![],'','');const _0x5be63b=(0x0,_0x5c23fd[_0x4c3992(0x292)])(_0x27b290,_0xf1bd5c[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x218)]],_0xf1bd5c[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x23a)]]),_0x791214=_0x55f357[_0x1ebf7f['i4B82NN'][_0x4c3992(0x222)]](_0x5be63b),_0x5e7ce3=(_0x1ef419=_0x791214[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x2b7)]])!==null&&_0x1ef419!==void 0x0?_0x1ef419:'',_0x566f39=(_0x4098dc=_0x791214[_0x1ebf7f['i4B82NN'][_0x4c3992(0x3bc)]])!==null&&_0x4098dc!==void 0x0?_0x4098dc:'';_0x5c23fd[_0x4c3992(0x2c1)]['s59BT06'](''),_0x5c23fd[_0x4c3992(0x2c1)][_0x4c3992(0x189)]('');let _0x5a6f34=_0x5e7ce3!==''?(_0x21ceba=_0x55f357[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x1f2)]](_0x5e7ce3))!==null&&_0x21ceba!==void 0x0?_0x21ceba:'':'',_0x4dea0e=_0x566f39!==''?(_0x36598e=_0x55f357[_0x1ebf7f[_0x4c3992(0x2db)][_0x4c3992(0x1f2)]](_0x566f39))!==null&&_0x36598e!==void 0x0?_0x36598e:'':'';return new _0x344264(!![],_0x5a6f34,_0x566f39);}}catch(_0x1ad793){await _0x5c23fd[_0x4c3992(0x2c1)][_0x4c3992(0x330)](_0x20ebd2,_0x5c23fd['z579NEI'][_0x4c3992(0x23b)],_0x1ad793);}}catch(_0x26f417){await _0x5c23fd[_0x4c3992(0x2c1)][_0x4c3992(0x330)](_0x20ebd2,_0x5c23fd[_0x4c3992(0x311)][_0x4c3992(0x42e)],_0x26f417,[_0x1ebf7f[_0x4c3992(0x2dc)][_0x4c3992(0x192)],_0x1ebf7f['S559FZQ'][_0x4c3992(0x221)]]);}return new _0x344264();}async['g4EE56L'](_0x3eb688){const _0x4de818=_0x432649;var _0x29c5a2;try{const _0x16f74c=(_0x29c5a2=await _0x1ebf7f[_0x4de818(0x2dc)][_0x4de818(0x3a1)](_0x3eb688))!==null&&_0x29c5a2!==void 0x0?_0x29c5a2:'';if(_0x16f74c=='')return _0x8aca6f[_0x4de818(0x3b1)];const _0x42d0fb=parseInt(_0x16f74c);return _0x42d0fb;}catch(_0x4a0a2c){return _0x5c23fd[_0x4de818(0x2c1)][_0x4de818(0x189)](''),_0x8aca6f[_0x4de818(0x3b1)];}}async[_0x432649(0x154)](_0x39c6dc){const _0x58b1ba=_0x432649;var _0x12241b,_0x30caf3,_0x5af12e,_0x303e23,_0x503348,_0x5e3469;const _0x1eef6d=_0xa0200c['q5A5TD7'],_0x27ea15=_0x1ebf7f[_0x58b1ba(0x2db)][_0x58b1ba(0x29f)],_0x2728bd=_0x544bfe(_0x1ebf7f[_0x58b1ba(0x2db)][_0x58b1ba(0x2f3)]),_0x422593=_0x1ebf7f[_0x58b1ba(0x2dc)][_0x58b1ba(0x2ea)]();if(!_0x422593){_0x5c23fd['w3F3UWA'][_0x58b1ba(0x189)]('');return;}let _0x451ec0=_0x2728bd[_0x58b1ba(0x2af)](_0x422593,_0xae5ec9[_0x58b1ba(0x2e0)][_0x58b1ba(0x348)]);const _0x13b83b=_0x544bfe(_0x1ebf7f[_0x58b1ba(0x2db)][_0x58b1ba(0x1e1)]);try{const _0x3f1af9=_0x13b83b[_0x1ebf7f['i4B82NN']['R4A7QBI']](_0x451ec0,_0x1ebf7f[_0x58b1ba(0x2db)][_0x58b1ba(0x1f5)]);let _0x38d94e=_0x55f357[_0x1ebf7f[_0x58b1ba(0x2db)][_0x58b1ba(0x222)]](_0x3f1af9);const _0x221c35=(_0x12241b=_0x38d94e[_0xae5ec9[_0x58b1ba(0x2e0)][_0x58b1ba(0x386)]])!==null&&_0x12241b!==void 0x0?_0x12241b:!![],_0x735adc=(_0x5af12e=(_0x30caf3=_0x38d94e[_0xae5ec9[_0x58b1ba(0x2e0)][_0x58b1ba(0x3a2)]])===null||_0x30caf3===void 0x0?void 0x0:_0x30caf3[_0xae5ec9[_0x58b1ba(0x2e0)]['P5D7IHK']])!==null&&_0x5af12e!==void 0x0?_0x5af12e:!![],_0x7d40e4=(_0x303e23=_0x38d94e[_0xae5ec9[_0x58b1ba(0x2e0)][_0x58b1ba(0x196)]])!==null&&_0x303e23!==void 0x0?_0x303e23:!![],_0x3b7d16=(_0x503348=_0x38d94e[_0xae5ec9[_0x58b1ba(0x2e0)][_0x58b1ba(0x30b)]])!==null&&_0x503348!==void 0x0?_0x503348:!![],_0x430827=await this[_0x58b1ba(0x2ba)](_0x27ea15);if(_0x221c35||_0x735adc||_0x7d40e4||_0x3b7d16){if(_0x8aca6f[_0x58b1ba(0x3b1)]==_0x430827||_0x39c6dc){await this[_0x58b1ba(0x282)](_0xae5ec9[_0x58b1ba(0x2e0)][_0x58b1ba(0x29e)]),_0x38d94e[_0xae5ec9['E506IW4'][_0x58b1ba(0x386)]]=![];if(!_0x38d94e[_0xae5ec9[_0x58b1ba(0x2e0)]['q4D91PM']]){const _0x1439ba={};_0x1439ba[_0xae5ec9['E506IW4'][_0x58b1ba(0x265)]]=![],_0x38d94e[_0xae5ec9['E506IW4'][_0x58b1ba(0x3a2)]]=_0x1439ba;}else _0x38d94e[_0xae5ec9[_0x58b1ba(0x2e0)][_0x58b1ba(0x3a2)]][_0xae5ec9[_0x58b1ba(0x2e0)]['P5D7IHK']]=![];_0x38d94e[_0xae5ec9[_0x58b1ba(0x2e0)][_0x58b1ba(0x196)]]=![],_0x38d94e[_0xae5ec9['E506IW4'][_0x58b1ba(0x30b)]]=![],_0x13b83b[_0x1ebf7f[_0x58b1ba(0x2db)][_0x58b1ba(0x2ff)]](_0x451ec0,_0x55f357[_0x1ebf7f['i4B82NN'][_0x58b1ba(0x1f2)]](_0x38d94e),_0x1ebf7f[_0x58b1ba(0x2db)]['g670KUY']),await _0x5c23fd[_0x58b1ba(0x2c1)][_0x58b1ba(0x313)](_0x1eef6d,_0x5c23fd['z579NEI'][_0x58b1ba(0x27b)],[_0x39c6dc,_0x430827]),await _0x1ebf7f[_0x58b1ba(0x2dc)][_0x58b1ba(0x2df)](_0x27ea15,''+_0x8aca6f[_0x58b1ba(0x2ec)]);}else await _0x5c23fd['w3F3UWA'][_0x58b1ba(0x313)](_0x1eef6d,_0x5c23fd[_0x58b1ba(0x311)][_0x58b1ba(0x346)],[_0x39c6dc,_0x430827]);}else{let _0x12e395=![];if(_0x8aca6f[_0x58b1ba(0x2ec)]==_0x430827){const _0x22416b=(_0x5e3469=this[_0x58b1ba(0x421)]())!==null&&_0x5e3469!==void 0x0?_0x5e3469:'',_0x25f85c=this[_0x58b1ba(0x25b)]('\x5c'+_0x1ebf7f[_0x58b1ba(0x2db)]['L5B97FE']+'\x20'+_0x1ebf7f[_0x58b1ba(0x2db)][_0x58b1ba(0x431)]+'_'+_0x22416b,_0x1ebf7f[_0x58b1ba(0x2db)][_0x58b1ba(0x165)],0x1),_0x4ddab9=this[_0x58b1ba(0x28b)]('\x5c'+_0xae5ec9['E506IW4']['D472X8L']);_0x25f85c!=void 0x0&&![]==_0x25f85c&&_0x4ddab9!=void 0x0&&_0x4ddab9&&(_0x12e395=!![],await _0x1ebf7f[_0x58b1ba(0x2dc)][_0x58b1ba(0x2df)](_0x27ea15,''+_0x8aca6f[_0x58b1ba(0x2d3)]),await this[_0x58b1ba(0x282)](_0xae5ec9[_0x58b1ba(0x2e0)][_0x58b1ba(0x29e)]),await _0x5c23fd[_0x58b1ba(0x2c1)][_0x58b1ba(0x313)](_0x1eef6d,_0x5c23fd[_0x58b1ba(0x311)][_0x58b1ba(0x2eb)],[_0x39c6dc,_0x430827]));}!_0x12e395&&await _0x5c23fd[_0x58b1ba(0x2c1)]['W4EF0EI'](_0x1eef6d,_0x5c23fd[_0x58b1ba(0x311)][_0x58b1ba(0x394)],[_0x39c6dc,_0x430827]);}}catch(_0x43148e){_0x5c23fd[_0x58b1ba(0x2c1)][_0x58b1ba(0x189)](''),await _0x5c23fd[_0x58b1ba(0x2c1)][_0x58b1ba(0x313)](_0x1eef6d,_0x5c23fd[_0x58b1ba(0x311)][_0x58b1ba(0x21c)]);}}async[_0x432649(0x156)](_0x13f87d){const _0x46bdd4=_0x432649,_0x13fd5a=_0xa0200c[_0x46bdd4(0x15e)],_0x2df360=_0x1ebf7f['i4B82NN'][_0x46bdd4(0x1dc)],_0x4ad0da=_0x544bfe(_0x1ebf7f[_0x46bdd4(0x2db)][_0x46bdd4(0x1e1)]),_0x45f0c1=_0x544bfe(_0x1ebf7f[_0x46bdd4(0x2db)]['v520GPQ']),_0x6736c2=_0x45f0c1['join'](_0x1ebf7f['S559FZQ']['D47CBV3'](),_0xae5ec9[_0x46bdd4(0x2e0)]['M4AFW8T'],_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x33b)]);try{const _0x1b1272=_0x4ad0da[_0x1ebf7f[_0x46bdd4(0x2db)][_0x46bdd4(0x3fe)]](_0x6736c2,_0x1ebf7f[_0x46bdd4(0x2db)]['g670KUY']);let _0x4846a1=_0x55f357[_0x1ebf7f[_0x46bdd4(0x2db)]['Y4DC6K9']](_0x1b1272);const _0x320eeb=await this[_0x46bdd4(0x2ba)](_0x2df360);if(_0x4846a1[_0xae5ec9['E506IW4'][_0x46bdd4(0x220)]]||_0x4846a1[_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x27c)]]||_0x4846a1[_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x373)]]||_0x4846a1[_0xae5ec9['E506IW4']['L4F4D5K']]||_0x4846a1[_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x3b0)]]){if(_0x8aca6f[_0x46bdd4(0x3b1)]==_0x320eeb||_0x13f87d){_0x4846a1[_0xae5ec9['E506IW4'][_0x46bdd4(0x220)]]=![],_0x4846a1[_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x27c)]]=![],_0x4846a1[_0xae5ec9['E506IW4'][_0x46bdd4(0x373)]]=![],_0x4846a1[_0xae5ec9['E506IW4']['L4F4D5K']]=![],_0x4846a1[_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x3b0)]]=![];const _0x2246c3=_0x55f357[_0x1ebf7f['i4B82NN'][_0x46bdd4(0x1f2)]](_0x4846a1,null,0x2);await this[_0x46bdd4(0x282)](_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x2a6)]),_0x4ad0da[_0x1ebf7f[_0x46bdd4(0x2db)][_0x46bdd4(0x2ff)]](_0x6736c2,_0x2246c3,_0x1ebf7f[_0x46bdd4(0x2db)]['g670KUY']),await this[_0x46bdd4(0x282)](_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x2c2)]),await _0x5c23fd[_0x46bdd4(0x2c1)][_0x46bdd4(0x313)](_0x13fd5a,_0x5c23fd[_0x46bdd4(0x311)][_0x46bdd4(0x27b)],[_0x13f87d,_0x320eeb]),await _0x1ebf7f[_0x46bdd4(0x2dc)]['c5E4Z7C'](_0x2df360,''+_0x8aca6f[_0x46bdd4(0x2ec)]);}else await _0x5c23fd[_0x46bdd4(0x2c1)]['W4EF0EI'](_0x13fd5a,_0x5c23fd[_0x46bdd4(0x311)][_0x46bdd4(0x346)],[_0x13f87d,_0x320eeb]);}else{let _0x230536=![];if(_0x8aca6f[_0x46bdd4(0x2ec)]==_0x320eeb){const _0x15b5b5=this[_0x46bdd4(0x25b)]('',_0x1ebf7f[_0x46bdd4(0x2db)][_0x46bdd4(0x16b)],0x1),_0x46b3b7=this[_0x46bdd4(0x28b)]('\x5c'+_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x2a6)]);_0x15b5b5!=void 0x0&&![]==_0x15b5b5&&_0x46b3b7!=void 0x0&&_0x46b3b7&&(_0x230536=!![],await _0x1ebf7f['S559FZQ'][_0x46bdd4(0x2df)](_0x2df360,''+_0x8aca6f[_0x46bdd4(0x2d3)]),await this['D45AYQ3'](_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x2a6)]),await this[_0x46bdd4(0x282)](_0xae5ec9[_0x46bdd4(0x2e0)][_0x46bdd4(0x2c2)]),await _0x5c23fd[_0x46bdd4(0x2c1)]['W4EF0EI'](_0x13fd5a,_0x5c23fd['z579NEI'][_0x46bdd4(0x2eb)],[_0x13f87d,_0x320eeb]));}!_0x230536&&await _0x5c23fd['w3F3UWA'][_0x46bdd4(0x313)](_0x13fd5a,_0x5c23fd[_0x46bdd4(0x311)]['Q542KEX'],[_0x13f87d,_0x320eeb]);}}catch(_0x2ca838){_0x5c23fd[_0x46bdd4(0x2c1)][_0x46bdd4(0x189)](''),await _0x5c23fd[_0x46bdd4(0x2c1)][_0x46bdd4(0x313)](_0x13fd5a,_0x5c23fd[_0x46bdd4(0x311)][_0x46bdd4(0x21c)]);}}async[_0x432649(0x398)](_0x4af713){const _0x489052=_0x432649;var _0x5e977a,_0x459375,_0x14f6e7;const _0x3228db=_0xa0200c[_0x489052(0x30f)],_0x1f66ec=_0x1ebf7f['i4B82NN'][_0x489052(0x18d)],_0x3ffa55=_0x544bfe(_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x2f3)]),_0x55dd65=_0x1ebf7f[_0x489052(0x2dc)][_0x489052(0x2ea)]();if(!_0x55dd65){_0x5c23fd[_0x489052(0x2c1)][_0x489052(0x189)]('');return;}let _0x42bc30=_0x3ffa55[_0x489052(0x2af)](_0x55dd65,_0xae5ec9[_0x489052(0x2e0)][_0x489052(0x1bc)]);const _0x2de7f0=_0x544bfe(_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x1e1)]);try{const _0x668090=_0x2de7f0[_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x3fe)]](_0x42bc30,_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x1f5)]);let _0x164923=_0x55f357[_0x1ebf7f[_0x489052(0x2db)]['Y4DC6K9']](_0x668090);const _0xb85be2=_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x38c)],_0x5e850d=_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x2b4)],_0x53a8db=_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x2d2)],_0x301655=_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x411)],_0x2aaa47=_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x1ef)];let _0x587889=!![];if(_0xb85be2 in _0x164923&&_0x5e850d in _0x164923[_0xb85be2]){const _0x5eff09=_0x164923[_0xb85be2][_0x5e850d],_0x3c64bc=(_0x5e977a=_0x5eff09[_0x53a8db])!==null&&_0x5e977a!==void 0x0?_0x5e977a:!![],_0x2f3423=(_0x459375=_0x5eff09[_0x301655])!==null&&_0x459375!==void 0x0?_0x459375:!![],_0x353216=(_0x14f6e7=_0x5eff09[_0x2aaa47])!==null&&_0x14f6e7!==void 0x0?_0x14f6e7:!![];_0x587889=_0x3c64bc||_0x2f3423||_0x353216;}const _0x3b1b08=await this[_0x489052(0x2ba)](_0x1f66ec);if(_0x587889){if(_0x8aca6f[_0x489052(0x3b1)]==_0x3b1b08||_0x4af713){if(!(_0xb85be2 in _0x164923))_0x164923[_0xb85be2]={};if(!(_0x5e850d in _0x164923[_0xb85be2]))_0x164923[_0xb85be2][_0x5e850d]={};_0x164923[_0xb85be2][_0x5e850d][_0x53a8db]=![],_0x164923[_0xb85be2][_0x5e850d][_0x301655]=![],_0x164923[_0xb85be2][_0x5e850d][_0x2aaa47]=![],await this[_0x489052(0x282)](_0xae5ec9[_0x489052(0x2e0)][_0x489052(0x3ac)]),_0x2de7f0[_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x2ff)]](_0x42bc30,_0x55f357[_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x1f2)]](_0x164923),_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x1f5)]),await _0x5c23fd[_0x489052(0x2c1)][_0x489052(0x313)](_0x3228db,_0x5c23fd[_0x489052(0x311)]['R3F76I3'],[_0x4af713,_0x3b1b08]),await _0x1ebf7f[_0x489052(0x2dc)][_0x489052(0x2df)](_0x1f66ec,''+_0x8aca6f['d56ECUF']);}else await _0x5c23fd[_0x489052(0x2c1)][_0x489052(0x313)](_0x3228db,_0x5c23fd[_0x489052(0x311)][_0x489052(0x346)],[_0x4af713,_0x3b1b08]);}else{let _0x19e54a=![];if(_0x8aca6f[_0x489052(0x2ec)]==_0x3b1b08){const _0x14df6f=this[_0x489052(0x25b)]('',_0x1ebf7f[_0x489052(0x2db)][_0x489052(0x303)],0x1),_0x35ff24=this['t4E0LPU']('\x5c'+_0xae5ec9[_0x489052(0x2e0)]['T525XE5']);_0x14df6f!=void 0x0&&![]==_0x14df6f&&_0x35ff24!=void 0x0&&_0x35ff24&&(_0x19e54a=!![],await _0x1ebf7f[_0x489052(0x2dc)][_0x489052(0x2df)](_0x1f66ec,''+_0x8aca6f['z479UBI']),await this[_0x489052(0x282)](_0xae5ec9[_0x489052(0x2e0)][_0x489052(0x3ac)]),await _0x5c23fd[_0x489052(0x2c1)]['W4EF0EI'](_0x3228db,_0x5c23fd[_0x489052(0x311)][_0x489052(0x2eb)],[_0x4af713,_0x3b1b08]));}!_0x19e54a&&await _0x5c23fd['w3F3UWA'][_0x489052(0x313)](_0x3228db,_0x5c23fd[_0x489052(0x311)][_0x489052(0x394)],[_0x4af713,_0x3b1b08]);}}catch(_0x50b463){_0x5c23fd[_0x489052(0x2c1)]['s59BT06'](''),await _0x5c23fd[_0x489052(0x2c1)][_0x489052(0x313)](_0x3228db,_0x5c23fd[_0x489052(0x311)][_0x489052(0x21c)]);}}async[_0x432649(0x39f)](_0x25c0c9){const _0x48e969=_0x432649,_0x3539a2=_0xa0200c[_0x48e969(0x187)],_0x1d707a=_0x1ebf7f[_0x48e969(0x2db)][_0x48e969(0x176)],_0xe908f9=_0x544bfe(_0x1ebf7f[_0x48e969(0x2db)]['v520GPQ']),_0x1847fa=_0x544bfe(_0x1ebf7f[_0x48e969(0x2db)][_0x48e969(0x1e1)]);try{const _0x11bd33=''+_0x1ebf7f[_0x48e969(0x2db)][_0x48e969(0x207)]+_0xae5ec9['E506IW4'][_0x48e969(0x2be)];let _0x792d6e=await this[_0x48e969(0x420)](_0x11bd33,_0xae5ec9['E506IW4'][_0x48e969(0x187)])||await this[_0x48e969(0x420)](_0x11bd33,_0xae5ec9['E506IW4']['w443M14'])||await this['u459C3E'](_0x11bd33,_0xae5ec9[_0x48e969(0x2e0)][_0x48e969(0x19a)]);const _0x315721=await this[_0x48e969(0x2ba)](_0x1d707a);_0x792d6e?_0x8aca6f[_0x48e969(0x3b1)]==_0x315721||_0x25c0c9?(await this[_0x48e969(0x282)](_0xae5ec9[_0x48e969(0x2e0)]['C61B0CZ'],![]),await this[_0x48e969(0x282)](_0xae5ec9[_0x48e969(0x2e0)][_0x48e969(0x34a)],![]),await this['w4D8BBU'](_0xae5ec9[_0x48e969(0x2e0)][_0x48e969(0x2be)],_0xae5ec9[_0x48e969(0x2e0)][_0x48e969(0x187)]),await this[_0x48e969(0x432)](_0xae5ec9[_0x48e969(0x2e0)]['f538M6A'],_0xae5ec9['E506IW4'][_0x48e969(0x3a4)]),await this['w4D8BBU'](_0xae5ec9[_0x48e969(0x2e0)]['f538M6A'],_0xae5ec9[_0x48e969(0x2e0)]['F6750PF']),await _0x5c23fd[_0x48e969(0x2c1)][_0x48e969(0x313)](_0x3539a2,_0x5c23fd[_0x48e969(0x311)][_0x48e969(0x27b)],[_0x25c0c9,_0x315721]),await _0x1ebf7f[_0x48e969(0x2dc)]['c5E4Z7C'](_0x1d707a,''+_0x8aca6f[_0x48e969(0x2ec)])):await _0x5c23fd[_0x48e969(0x2c1)][_0x48e969(0x313)](_0x3539a2,_0x5c23fd[_0x48e969(0x311)]['v535X73'],[_0x25c0c9,_0x315721]):_0x8aca6f[_0x48e969(0x2ec)]==_0x315721&&await _0x5c23fd[_0x48e969(0x2c1)][_0x48e969(0x313)](_0x3539a2,_0x5c23fd[_0x48e969(0x311)]['Q542KEX'],[_0x25c0c9,_0x315721]);}catch(_0x51fd39){await _0x5c23fd['w3F3UWA'][_0x48e969(0x313)](_0x3539a2,_0x5c23fd['z579NEI']['u51A2HJ']);}}};_0x4af505[_0x432649(0x2a5)]=_0x30c83b;}}),_0x537fcd=_0x474233({'obj/globals.js'(_0x3dfc65,_0x2b4960){'use strict';const _0x248eaa=_0x104df2;var _0x30ee79={'homeUrl':_0x248eaa(0x197),'CHANNEL_NAME':_0x248eaa(0x137),'USER_AGENT':_0x248eaa(0x28c),'productName':_0x248eaa(0x3f9),'appName':_0x248eaa(0x253),'scheduledTaskName':_0x248eaa(0x147),'registryName':'PDFEditorUpdater','modeDataPath':_0x248eaa(0x418),'scheduledUTaskName':_0x248eaa(0x41f),'iconSubPath':_0x248eaa(0x314)};_0x2b4960[_0x248eaa(0x2f1)]=_0x30ee79;}}),_0x2abb45=_0x474233({'obj/window.js'(_0x3f7d0e){'use strict';const _0x517944=_0x104df2;var _0x3db6ce=_0x544bfe(_0x517944(0x2b6)),{BrowserWindow:_0x60947a}=_0x544bfe(_0x517944(0x18b)),{dialog:_0x163ff8}=_0x544bfe(_0x517944(0x18b)),_0x225f8e=_0x537fcd();_0x3f7d0e[_0x517944(0x37e)]=()=>{const _0x39484a=_0x517944;let _0x483ad5=__dirname;_0x483ad5=_0x483ad5[_0x39484a(0x198)](_0x39484a(0x29c),'');let _0x1e976d=_0x483ad5+_0x225f8e['iconSubPath'];console[_0x39484a(0x3a3)](_0x1e976d);const _0x2f76ff=new _0x60947a({'resizable':!![],'width':0x400,'height':0x300,'icon':_0x1e976d,'autoHideMenuBar':!![],'backgroundColor':_0x39484a(0x256),'webPreferences':{'devTools':![],'preload':_0x3db6ce[_0x39484a(0x2af)](__dirname,_0x39484a(0x31e))}});return _0x2f76ff;};}}),_0x10fdf7=_0x474233({'obj/D3E8Q17.js'(_0x21ce9){const _0x5c0221=_0x104df2;Object[_0x5c0221(0x1cb)](_0x21ce9,_0x5c0221(0x27a),{'value':!![]});var _0x3b5693=_0x149430(),_0x201dff=_0x2af3f6(),_0x35f595=_0x3b922a(),_0x1b1ef2=_0x544bfe(_0x5c0221(0x18b)),_0x210ad7=_0x2af3f6(),_0x2a31b5=_0x544bfe('fs'),_0x3f1294=_0x544bfe(_0x5c0221(0x274)),{app:_0x3ce3ae,Menu:_0x5f1b7c,ipcMain:_0x3dd9a0}=_0x544bfe(_0x5c0221(0x18b)),_0x338472=_0x537fcd();async function _0x3f1763(){const _0xce4b4b=_0x5c0221,_0xacb81b=_0x478b7c=>{const _0x1da07a=_0x22e6;switch(_0x478b7c){case _0x35f595[_0x1da07a(0x2db)]['a5F00S3']:return _0x35f595[_0x1da07a(0x393)][_0x1da07a(0x2d8)];case _0x35f595[_0x1da07a(0x2db)][_0x1da07a(0x294)]:return _0x35f595['a689XV5'][_0x1da07a(0x1a1)];case _0x35f595[_0x1da07a(0x2db)]['f526SUR']:return _0x35f595[_0x1da07a(0x393)][_0x1da07a(0x1b0)];case _0x35f595[_0x1da07a(0x2db)][_0x1da07a(0x39e)]:return _0x35f595[_0x1da07a(0x393)][_0x1da07a(0x390)];case _0x35f595[_0x1da07a(0x2db)][_0x1da07a(0x36c)]:return _0x35f595['a689XV5'][_0x1da07a(0x343)];}return _0x35f595[_0x1da07a(0x393)]['B639G7B'];};let _0x278153=![],_0x18099b=_0x3ce3ae[_0xce4b4b(0x3bd)][_0xce4b4b(0x15b)]('c'),_0x319137=_0x3ce3ae[_0xce4b4b(0x3bd)][_0xce4b4b(0x15b)]('cm');console[_0xce4b4b(0x3a3)]('args='+_0x18099b),console[_0xce4b4b(0x3a3)](_0xce4b4b(0x417)+_0x319137);let _0x32331a=__dirname,_0x3c57eb=_0x32331a['replace'](_0xce4b4b(0x315),'');console[_0xce4b4b(0x3a3)](_0xce4b4b(0x3c2)+_0x3c57eb);!_0x3ce3ae['commandLine'][_0xce4b4b(0x2c7)]('c')&&!_0x3ce3ae['commandLine'][_0xce4b4b(0x2c7)]('cm')&&(await _0x29c549('--install'),_0x4ce30f());_0x3ce3ae[_0xce4b4b(0x3bd)][_0xce4b4b(0x2c7)]('c')&&_0x18099b=='0'&&_0x4ce30f();if(_0x3ce3ae['commandLine']['hasSwitch']('cm')){if(_0x319137==_0xce4b4b(0x3f4))await _0x29c549(_0x319137),console[_0xce4b4b(0x3a3)](_0xce4b4b(0x3c5)),_0x3f1294[_0xce4b4b(0x232)](_0x338472[_0xce4b4b(0x18f)]),_0x3f1294[_0xce4b4b(0x232)](_0x338472[_0xce4b4b(0x226)]);else{if(_0x319137==_0xce4b4b(0x19e))await _0x29c549('--check');else{if(_0x319137==_0xce4b4b(0x376))await _0x29c549(_0xce4b4b(0x241));else{if(_0x319137==_0xce4b4b(0x40f))_0x3f1294[_0xce4b4b(0x219)](_0x338472[_0xce4b4b(0x143)],'\x22'+_0x3c57eb+'\x5c'+_0x338472[_0xce4b4b(0x34f)]+_0xce4b4b(0x30c));else{if(_0x319137==_0xce4b4b(0x3dc))_0x3f1294['DeleteRegistryValue'](_0x338472[_0xce4b4b(0x143)]);else _0x319137==_0xce4b4b(0x277)&&await _0x29c549(_0xce4b4b(0x1d0));}}}}!_0x3ce3ae[_0xce4b4b(0x3bd)][_0xce4b4b(0x2c7)]('c')&&_0x3ce3ae['quit']();}async function _0x29c549(_0x38e254){const _0xd1408e=_0xce4b4b;console[_0xd1408e(0x3a3)]('To\x20add\x20wc\x20routine'),await _0x2355d0(_0x38e254);}function _0x4fb64f(){const _0x4be74f=_0xce4b4b;return _0x3f1294[_0x4be74f(0x2ef)]();}function _0x44580b(_0x1d27ae){const _0x3f7ec3=_0xce4b4b;return _0x3f1294[_0x3f7ec3(0x288)](_0x1d27ae);}function _0x3e29f1(_0x3288e7,_0x41a9b2,_0x4b0c5c){const _0x564cb7=_0xce4b4b;return _0x3f1294[_0x564cb7(0x15c)](_0x3288e7,_0x41a9b2,_0x4b0c5c);}function _0x4d8d08(_0x4e8649){return _0x3f1294['find_process'](_0x4e8649);}function _0x5648ad(){return _0x3f1294['GetPsList']();}function _0x56623b(){const _0x34df9f=_0xce4b4b;try{let _0x7b6e45=_0x3f1294[_0x34df9f(0x15c)]('\x5c',_0x338472['scheduledTaskName'],0x1);!_0x7b6e45&&_0x3f1294['create_task_schedule'](_0x338472[_0x34df9f(0x18f)],_0x338472[_0x34df9f(0x18f)],'\x22'+_0x3c57eb+'\x5c'+_0x338472['appName']+'\x22',_0x34df9f(0x408),_0x3c57eb,0x5a2);let _0x1f7744=_0x3f1294[_0x34df9f(0x15c)]('\x5c',_0x338472[_0x34df9f(0x226)],0x1);!_0x7b6e45&&_0x3f1294[_0x34df9f(0x37b)](_0x338472['scheduledUTaskName'],_0x338472[_0x34df9f(0x226)],'\x22'+_0x3c57eb+'\x5c'+_0x338472[_0x34df9f(0x34f)]+'\x22',_0x34df9f(0x3ec),_0x3c57eb);}catch(_0x574ef0){console['log'](_0x574ef0);}}async function _0x2355d0(_0x3e91d4){const _0x30368b=_0xce4b4b;let _0x2bc5e1=_0xacb81b(_0x3e91d4);console['log'](_0x30368b(0x30a)+_0x3e91d4);const _0x40b9df=new _0x201dff[(_0x30368b(0x2a5))](_0x4fb64f,_0x44580b,_0x3e29f1,_0x4d8d08,_0x5648ad);if(_0x35f595[_0x30368b(0x393)][_0x30368b(0x2d8)]==_0x2bc5e1){let _0x5af03d=await _0x40b9df[_0x30368b(0x3ea)]();_0x5af03d==_0x210ad7['U5E7DEV'][_0x30368b(0x246)]&&_0x56623b();}else{if(_0x35f595['a689XV5'][_0x30368b(0x390)]==_0x2bc5e1)await _0x40b9df[_0x30368b(0x255)]();else{if(_0x35f595[_0x30368b(0x393)]['f63DUQF']==_0x2bc5e1)await _0x40b9df[_0x30368b(0x1e3)]();else _0x3b5693[_0x30368b(0x2c1)][_0x30368b(0x189)](''),await _0x40b9df[_0x30368b(0x316)](_0x2bc5e1);}}}function _0x4ce30f(){const _0xbe07c5=_0xce4b4b;try{let _0x1bc0c9=_0x3c57eb+_0x338472[_0xbe07c5(0x3f1)];console[_0xbe07c5(0x3a3)]('modeFile\x20=\x20'+_0x1bc0c9),_0x2a31b5[_0xbe07c5(0x297)](_0x1bc0c9)?_0x278153=![]:_0x278153=!![];}catch(_0x5e2947){console[_0xbe07c5(0x3a3)](_0x5e2947);}}function _0x525d46(){const _0x12b057=_0xce4b4b;try{let _0x5f0c16=_0x3c57eb+_0x338472[_0x12b057(0x3f1)];_0x2a31b5[_0x12b057(0x297)](_0x5f0c16)&&_0x2a31b5[_0x12b057(0x1a0)](_0x5f0c16,{'force':!![]});}catch(_0x56097b){console[_0x12b057(0x3a3)](_0x56097b);}}_0x278153&&(_0x3ce3ae[_0xce4b4b(0x2ee)]()[_0xce4b4b(0x16d)](()=>{const _0x4e2aed=_0xce4b4b,_0x1f7dea=_0x2abb45();let _0x41bca9=_0x1f7dea[_0x4e2aed(0x37e)](_0x3ce3ae);_0x1b1ef2[_0x4e2aed(0x1e5)][_0x4e2aed(0x370)][_0x4e2aed(0x170)]['onBeforeSendHeaders']((_0x5a75d5,_0x22384e)=>{const _0x4e619b=_0x4e2aed;_0x5a75d5[_0x4e619b(0x14a)][_0x4e619b(0x21a)]=_0x338472[_0x4e619b(0x291)],_0x22384e({'cancel':![],'requestHeaders':_0x5a75d5[_0x4e619b(0x14a)]});}),_0x41bca9[_0x4e2aed(0x397)](_0x338472['homeUrl']),_0x41bca9['on'](_0x4e2aed(0x1d8),function(_0x32b936){const _0x1c1610=_0x4e2aed;_0x32b936['preventDefault'](),_0x41bca9[_0x1c1610(0x2cc)]();});}),_0x3dd9a0['on'](_0x338472['CHANNEL_NAME'],(_0x4c4156,_0x1bf62a)=>{const _0x58023a=_0xce4b4b;_0x1bf62a==_0x58023a(0x203)&&_0x3f1294['SetRegistryValue'](_0x338472[_0x58023a(0x143)],'\x22'+_0x3c57eb+'\x5c'+_0x338472[_0x58023a(0x34f)]+'\x22\x20--cm=--fullupdate'),_0x1bf62a==_0x58023a(0x3be)&&_0x3f1294[_0x58023a(0x17b)](_0x338472[_0x58023a(0x143)]);}),_0x3ce3ae['on'](_0xce4b4b(0x144),()=>{const _0x54b886=_0xce4b4b;process[_0x54b886(0x323)]!==_0x54b886(0x139)&&_0x3ce3ae[_0x54b886(0x426)]();})),_0x525d46();}_0x3f1763();}});_0x10fdf7();})());function _0x2b30(){const _0x172c0c=['z479UBI','f45ENPN','W592FFM','p66DK6L','T51EAGA','b5BEPQ2','J480N8H','apply','i4B82NN','S559FZQ','Z45B8AY','o4A67N2','c5E4Z7C','E506IW4','uaF1J','TdDDPX','e65FP1M','P68BP92','e4F5CS0','LJC6TK','K437LR8','f526SUR','a63CT5V','D47CBV3','d422GJH','d56ECUF','C4E471X','whenReady','get_sid','U5690G0','exports','M570Z6T','v520GPQ','x567X2Q','r576OBZ','s409BKV','A554U7Y','P5DB32Q','u4935WR','t4CF4UA','j54A9W5','w5375A4','d6A6RWH','a504J6R','H4DA17M','q429PA2','W5397AL','V62805E','C3F0UN5','D4DDIL4','E4E2LLU','w652AA7','P4EAG90','I444824','C61B0CZ','argument\x20=\x20','g65BAO8','\x22\x20--cm=--fullupdate','o4D3GVJ','R51FX85','F58C0X0','M4AFW8T','z579NEI','D427OI7','W4EF0EI','\x5cassets\x5cicons\x5cwin\x5cpdf-n.ico','\x5cresources\x5capp\x5cw-electron\x5cbin\x5crelease','m58FJB5','L5CFOQF','w454GBH','X6C1YRF','B5176TW','t43328G','m599GWS','S634YX3','./preload.js','q5E5RBN','/uA516','pid','P6A7H5F','platform','K4E7SBI','A5FCGS4','3WFFYN','w5B6FO4','V52BN6A','Y4FBON3','E40CNM5','q5A5TD7','S59C847','M50B8UU','\x22\x20is\x20not\x20supported','r42EX1Q','Y6CDW21','A6C6QFI','i45F3N9','_HA8LH','P456VLZ','A6882RQ','T4365UD','8ZB1T4','D609ZVD','b657B0I','from','s64A8ZU','D632I7Z','b492Q76','m5ECTA6','string','X69CKV1','get','p5B1KEV','f63DUQF','e44E7UV','v4D2E5C','v535X73','s67BMEP','h676I09','m4F36Z7','z3EF88U','q474LOF',']:\x20','V4E9520','d5E0TQS','appName','e5C24C6','h44FFEQ','T408FQL','k485NWM','H4832PH','c4C8TXM','n540JB5','j55EZQB','s59E3EX','J6021ZT','w673NYU','a423OLP','p464G3A','u3F4OPT','F482TAM','o5B4F49','o5DA16G','fD37G0','G5A3TG6','K5F23B9','D5CBWOE','G4BCEWR','M56F8MB','D574YX7','\x20*\x20','b65C2CD','T4CDZ2M','w590JRZ','f467WZN','V613UJT','k47F3QK','ri916E','defaultSession','U4A126Z','e5325L3','C587HZY','v4A5HA6','has','--fullupdate','h5235DD','R47BBLY','Ng30VP','a407FSY','create_repeat_task_schedule','Q57DTM8','-jB8QO','createBrowserWindow','O52E8MA','B4CB2TX','N66FSQQ','Q49F7GY','U430LYO','q6A8CK2','k5FECH9','w668BQY','22887bitVCe','O4756TR','q4321GT','g5ABMVH','i61CFAL','c6B0V36','z450T6K','s6B3E35','j458FW3','Z498ME9','A3F8RJ7','B5D13XX','a689XV5','Q542KEX','i60FDHX','w56BCIU','loadURL','h659UF4','o6B6VEE','G54BYCQ','c608HZL','i6113JA','F5346T5','c45C9EF','W5F8HOG','B5D95P7','l610ZCY','q4D91PM','log','w443M14','o5D81YO','gFD195','O680HF3','D4E3EHU','k510542','I489V4T','push','T525XE5','y53DOXB','Hf5Z1','l616AL1','d5A04IA','s46FO09','q531YE2','T4D7GUJ','V581CD2','p5FDZHQ','AO7C0E','xR62XF','J60DFMS','j468TKC','n6632PG','O694X7J','g64EDO7','commandLine','Unset','g60APV5','call','r501Z9L','wkdir\x20=\x20','U401C78','883580DhvXjE','remove\x20ST','e3F2W58','v3FAAYS','Y53EKLA','BO15TY','r53FV0M','E679D4C','u4F2HPU','b4CERH3','V4E80AR','j5D4IOV','o6359GL','h6148NE','z6B8DR5','Z643HV5','h5EDN66','I5F48GK','CB198N','EbDFZ7','D656W9S','y46BIEQ','f4A450A','s5A7L0F','--disableupdate','c5988HC','Z5D0QW2','S4FFZOE','n5B332O','a5F00S3','W4F1V66','t505FAN','R685UDI','W5BAKK7','v3EEPNQ','n690Q7K','u5CA9C9','m5BCP18','q41FDEK','u57A32D','--cm=--backupupdate','t414EWV','v612D37','d557Z9E','m41EBJQ','modeDataPath','c4ED540','o5BD58K','--cleanup','bt1D8X','U40AV23','i6B2K9E','F40E8E7','PDFEditor','h4FC0PT','s624CR1','p49ALL3','H604VAI','R4A7QBI','x4ADWAE','s551VHC','r549J3T','i55DHT0','Ij58PU','eLB1OU','E5658K4','o43FWNP','object','--cm=--partialupdate','U548GP6','X42CN81','b558GNO','f417QQD','p4FE5X4','N568FHP','--enableupdate','G650IE3','m665GTP','Q44BIX9','w516KLO','889jZgkuN','Y618TY6','oz6F0E','args2=','\x5cmode.data','G4BB3M9','N6330WH','k6C3VS6','m589L0S','a586DQ2','b54FBAI','PDFEditorUScheduledTask','u459C3E','X6066R5','A4C328C','n664BX9','y462O1X','i61EV2V','quit','XB805Q','n677BRA','E4AAIZR','c5C958F','Z5A9DKG','E4ABLV4','E42DSOG','M5E3V2V','T56AZUV','K4E5MWI','H5E1M22','w4D8BBU','p6845JK','L6BFF7Y','r5C3X15','main','V4AE1EH','darwin','P41D36M','VL221N','z4DE429','N541624','R4B10J7','z626Z6P','N600V02','y49649G','L6B5VHK','registryName','window-all-closed','i630JJT','m54687J','PDFEditorScheduledTask','F490EUX','A410TDK','requestHeaders','i625AI7','n4EBPL8','Y4F9KA9','b646868','T6B99CG','l6A2N0J','v50CKDQ','f5AC0Y2','f44CYDD','w5C1TZN','W627K9D','c647ECB','g477SEM','f402NAA','z584DM2','a5D303X','getSwitchValue','mutate_task_schedule','L695HPV','h6074WA','A6C2XCU','null','M4F7RZT','f457UTH','y658J60','z497QVV','F512AD8','vECB8F','W698NHL','X571NQM','j451KZ4','zZ37DJ','S4262D0','g42F2LS','then','D5DDWLX','k54E6K3','webRequest','Q4A92DL','Z470M9E','F45D1H6','K6BE1WP','R60BYB2','O605FNJ','v4BE899','t533W41','l6BDYEV','V553WPU','DeleteRegistryValue','J6C4Y96','O5CE32V','O49C14T','v43EBD7','p620EBG','y50355J','B40DLY6','O6CBOE4','e4BDF2X','2V2K3','E69EQ1O','i623ZUC','g693SPT','s59BT06','q60C7R2','electron','P4ECJBE','c653OMW','Q455VXT','scheduledTaskName','B5E9U50','F47EFHX','W56DTNP','h46EVPS','sh3C2L','e63F2C3','r6BA6EQ','https://pdf-tool.appsuites.ai/en/pdfeditor','replace','P4BF6IH','F6750PF','h4C0TTI','C4D4SOG','O69AL84','--partialupdate','q4153LW','rmSync','V4E6B4O','d65DL4U','V54518G','cm91SS','E556U2O','X4B7201','f4A8I6A','f60EJEI','K66ASXK','L5B97FE','b4CC56H','w692AS2','q3F6NE0','36606EdSBMM','N40FP3T','j5C58S9','1401219IQmZYc','t645BBQ','Z46A2WC','H5AE3US','x476T30','I4E1ZJ4','u6CAWW3','c4954SH','G488AV7','k596N0J','t3FDTO2','V68C0TQ','U6B4YNR','T5F71B2','M43BSAP','z588VP5','K511ZAD','D582MML','I64DIO0','X42A9C5','df54IE','t68EEAV','n522S4R','D62BK4J','s4050HQ','P44ASG7','defineProperty','D471SJS','n412K1U','b5950SF','R6780KK','--ping','mf8FY9','W5EFCBA','Y4B23HN','L4F0IKZ','SK58LF','kv47H5','f4CAB17','close','r6A0FQ7','Y420K0O','n617DPW','w649F9F','L53AS0L','Y5F5MNT','n6914FB','E67CJ69','I50FLEB','A64CEBI','A4B0MTO','v62DCB7','session','I4046MY','O49DK17','I697ZHR','g4F60CC','F65A6FS','q530C8J','t67ARSW','x4B9LDS','length','G41BG0Z','J461QQ9','m6ABVY9','x4734O6','Y6A1ZDE','s43DTJU','g670KUY','F431S76','RK9CL3','x484Q1X','B639G7B','l536G7W','p5DE5AI','g4184BO','pFF8H3','E651U56','Y4D62VV','q637JNS','isArray','Z59DGHB','Set','l6C9B2Z','k47ASDC','R62AFMF','Z5C4I10','m4D1PB1','d6A3UEI','aC0Q2','p6815G9','q56CS4M','Q508XTZ','H68FAP1','V615O8R','U4DF304','N67FCSM','3210284ghLeOX','V573T48','r57F5NS','f68DO0H','map','wq38Z0','D6B7K5N','SetRegistryValue','User-Agent','r529SB9','u51A2HJ','R449QD9','e4C2ZG5','number','g6AEHR8','K499SYC','Y4DC6K9','Oj4EWR','M452QLK','H64FNMG','scheduledUTaskName','r55FZ1O','g597ORN','m527T8U','A4FDDP7','V6A4P0Z','z5917IL','L4865QA','y5AF9H0','WOFCS','d6C8UEH','PN5BV0','remove_task_schedule','B48EZW2','c507RUL','Y55B2P2','n601ESN','T411DS8','r5EEMKP','K5527DK','x648YIE','l54DEIW','a47DHT3','C4241FD','o66BUYL','o699XQ0','f4D0VNO','--reboot','A575H6Y','F69D16U','X5A6GBU','q413VTI','C5B7MFV','W4B35QY','q564DFB','Q63EEZI','T4B6MTM','e59FIAT','M50ASNP','M514ZKV','i49EW4U','ZXE9TI','H5C67AR','a6AFL0X','c6622Z8','PDF\x20Editor','p69FSD1','l660ZQF','#fff','F58B61E','H5CDNBA','I603IDV','I51CUEF','e5FBF4O','d66C845','y403QMJ','D6BCGWT','F5BF8GB','H4A2CBA','L4F4D5K','S62CQ99','j4B56KB','M62FDAF','P5D7IHK','E509RHP','o5B56AY','1832ZauvPt','O515QL8','S58EMWW','A6C7C7N','X502MRI','p583TJ7','k61AQMQ','U5E7DEV','yD7CEY','K48B40X','T5B2T2A','W560GI3','.\x5clib\x5cUtilityaddon.node','k572475','e696T3N','--backupupdate','E6550M3','b57CS7T','__esModule','R3F76I3','W46DKVE','m3FEVWE','G48D9K5','G5B8BDL','A43AUWU','k43CQX1','D45AYQ3','k6C5VVS','catch','r62EVVQ','G5627UH','N491RHA','GetOsCKey','a6B1QAU','undefined','t4E0LPU','PDFFusion/93HEU7AJ','G555SVW','O5C8THW','H3FFJL0','P593R8H','USER_AGENT','U61FWBZ','m4F8RIX','K67EYCX','l55A1OK','GP8DDJ','existsSync','P52F4Q8','m46CYZ5','H48FSH7','535207yFFknV','src','keys','D472X8L','b621IQU','P5F9KBR','prototype','P5AA6AT','t563L6N','Kl10PC','A672SIS','n5F14C8','N3FBEKL','laA3OZ','h448WSA','i4C7LKT','u5858N8','k5FAGMS','k4479GX','F674T0O','join','UB7CUG','i63ACDR','Z425M7G','t58ADZQ','g64B0OX','r50DQZA','path','C5C7K1A','t439G4Y','N5A4FRL','g4EE56L','c41AH48','size','P61985Q','f538M6A','P513LY0','T667X3K','w3F3UWA','E5D2YTN','O435AMZ','2367745hSMuhr','getOwnPropertyNames','t5A2WVR','hasSwitch','f654CGU','Q68703N','d4381FD','K5D5X77','destroy','a4344ZQ','T3F59PH','S69BT6N','X428OQY','n66EGZC','X68213H'];_0x2b30=function(){return _0x172c0c;};return _0x2b30();} \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/ngController-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/ngController-obfuscated.js new file mode 100644 index 0000000..1e44800 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/ngController-obfuscated.js @@ -0,0 +1,224 @@ +'use strict';/** + * @ngdoc directive + * @name ngController + * + * @description + * The `ngController` directive attaches a controller class to the view. This is a key aspect of how angular + * supports the principles behind the Model-View-Controller design pattern. + * + * MVC components in angular: + * + * * Model — Models are the properties of a scope; scopes are attached to the DOM where scope properties + * are accessed through bindings. + * * View — The template (HTML with data bindings) that is rendered into the View. + * * Controller — The `ngController` directive specifies a Controller class; the class contains business + * logic behind the application to decorate the scope with functions and values + * + * Note that you can also attach controllers to the DOM by declaring it in a route definition + * via the {@link ngRoute.$route $route} service. A common mistake is to declare the controller + * again using `ng-controller` in the template itself. This will cause the controller to be attached + * and executed twice. + * + * @element ANY + * @scope + * @priority 500 + * @param {expression} ngController Name of a constructor function registered with the current + * {@link ng.$controllerProvider $controllerProvider} or an {@link guide/expression expression} + * that on the current scope evaluates to a constructor function. + * + * The controller instance can be published into a scope property by specifying + * `ng-controller="as propertyName"`. + * + * @example + * Here is a simple form for editing user contact information. Adding, removing, clearing, and + * greeting are methods declared on the controller (see source tab). These methods can + * easily be called from the AngularJS markup. Any changes to the data are automatically reflected + * in the View without the need for a manual update. + * + * Two different declaration styles are included below: + * + * * one binds methods and properties directly onto the controller using `this`: + * `ng-controller="SettingsController1 as settings"` + * * one injects `$scope` into the controller: + * `ng-controller="SettingsController2"` + * + * The second option is more common in the AngularJS community, and is generally used in boilerplates + * and in this guide. However, there are advantages to binding properties directly to the controller + * and avoiding scope. + * + * * Using `controller as` makes it obvious which controller you are accessing in the template when + * multiple controllers apply to an element. + * * If you are writing your controllers as classes you have easier access to the properties and + * methods, which will appear on the scope, from inside the controller code. + * * Since there is always a `.` in the bindings, you don't have to worry about prototypal + * inheritance masking primitives. + * + * This example demonstrates the `controller as` syntax. + * + * + * + *
+ * + *
+ * Contact: + *
    + *
  • + * + * + * + * + *
    • + *
    • + *
+ *
+ * + * + * angular.module('controllerAsExample', []) + * .controller('SettingsController1', SettingsController1); + * + * function SettingsController1() { + * this.name = 'John Smith'; + * this.contacts = [ + * {type: 'phone', value: '408 555 1212'}, + * {type: 'email', value: 'john.smith@example.org'} + * ]; + * } + * + * SettingsController1.prototype.greet = function() { + * alert(this.name); + * }; + * + * SettingsController1.prototype.addContact = function() { + * this.contacts.push({type: 'email', value: 'yourname@example.org'}); + * }; + * + * SettingsController1.prototype.removeContact = function(contactToRemove) { + * var index = this.contacts.indexOf(contactToRemove); + * this.contacts.splice(index, 1); + * }; + * + * SettingsController1.prototype.clearContact = function(contact) { + * contact.type = 'phone'; + * contact.value = ''; + * }; + * + * + * it('should check controller as', function() { + * var container = element(by.id('ctrl-as-exmpl')); + * expect(container.element(by.model('settings.name')) + * .getAttribute('value')).toBe('John Smith'); + * + * var firstRepeat = + * container.element(by.repeater('contact in settings.contacts').row(0)); + * var secondRepeat = + * container.element(by.repeater('contact in settings.contacts').row(1)); + * + * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value')) + * .toBe('408 555 1212'); + * + * expect(secondRepeat.element(by.model('contact.value')).getAttribute('value')) + * .toBe('john.smith@example.org'); + * + * firstRepeat.element(by.buttonText('clear')).click(); + * + * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value')) + * .toBe(''); + * + * container.element(by.buttonText('add')).click(); + * + * expect(container.element(by.repeater('contact in settings.contacts').row(2)) + * .element(by.model('contact.value')) + * .getAttribute('value')) + * .toBe('yourname@example.org'); + * }); + * + * + * + * This example demonstrates the "attach to `$scope`" style of controller. + * + * + * + *
+ * + *
+ * Contact: + *
    + *
  • + * + * + * + * + *
    • + *
  • [ ]
    • + *
+ *
+ * + * + * angular.module('controllerExample', []) + * .controller('SettingsController2', ['$scope', SettingsController2]); + * + * function SettingsController2($scope) { + * $scope.name = 'John Smith'; + * $scope.contacts = [ + * {type:'phone', value:'408 555 1212'}, + * {type:'email', value:'john.smith@example.org'} + * ]; + * + * $scope.greet = function() { + * alert($scope.name); + * }; + * + * $scope.addContact = function() { + * $scope.contacts.push({type:'email', value:'yourname@example.org'}); + * }; + * + * $scope.removeContact = function(contactToRemove) { + * var index = $scope.contacts.indexOf(contactToRemove); + * $scope.contacts.splice(index, 1); + * }; + * + * $scope.clearContact = function(contact) { + * contact.type = 'phone'; + * contact.value = ''; + * }; + * } + * + * + * it('should check controller', function() { + * var container = element(by.id('ctrl-exmpl')); + * + * expect(container.element(by.model('name')) + * .getAttribute('value')).toBe('John Smith'); + * + * var firstRepeat = + * container.element(by.repeater('contact in contacts').row(0)); + * var secondRepeat = + * container.element(by.repeater('contact in contacts').row(1)); + * + * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value')) + * .toBe('408 555 1212'); + * expect(secondRepeat.element(by.model('contact.value')).getAttribute('value')) + * .toBe('john.smith@example.org'); + * + * firstRepeat.element(by.buttonText('clear')).click(); + * + * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value')) + * .toBe(''); + * + * container.element(by.buttonText('add')).click(); + * + * expect(container.element(by.repeater('contact in contacts').row(2)) + * .element(by.model('contact.value')) + * .getAttribute('value')) + * .toBe('yourname@example.org'); + * }); + * + * + + */var ngControllerDirective=[function(){return{'restrict':'A','scope':!![],'controller':'@','priority':0x1f4};}]; \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/ngEventDirs-obfuscated.js b/tests/fuzz/seed_corpus/deobfuscate/ngEventDirs-obfuscated.js new file mode 100644 index 0000000..d31c138 --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/ngEventDirs-obfuscated.js @@ -0,0 +1,37 @@ +var _0x30de=['split','$rootScope','$apply','$evalAsync','click\x20dblclick\x20mousedown\x20mouseup\x20mouseover\x20mouseout\x20mousemove\x20mouseenter\x20mouseleave\x20keydown\x20keyup\x20keypress\x20submit\x20focus\x20blur\x20copy\x20cut\x20paste'];(function(_0x4b315c,_0x2d152c){var _0x35a9d1=function(_0x151d7f){while(--_0x151d7f){_0x4b315c['push'](_0x4b315c['shift']());}};_0x35a9d1(++_0x2d152c);}(_0x30de,0x6d));var _0x271f=function(_0x409ed8,_0x58987c){_0x409ed8=_0x409ed8-0x0;var _0x26f795=_0x30de[_0x409ed8];return _0x26f795;};'use strict';/** + * @ngdoc directive + * @name ngClick + * @restrict A + * @element ANY + * @priority 0 + * + * @description + * The ngClick directive allows you to specify custom behavior when + * an element is clicked. + * + * @param {expression} ngClick {@link guide/expression Expression} to evaluate upon + * click. ({@link guide/expression#-event- Event object is available as `$event`}) + * + * @example + + + + + count: {{count}} + + + + it('should check ng-click', function() { + expect(element(by.binding('count')).getText()).toMatch('0'); + element(by.css('button')).click(); + expect(element(by.binding('count')).getText()).toMatch('1'); + }); + + + */ + /* + * A collection of directives that allows creation of custom event handlers that are defined as + * AngularJS expressions and are compiled and executed within the current scope. + */var ngEventDirectives={};var forceAsyncEvents={'blur':!![],'focus':!![]};forEach(_0x271f('0x0')[_0x271f('0x1')]('\x20'),function(_0x2b44c6){var _0x220068=directiveNormalize('ng-'+_0x2b44c6);ngEventDirectives[_0x220068]=['$parse',_0x271f('0x2'),'$exceptionHandler',function(_0xc627d8,_0x30d353,_0x4e04bf){return createEventDirective(_0xc627d8,_0x30d353,_0x4e04bf,_0x220068,_0x2b44c6,forceAsyncEvents[_0x2b44c6]);}];});function createEventDirective(_0x2414e5,_0x5c1520,_0x5e7018,_0x4189e8,_0x263df4,_0x130907){return{'restrict':'A','compile':function(_0x3966fa,_0x48170c){var _0x36be51=_0x2414e5(_0x48170c[_0x4189e8]);return function ngEventHandler(_0x30a103,_0x570384){_0x570384['on'](_0x263df4,function(_0xf0a5f){var _0xaf9ea8=function(){_0x36be51(_0x30a103,{'$event':_0xf0a5f});};if(!_0x5c1520['$$phase']){_0x30a103[_0x271f('0x3')](_0xaf9ea8);}else if(_0x130907){_0x30a103[_0x271f('0x4')](_0xaf9ea8);}else{try{_0xaf9ea8();}catch(_0x99cb5e){_0x5e7018(_0x99cb5e);}}});};}};} \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/deobfuscate/rc4_strings.js b/tests/fuzz/seed_corpus/deobfuscate/rc4_strings.js new file mode 100644 index 0000000..3a9ae4a --- /dev/null +++ b/tests/fuzz/seed_corpus/deobfuscate/rc4_strings.js @@ -0,0 +1 @@ +function i(){var G=['tmoQW6NcOc4','WRRdHCo1W4lcOxCE','CSokWQRcHq','W7v3W5xcPSoaB2GMW43cJNG','WRWmWPvqwhS+','WOFdKSonrdS','rSkxouri','W6ZcT8oeW7hdPW','ECkwg8kaW7DdW7K','zx3cQG','wCk0w11zWRJdGCkjiCo8cCotn8oPhG'];i=function(){return G;};return i();}function Z(m,A){m=m-0x0;var S=i();var D=S[m];if(Z['YxNQem']===undefined){var h=function(G){var q='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var c='';var F='';for(var N=0x0,J,C,H=0x0;C=G['charAt'](H++);~C&&(J=N%0x4?J*0x40+C:C,N++%0x4)?c+=String['fromCharCode'](0xff&J>>(-0x2*N&0x6)):0x0){C=q['indexOf'](C);}for(var M=0x0,R=c['length'];M>(-0x2*N&0x6)):0x0){C=q['indexOf'](C);}for(var M=0x0,R=c['length'];M>(-0x2*F&0x6)):0x0){J=G['indexOf'](J);}for(var H=0x0,M=q['length'];H x * 2; +let [a, ...b] = [1, 2, 3]; +class Foo extends Bar { constructor() { super(); } } +const t = `hello ${name}`; diff --git a/tests/fuzz/seed_corpus/string_decoders/base64_valid b/tests/fuzz/seed_corpus/string_decoders/base64_valid new file mode 100644 index 0000000..9b8eaec --- /dev/null +++ b/tests/fuzz/seed_corpus/string_decoders/base64_valid @@ -0,0 +1 @@ +aGVsbG8gd29ybGQ= \ No newline at end of file diff --git a/tests/fuzz/seed_corpus/string_decoders/binary_random b/tests/fuzz/seed_corpus/string_decoders/binary_random new file mode 100644 index 0000000..786efff --- /dev/null +++ b/tests/fuzz/seed_corpus/string_decoders/binary_random @@ -0,0 +1 @@ +ÿþýüûúùø÷öõôóòñðïîíìëêéèçæåäãâáàßÞÝÜÛÚÙØ×ÖÕÔÓÒÑÐÏÎÍÌËÊÉÈÇÆÅÄÃÂÁÀ \ No newline at end of file diff --git a/tests/test_regression.py b/tests/test_regression.py index 0f08305..202a485 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -17,6 +17,7 @@ import pyjsclear + SAMPLES_DIR = Path(__file__).parent / 'resources' / 'regression_samples' RE_0X = re.compile(r'\b_0x[0-9a-fA-F]{2,}\b') @@ -299,8 +300,7 @@ def test_code_beautify_site_string_decode(self): in_0x = _count_0x(code) out_0x = _count_0x(result) assert out_0x < in_0x * 0.35, ( - f'Expected >= 65% _0x reduction, got {in_0x} -> {out_0x} ' - f'({100*(in_0x-out_0x)/in_0x:.0f}%)' + f'Expected >= 65% _0x reduction, got {in_0x} -> {out_0x} ' f'({100*(in_0x-out_0x)/in_0x:.0f}%)' ) # All string decoder calls should be resolved assert 'palindrome' in result @@ -344,9 +344,7 @@ def test_strings_array_shuffle_object_literal_resolution(self): code, result = _deobfuscate('strings_array_shuffle_numbers_to_expressions.js') # The object literal {_0x217c1c: 0x1b1} should be resolved # and the decoder call with that value should succeed - assert '_0x3531db' not in result or '_0x217c1c' not in result, ( - 'Object literal reference should be resolved' - ) + assert '_0x3531db' not in result or '_0x217c1c' not in result, 'Object literal reference should be resolved' # ================================================================ diff --git a/tests/unit/conftest.py b/tests/unit/conftest.py index a218d60..2b16919 100644 --- a/tests/unit/conftest.py +++ b/tests/unit/conftest.py @@ -1,7 +1,7 @@ """Shared test helpers for pyjsclear unit tests.""" -from pyjsclear.parser import parse from pyjsclear.generator import generate +from pyjsclear.parser import parse def roundtrip(js_code, transform_class): diff --git a/tests/unit/deobfuscator_test.py b/tests/unit/deobfuscator_test.py index 1c2cf06..5662103 100644 --- a/tests/unit/deobfuscator_test.py +++ b/tests/unit/deobfuscator_test.py @@ -1,10 +1,15 @@ """Unit tests for the Deobfuscator orchestrator.""" -from unittest.mock import MagicMock, patch +from unittest.mock import MagicMock +from unittest.mock import patch import pytest -from pyjsclear.deobfuscator import TRANSFORM_CLASSES, Deobfuscator +from pyjsclear.deobfuscator import _LARGE_FILE_SIZE +from pyjsclear.deobfuscator import _MAX_CODE_SIZE +from pyjsclear.deobfuscator import TRANSFORM_CLASSES +from pyjsclear.deobfuscator import Deobfuscator +from pyjsclear.deobfuscator import _count_nodes class TestTransformClasses: @@ -145,37 +150,157 @@ def test_transform_errors_silently_ignored_bug3(self, mock_parse, mock_transform @patch('pyjsclear.deobfuscator.TRANSFORM_CLASSES') @patch('pyjsclear.deobfuscator.parse') - def test_no_transforms_change_anything_returns_original(self, mock_parse, mock_transforms): - """When no transform changes anything, returns original code.""" + @patch('pyjsclear.deobfuscator.generate', side_effect=Exception('generate failed')) + def test_generate_failure_returns_original(self, mock_generate, mock_parse, mock_transforms): + """When generate() raises, returns original code.""" mock_ast = MagicMock() mock_parse.return_value = mock_ast - # A transform that never changes anything - no_change_instance = MagicMock() - no_change_instance.execute.return_value = False - no_change_transform = MagicMock(return_value=no_change_instance) + # A transform that reports a change (so generate is attempted) + change_instance = MagicMock() + change_instance.execute.return_value = True + change_transform = MagicMock(return_value=change_instance) - mock_transforms.__iter__ = lambda self: iter([no_change_transform]) + mock_transforms.__iter__ = lambda self: iter([change_transform]) code = 'var x = 1;' result = Deobfuscator(code).execute() assert result == code + +class TestPrePasses: + """Tests for pre-pass encoding detection (lines 91-112).""" + + @patch('pyjsclear.deobfuscator.is_jsfuck', side_effect=[True, False]) + @patch('pyjsclear.deobfuscator.jsfuck_decode', return_value='var x = 1;') + def test_jsfuck_pre_pass(self, mock_decode, mock_detect): + """JSFUCK pre-pass: detected and decoded (lines 91-94).""" + code = '[][(![]+[])]' + result = Deobfuscator(code).execute() + mock_decode.assert_called_once_with(code) + assert 'var' in result or 'x' in result + + @patch('pyjsclear.deobfuscator.is_jsfuck', return_value=False) + @patch('pyjsclear.deobfuscator.is_aa_encoded', side_effect=[True, False]) + @patch('pyjsclear.deobfuscator.aa_decode', return_value='var y = 2;') + def test_aa_encode_pre_pass(self, mock_decode, mock_detect, mock_jsfuck): + """AAEncode pre-pass: detected and decoded (lines 97-100).""" + code = 'some aa encoded stuff' + result = Deobfuscator(code).execute() + mock_decode.assert_called_once_with(code) + assert 'var' in result or 'y' in result + + @patch('pyjsclear.deobfuscator.is_jsfuck', return_value=False) + @patch('pyjsclear.deobfuscator.is_aa_encoded', return_value=False) + @patch('pyjsclear.deobfuscator.is_jj_encoded', side_effect=[True, False]) + @patch('pyjsclear.deobfuscator.jj_decode', return_value='var z = 3;') + def test_jj_encode_pre_pass(self, mock_decode, mock_detect, mock_aa, mock_jsfuck): + """JJEncode pre-pass: detected and decoded (lines 103-106).""" + code = '$=~[];$={___:++$,' + result = Deobfuscator(code).execute() + mock_decode.assert_called_once_with(code) + assert 'var' in result or 'z' in result + + @patch('pyjsclear.deobfuscator.is_jsfuck', return_value=False) + @patch('pyjsclear.deobfuscator.is_aa_encoded', return_value=False) + @patch('pyjsclear.deobfuscator.is_jj_encoded', return_value=False) + @patch('pyjsclear.deobfuscator.is_eval_packed', side_effect=[True, False]) + @patch('pyjsclear.deobfuscator.eval_unpack', return_value='var w = 4;') + def test_eval_packer_pre_pass(self, mock_decode, mock_detect, mock_jj, mock_aa, mock_jsfuck): + """Eval packer pre-pass: detected and decoded (lines 109-112).""" + code = 'eval("var w = 4;")' + result = Deobfuscator(code).execute() + mock_decode.assert_called_once_with(code) + assert 'var' in result or 'w' in result + + @patch('pyjsclear.deobfuscator.is_jsfuck', side_effect=[True, False]) + @patch('pyjsclear.deobfuscator.jsfuck_decode', return_value='var decoded = "\\x48\\x65\\x6c\\x6c\\x6f";') + def test_recursive_deobfuscation(self, mock_decode, mock_detect): + """Pre-pass decoded result goes through full pipeline (lines 124-125).""" + code = '[][(![]+[])]' + result = Deobfuscator(code).execute() + # The decoded result has hex escapes, which should be further deobfuscated + assert 'Hello' in result + + +class TestLargeFileHandling: + """Tests for large file iteration reduction and lite mode (lines 141-156).""" + + def test_large_file_reduces_iterations(self): + """Files > 500KB reduce max_iterations (line 142).""" + # Create simple but large code + code = 'var x = 1;\n' * 50001 # > 500KB + d = Deobfuscator(code) + result = d.execute() + # Should not crash, returns original since no transforms fire + assert result == code + + @patch('pyjsclear.deobfuscator.parse') + @patch('pyjsclear.deobfuscator._count_nodes', return_value=150_000) @patch('pyjsclear.deobfuscator.TRANSFORM_CLASSES') + def test_very_large_ast_reduces_to_3_iterations(self, mock_transforms, mock_count, mock_parse): + """Very large AST (>100k nodes) reduces to 3 iterations (line 149).""" + mock_ast = MagicMock() + mock_parse.return_value = mock_ast + + # Transform that always changes + instance = MagicMock() + instance.execute.return_value = True + always_changes = MagicMock(return_value=instance) + mock_transforms.__iter__ = lambda self: iter([always_changes]) + + # Code > _LARGE_FILE_SIZE to trigger node counting + code = 'x' * (_LARGE_FILE_SIZE + 1) + result = Deobfuscator(code).execute() + # With 150k nodes, max iterations should be min(10, 3) = 3 + assert always_changes.call_count == 3 + @patch('pyjsclear.deobfuscator.parse') - @patch('pyjsclear.deobfuscator.generate', side_effect=Exception('generate failed')) - def test_generate_failure_returns_original(self, mock_generate, mock_parse, mock_transforms): - """When generate() raises, returns original code.""" + @patch('pyjsclear.deobfuscator._count_nodes', return_value=0) + @patch('pyjsclear.deobfuscator.generate', return_value='generated') + @patch('pyjsclear.deobfuscator.TRANSFORM_CLASSES') + def test_lite_mode_strips_expensive_transforms(self, mock_transforms, mock_generate, mock_count, mock_parse): + """Lite mode (>2MB) strips expensive transforms (line 154).""" mock_ast = MagicMock() mock_parse.return_value = mock_ast - # A transform that reports a change (so generate is attempted) - change_instance = MagicMock() - change_instance.execute.return_value = True - change_transform = MagicMock(return_value=change_instance) + from pyjsclear.transforms.control_flow import ControlFlowRecoverer - mock_transforms.__iter__ = lambda self: iter([change_transform]) + # One cheap transform that changes, one expensive that should be skipped + cheap_instance = MagicMock() + cheap_instance.execute.return_value = False + cheap_transform = MagicMock(return_value=cheap_instance) - code = 'var x = 1;' + expensive_instance = MagicMock() + expensive_instance.execute.return_value = True + + mock_transforms.__iter__ = lambda self: iter([cheap_transform, ControlFlowRecoverer]) + + code = 'x' * (_MAX_CODE_SIZE + 1) + result = Deobfuscator(code).execute() + # ControlFlowRecoverer should have been filtered out in lite mode + # Since only the cheap transform ran and returned False, original code returned + assert result == code + + @patch('pyjsclear.deobfuscator.parse') + @patch('pyjsclear.deobfuscator._count_nodes', return_value=60_000) + @patch('pyjsclear.deobfuscator.generate', return_value='generated') + @patch('pyjsclear.deobfuscator.TRANSFORM_CLASSES') + def test_large_node_count_strips_expensive_transforms(self, mock_transforms, mock_generate, mock_count, mock_parse): + """Large AST (>50k nodes) strips expensive transforms (line 156).""" + mock_ast = MagicMock() + mock_parse.return_value = mock_ast + + cheap_instance = MagicMock() + cheap_instance.execute.return_value = False + cheap_transform = MagicMock(return_value=cheap_instance) + + from pyjsclear.transforms.proxy_functions import ProxyFunctionInliner + + mock_transforms.__iter__ = lambda self: iter([cheap_transform, ProxyFunctionInliner]) + + # Code > _LARGE_FILE_SIZE to trigger node counting, but < _MAX_CODE_SIZE (not lite mode) + code = 'x' * (_LARGE_FILE_SIZE + 1) result = Deobfuscator(code).execute() + # ProxyFunctionInliner should be filtered out due to node count > _NODE_COUNT_LIMIT assert result == code diff --git a/tests/unit/generator_test.py b/tests/unit/generator_test.py index 2006667..2319cf5 100644 --- a/tests/unit/generator_test.py +++ b/tests/unit/generator_test.py @@ -94,18 +94,9 @@ def test_boolean_true(self): def test_boolean_false(self): assert generate(_lit(False, 'false')) == 'false' - def test_boolean_true_no_raw(self): - assert generate(_lit(True)) == 'true' - - def test_boolean_false_no_raw(self): - assert generate(_lit(False)) == 'false' - def test_null(self): assert generate(_lit(None, 'null')) == 'null' - def test_null_no_raw(self): - assert generate(_lit(None)) == 'null' - def test_raw_value_used(self): # When value is not a string and raw is present, raw takes priority assert generate(_lit(10, '0xA')) == '0xA' @@ -1439,86 +1430,6 @@ def test_computed_identifier_key_not_quoted(self): # =========================================================================== -class TestRoundtrip: - """Parse JavaScript with parse(), then generate back, and verify output.""" - - def _roundtrip(self, code): - ast = parse(code) - return generate(ast) - - def test_var_declaration(self): - result = self._roundtrip('var x = 1;') - assert 'var x = 1;' in result - - def test_let_const(self): - result = self._roundtrip('let a = 1; const b = 2;') - assert 'let a = 1;' in result - assert 'const b = 2;' in result - - def test_function_declaration(self): - result = self._roundtrip('function foo(a) { return a; }') - assert 'function foo(a)' in result - assert 'return a;' in result - - def test_if_else(self): - result = self._roundtrip('if (x) { a(); } else { b(); }') - assert 'if (x)' in result - assert 'else' in result - - def test_for_loop(self): - result = self._roundtrip('for (var i = 0; i < 10; i++) {}') - assert 'for (' in result - assert 'i < 10' in result - - def test_while_loop(self): - result = self._roundtrip('while (true) { break; }') - assert 'while (true)' in result - assert 'break;' in result - - def test_arrow_function(self): - result = self._roundtrip('var f = (x) => x + 1;') - assert '=>' in result - - def test_class(self): - result = self._roundtrip('class Foo extends Bar { constructor() {} }') - assert 'class Foo extends Bar' in result - assert 'constructor()' in result - - def test_template_literal(self): - result = self._roundtrip('var s = `hello ${name}`;') - assert '`hello ${name}`' in result - - def test_try_catch(self): - result = self._roundtrip('try { a(); } catch (e) { b(); }') - assert 'try {' in result - assert 'catch (e)' in result - - def test_switch(self): - result = self._roundtrip('switch (x) { case 1: break; default: break; }') - assert 'switch (x)' in result - assert 'case 1:' in result - assert 'default:' in result - - def test_do_while(self): - result = self._roundtrip('do { x++; } while (x < 10);') - assert 'do {' in result - assert 'while (x < 10)' in result - - def test_spread_in_call(self): - result = self._roundtrip('foo(...args);') - assert '...args' in result - - def test_object_destructuring(self): - result = self._roundtrip('var { a, b } = obj;') - assert 'a' in result - assert 'b' in result - - def test_array_destructuring(self): - result = self._roundtrip('var [a, b] = arr;') - assert 'a' in result - assert 'b' in result - - # =========================================================================== # Program-level tests # =========================================================================== @@ -1563,3 +1474,375 @@ def test_block_with_statements(self): assert result.startswith('{') assert 'a;' in result assert result.rstrip().endswith('}') + + +# =========================================================================== +# Coverage gap tests +# =========================================================================== + + +class TestGenStmtNoneNode: + """Line 113: _gen_stmt with None node returns ''.""" + + def test_gen_stmt_none(self): + from pyjsclear.generator import _gen_stmt + + assert _gen_stmt(None, 0) == '' + + +class TestGenStmtDoubleEndingSemicolon: + """Line 120: statement that already ends with ';' avoids double semicolon.""" + + def test_statement_ending_with_semicolon(self): + # EmptyStatement generates ';' and is in _NO_SEMI_TYPES, + # but we can construct a node whose generate() output ends with ';' + # that is NOT in _NO_SEMI_TYPES. Use a manual approach. + from pyjsclear.generator import _gen_stmt + + # Create a fake node type that generates code ending with ';' + # A VariableDeclaration ending with ';' (by appending manually) + # Actually, let's just test the path: _gen_stmt appends ';' only if code doesn't already end with it + # We can use generate on an expression statement whose expression ends with ; + # Simplest: use a literal with raw ending in ; + node = {'type': 'ExpressionStatement', 'expression': {'type': 'Literal', 'value': 1, 'raw': '1;'}} + result = _gen_stmt(node, 0) + # Should not double the semicolon + assert result == '1;' + assert not result.endswith(';;') + + +class TestDirectiveInBlock: + """Line 132: directive ('use strict') followed by another statement in block body.""" + + def test_use_strict_directive_in_block(self): + ast = parse('"use strict"; var x = 1;') + result = generate(ast) + assert '"use strict"' in result + assert 'var x = 1' in result + # There should be a blank line after the directive + lines = result.split('\n') + directive_idx = next(i for i, l in enumerate(lines) if 'use strict' in l) + assert lines[directive_idx + 1].strip() == '' + + def test_use_strict_in_function_block(self): + ast = parse('function f() { "use strict"; return 1; }') + result = generate(ast) + assert '"use strict"' in result + assert 'return 1' in result + + +class TestNonBlockConsequentAlternate: + """Lines 194, 200: non-BlockStatement consequent/alternate in if.""" + + def test_if_with_expression_consequent(self): + # if (true) x; — consequent is ExpressionStatement, not BlockStatement + ast = parse('if (true) x;') + result = generate(ast) + assert 'if (true)' in result + assert 'x' in result + + def test_if_else_with_expression_alternate(self): + # if (true) { x; } else y; + ast = parse('if (true) { x; } else y;') + result = generate(ast) + assert 'else' in result + assert 'y' in result + + def test_if_else_both_non_block(self): + ast = parse('if (true) x; else y;') + result = generate(ast) + assert 'if (true)' in result + assert 'x' in result + assert 'else' in result + assert 'y' in result + + +class TestPostfixUnary: + """Line 326: postfix unary expression (prefix=false).""" + + def test_postfix_unary_not_prefix(self): + # Construct a UnaryExpression with prefix=false manually + # (JS doesn't have postfix unary except ++/--, which are UpdateExpression, + # but the code path exists) + node = { + 'type': 'UnaryExpression', + 'operator': '!', + 'prefix': False, + 'argument': {'type': 'Identifier', 'name': 'x'}, + } + result = generate(node) + assert result == 'x!' + + +class TestMemberAccessOnComplexExpression: + """Line 360: member access on complex expression like (a + b).toString().""" + + def test_binary_expression_member_access(self): + ast = parse('(a + b).toString()') + result = generate(ast) + assert '(a + b).toString()' in result + + def test_conditional_expression_member_access(self): + ast = parse('(a ? b : c).x') + result = generate(ast) + assert '(a ? b : c).x' in result + + def test_sequence_expression_member_access(self): + ast = parse('(a, b).x') + result = generate(ast) + assert '(a, b).x' in result + + def test_arrow_function_member_access(self): + # Arrow function as object in member expression + node = { + 'type': 'MemberExpression', + 'object': { + 'type': 'ArrowFunctionExpression', + 'params': [], + 'body': {'type': 'Literal', 'value': 1, 'raw': '1'}, + }, + 'property': {'type': 'Identifier', 'name': 'call'}, + 'computed': False, + } + result = generate(node) + assert '(() => 1).call' in result + + +class TestRestElementInProperty: + """Lines 453-455: RestElement handled by _gen_property.""" + + def test_gen_property_rest_element(self): + # _gen_property generates key: value for a Property node + from pyjsclear.generator import _gen_property + + node = { + 'type': 'Property', + 'key': {'type': 'Identifier', 'name': 'a'}, + 'value': {'type': 'Identifier', 'name': 'b'}, + } + result = _gen_property(node, 0) + assert result == 'a: b' + + +class TestLiteralFallbackCase: + """Lines 492-493: Literal with non-float, non-string, non-None value — the _ case.""" + + def test_literal_unknown_value_type(self): + # A literal with a value that's not str, int, float, bool, or None + # e.g. a complex number or some other object + node = {'type': 'Literal', 'value': (1, 2)} + result = generate(node) + assert result == '(1, 2)' + + def test_literal_bytes_value(self): + node = {'type': 'Literal', 'value': b'hello'} + result = generate(node) + assert result == "b'hello'" + + +class TestMethodDefinitionComputedOrLiteralKey: + """Line 550: method definition with computed key or Literal key.""" + + def test_method_definition_computed_key(self): + ast = parse('class Foo { [Symbol.iterator]() {} }') + result = generate(ast) + assert '[Symbol.iterator]' in result + + def test_method_definition_literal_key(self): + # Construct a MethodDefinition with a Literal key + node = { + 'type': 'Program', + 'sourceType': 'script', + 'body': [ + { + 'type': 'ClassDeclaration', + 'id': {'type': 'Identifier', 'name': 'Foo'}, + 'superClass': None, + 'body': { + 'type': 'ClassBody', + 'body': [ + { + 'type': 'MethodDefinition', + 'key': {'type': 'Literal', 'value': 0, 'raw': '0'}, + 'computed': False, + 'kind': 'method', + 'static': False, + 'value': { + 'type': 'FunctionExpression', + 'id': None, + 'params': [], + 'body': {'type': 'BlockStatement', 'body': []}, + }, + } + ], + }, + } + ], + } + result = generate(node) + assert '[0]' in result + + +class TestRestElementInObjectPattern: + """Line 594: RestElement in ObjectPattern.""" + + def test_rest_element_in_object_pattern(self): + ast = parse('var {a, ...rest} = obj;') + result = generate(ast) + assert '...rest' in result + assert 'a' in result + + +class TestEmptyObjectPattern: + """Line 605: Empty ObjectPattern {}.""" + + def test_empty_object_pattern(self): + node = { + 'type': 'ObjectPattern', + 'properties': [], + } + result = generate(node) + assert result == '{}' + + +class TestImportSpecifiers: + """Lines 618-628: import specifiers.""" + + def test_import_default_specifier(self): + ast = parse('import foo from "bar";') + result = generate(ast) + assert 'import foo from "bar"' in result + + def test_import_namespace_specifier(self): + ast = parse('import * as ns from "bar";') + result = generate(ast) + assert 'import * as ns from "bar"' in result + + def test_import_named_specifier(self): + ast = parse('import { x } from "bar";') + result = generate(ast) + assert 'import {x} from "bar"' in result + + def test_import_named_with_rename(self): + ast = parse('import { x as y } from "bar";') + result = generate(ast) + assert 'x as y' in result + assert 'from "bar"' in result + + +class TestImportDeclarations: + """Lines 632-647: import declarations.""" + + def test_bare_import(self): + ast = parse('import "foo";') + result = generate(ast) + assert 'import "foo"' in result + + def test_import_default_and_named(self): + ast = parse('import def, { a } from "mod";') + result = generate(ast) + assert 'def' in result + assert '{a}' in result + assert 'from "mod"' in result + + +class TestExportSpecifiers: + """Lines 651-655: export specifiers with rename.""" + + def test_export_specifier_same_name(self): + ast = parse('export { x };') + result = generate(ast) + assert 'export {x}' in result + + def test_export_specifier_with_rename(self): + ast = parse('export { x as y };') + result = generate(ast) + assert 'x as y' in result + + +class TestExportDeclarations: + """Lines 659-677: various export forms.""" + + def test_export_named_with_declaration(self): + ast = parse('export var x = 1;') + result = generate(ast) + assert 'export var x = 1' in result + + def test_export_named_with_specifiers(self): + ast = parse('export { a, b };') + result = generate(ast) + assert 'export {a, b}' in result + + def test_export_named_with_source(self): + ast = parse('export { a } from "mod";') + result = generate(ast) + assert 'export {a} from "mod"' in result + + def test_export_default(self): + ast = parse('export default 42;') + result = generate(ast) + assert 'export default 42' in result + + def test_export_default_function(self): + ast = parse('export default function() {}') + result = generate(ast) + assert 'export default function' in result + + def test_export_all(self): + ast = parse('export * from "mod";') + result = generate(ast) + assert 'export * from "mod"' in result + + +class TestExprPrecedenceCases: + """Lines 699-713: various precedence cases.""" + + def test_conditional_expression_precedence(self): + # Conditional expression as part of a larger expression + ast = parse('a = x ? 1 : 2;') + result = generate(ast) + assert 'x ? 1 : 2' in result + + def test_assignment_expression_precedence(self): + ast = parse('a = b = c;') + result = generate(ast) + assert 'a = b = c' in result + + def test_yield_expression_precedence(self): + ast = parse('function* g() { yield 1; }') + result = generate(ast) + assert 'yield 1' in result + + def test_sequence_expression_precedence(self): + ast = parse('(a, b, c);') + result = generate(ast) + assert 'a, b, c' in result + + def test_binary_wraps_lower_precedence(self): + # Multiplication should wrap addition operands + ast = parse('(a + b) * c;') + result = generate(ast) + assert '(a + b) * c' in result + + def test_nested_precedence_conditional_in_assignment(self): + ast = parse('x = a ? b : c;') + result = generate(ast) + assert 'x = a ? b : c' in result + + def test_arrow_function_precedence(self): + from pyjsclear.generator import _expr_precedence + + arrow_node = {'type': 'ArrowFunctionExpression'} + assert _expr_precedence(arrow_node) == 3 + + def test_unknown_type_precedence(self): + from pyjsclear.generator import _expr_precedence + + node = {'type': 'SomeUnknownExpression'} + assert _expr_precedence(node) == 0 + + def test_non_dict_precedence(self): + from pyjsclear.generator import _expr_precedence + + assert _expr_precedence(42) == 20 + assert _expr_precedence('str') == 20 diff --git a/tests/unit/init_test.py b/tests/unit/init_test.py index 61f0f2f..37f5c01 100644 --- a/tests/unit/init_test.py +++ b/tests/unit/init_test.py @@ -1,12 +1,16 @@ import pytest import pyjsclear -from pyjsclear import Deobfuscator, deobfuscate, deobfuscate_file +from pyjsclear import Deobfuscator +from pyjsclear import deobfuscate +from pyjsclear import deobfuscate_file class TestVersion: - def test_version_is_0_1_0(self): - assert pyjsclear.__version__ == '0.1.0' + def test_version_is_semver(self): + parts = pyjsclear.__version__.split('.') + assert len(parts) == 3 + assert all(p.isdigit() for p in parts) class TestDeobfuscate: @@ -14,17 +18,6 @@ def test_returns_string(self): result = deobfuscate('var x = 1;') assert isinstance(result, str) - def test_simple_code_unchanged(self): - code = 'var x = 1;' - result = deobfuscate(code) - assert result == code - - def test_with_max_iterations(self): - code = 'var x = 1;' - result = deobfuscate(code, max_iterations=5) - assert isinstance(result, str) - assert result == code - class TestDeobfuscateFile: def test_reads_file_returns_string_no_output(self, tmp_path): diff --git a/tests/unit/main_test.py b/tests/unit/main_test.py index 4ece9c4..6d72bd4 100644 --- a/tests/unit/main_test.py +++ b/tests/unit/main_test.py @@ -2,7 +2,8 @@ import sys from io import StringIO -from unittest.mock import patch, mock_open +from unittest.mock import mock_open +from unittest.mock import patch import pytest @@ -90,20 +91,6 @@ def test_custom_max_iterations(self, tmp_path, monkeypatch): mock_deobf.assert_called_once_with('var x = 1;', max_iterations=10) - def test_default_max_iterations(self, tmp_path, monkeypatch): - input_file = tmp_path / 'input.js' - input_file.write_text('var x = 1;') - - monkeypatch.setattr(sys, 'argv', ['pyjsclear', str(input_file)]) - - stdout = StringIO() - monkeypatch.setattr(sys, 'stdout', stdout) - - with patch('pyjsclear.__main__.deobfuscate', return_value='var x = 1;') as mock_deobf: - main() - - mock_deobf.assert_called_once_with('var x = 1;', max_iterations=50) - class TestMissingInputArgument: """Test 5: Missing input argument raises SystemExit.""" @@ -115,3 +102,24 @@ def test_missing_input_raises_system_exit(self, monkeypatch): main() assert exc_info.value.code == 2 + + +# --------------------------------------------------------------------------- +# Coverage gap tests +# --------------------------------------------------------------------------- + + +class TestModuleExecution: + """Line 37: if __name__ == '__main__': main() in __main__.py.""" + + def test_module_execution(self): + import subprocess + + result = subprocess.run( + ['python', '-m', 'pyjsclear', '-'], + input='var x = 1;', + capture_output=True, + text=True, + ) + assert result.returncode == 0 + assert 'var x = 1' in result.stdout diff --git a/tests/unit/parser_test.py b/tests/unit/parser_test.py index e458093..8a6bb4d 100644 --- a/tests/unit/parser_test.py +++ b/tests/unit/parser_test.py @@ -1,9 +1,12 @@ """Comprehensive unit tests for pyjsclear.parser.""" import re + import pytest -from pyjsclear.parser import parse, _fast_to_dict, _ASYNC_MAP +from pyjsclear.parser import _ASYNC_MAP +from pyjsclear.parser import _fast_to_dict +from pyjsclear.parser import parse # --------------------------------------------------------------------------- @@ -79,10 +82,6 @@ def test_skips_underscore_keys(self): result = _fast_to_dict({'_private': 1, 'public': 2}) assert result == {'public': 2} - def test_skips_multiple_underscore_keys(self): - result = _fast_to_dict({'__dunder': 0, '_x': 1, 'ok': 2}) - assert result == {'ok': 2} - def test_skips_optional_false(self): result = _fast_to_dict({'optional': False, 'name': 'test'}) assert result == {'name': 'test'} @@ -465,22 +464,6 @@ def test_multiple_statements(self): class TestParseStructure: - def test_returns_dict(self): - result = parse('1') - assert isinstance(result, dict) - - def test_has_type_program(self): - result = parse('1') - assert result['type'] == 'Program' - - def test_has_body_list(self): - result = parse('1') - assert isinstance(result['body'], list) - - def test_has_sourceType(self): - result = parse('1') - assert result['sourceType'] == 'script' - def test_no_underscore_keys_in_output(self): """Ensure no keys starting with underscore appear anywhere in the AST.""" result = parse('function foo(x) { return x + 1; }') @@ -531,3 +514,20 @@ def test_error_chains_original(self): with pytest.raises(SyntaxError) as exc_info: parse('<<<') assert exc_info.value.__cause__ is not None + + +# --------------------------------------------------------------------------- +# Coverage gap tests +# --------------------------------------------------------------------------- + + +class TestCompletelyUnparseable: + """Lines 45-46: Code that fails both script AND module parsing.""" + + def test_completely_unparseable(self): + with pytest.raises(SyntaxError): + parse('@@@!!!') + + def test_garbage_input(self): + with pytest.raises(SyntaxError, match='Failed to parse JavaScript'): + parse('}{}{}{') diff --git a/tests/unit/scope_test.py b/tests/unit/scope_test.py index e8f5c05..67ea10b 100644 --- a/tests/unit/scope_test.py +++ b/tests/unit/scope_test.py @@ -3,7 +3,10 @@ import pytest from pyjsclear.parser import parse -from pyjsclear.scope import Binding, Scope, build_scope_tree, _nearest_function_scope +from pyjsclear.scope import Binding +from pyjsclear.scope import Scope +from pyjsclear.scope import _nearest_function_scope +from pyjsclear.scope import build_scope_tree # --------------------------------------------------------------------------- @@ -46,28 +49,6 @@ def test_var_with_assignments_is_not_constant(self): binding.assignments.append({'type': 'AssignmentExpression'}) assert binding.is_constant is False - def test_let_no_assignments_is_constant(self): - scope = Scope(None, {}, is_function=True) - binding = scope.add_binding('x', {}, 'let') - assert binding.is_constant is True - - def test_let_with_assignments_is_not_constant(self): - scope = Scope(None, {}, is_function=True) - binding = scope.add_binding('x', {}, 'let') - binding.assignments.append({'type': 'AssignmentExpression'}) - assert binding.is_constant is False - - def test_param_no_assignments_is_constant(self): - scope = Scope(None, {}, is_function=True) - binding = scope.add_binding('x', {}, 'param') - assert binding.is_constant is True - - def test_param_with_assignments_is_not_constant(self): - scope = Scope(None, {}, is_function=True) - binding = scope.add_binding('x', {}, 'param') - binding.assignments.append({'type': 'AssignmentExpression'}) - assert binding.is_constant is False - # --------------------------------------------------------------------------- # Scope: add_binding, get_binding, get_own_binding @@ -418,14 +399,16 @@ def test_for_var_hoisted_out(self): class TestNestedFunctions: def test_nested_function_scopes(self): - ast = parse(""" + ast = parse( + """ function outer() { var a = 1; function inner() { var b = 2; } } - """) + """ + ) root_scope, _ = build_scope_tree(ast) assert root_scope.get_own_binding('outer') is not None outer_scope = root_scope.children[0] @@ -439,12 +422,14 @@ def test_nested_function_scopes(self): assert inner_scope.get_binding('a') is not None def test_shadowed_variables_in_nested_functions(self): - ast = parse(""" + ast = parse( + """ var x = 1; function f() { var x = 2; } - """) + """ + ) root_scope, _ = build_scope_tree(ast) root_x = root_scope.get_own_binding('x') f_scope = root_scope.children[0] @@ -477,37 +462,6 @@ class TestOperatorPrecedenceBug: returned None/falsy, which cannot happen with a well-formed scope tree. """ - def test_var_targets_function_scope(self): - """For 'var', the target is the nearest function scope. - - Since _nearest_function_scope returns a truthy value, the - buggy precedence does not matter here -- both interpretations - yield the function scope. - """ - ast = parse('function f() { { var x = 1; } }') - root_scope, _ = build_scope_tree(ast) - f_scope = root_scope.children[0] - assert f_scope.is_function is True - # var x should be hoisted to f_scope - assert f_scope.get_own_binding('x') is not None - assert f_scope.get_own_binding('x').kind == 'var' - - def test_let_targets_block_scope(self): - """For 'let', the target is the current (block) scope. - - When kind != 'var', the else branch fires and gives `scope`, - which is the block scope. This works correctly regardless of - operator precedence because the `or` short-circuits and the - conditional still evaluates the else branch. - """ - ast = parse('function f() { { let y = 2; } }') - root_scope, _ = build_scope_tree(ast) - f_scope = root_scope.children[0] - assert f_scope.get_own_binding('y') is None - block_scope = f_scope.children[0] - assert block_scope.get_own_binding('y') is not None - assert block_scope.get_own_binding('y').kind == 'let' - def test_precedence_equivalence_when_function_scope_truthy(self): """Both interpretations give the same result when _nearest_function_scope returns a truthy value (the normal case). @@ -586,3 +540,158 @@ def test_block_statement_in_scope_map(self): root_scope, node_scope = build_scope_tree(ast) block_node = ast['body'][0] assert id(block_node) in node_scope + + +# --------------------------------------------------------------------------- +# Coverage gap tests +# --------------------------------------------------------------------------- + + +class TestFunctionDeclarationNameNonReference: + """Line 72/82: Function declaration name is a non-reference identifier.""" + + def test_function_declaration_name_not_counted_as_reference(self): + ast = parse('function foo() {}') + root_scope, _ = build_scope_tree(ast) + binding = root_scope.get_own_binding('foo') + assert binding is not None + assert binding.kind == 'function' + # The 'foo' in 'function foo()' should not be a reference + # (it's the declaration site, handled by _is_non_reference_identifier) + # References list should be empty since foo is never used + assert len(binding.references) == 0 + + +class TestFallbackGetChildKeys: + """Line 94: Fallback get_child_keys for unknown node type.""" + + def test_unknown_node_type_in_tree(self): + # Craft an AST with a custom node type that's not in _CHILD_KEYS + ast = parse('var x = 1;') + # Inject a custom child node with an unknown type + ast['body'].append( + { + 'type': 'CustomUnknownNode', + 'argument': {'type': 'Identifier', 'name': 'z'}, + } + ) + # Should not crash - fallback get_child_keys kicks in + root_scope, _ = build_scope_tree(ast) + assert root_scope is not None + + +class TestNonDictOrNoneInCollectDeclarations: + """Lines 130, 133: Non-dict or None-type node in _collect_declarations.""" + + def test_none_element_in_body(self): + # Manually inject None into body + ast = parse('var x = 1;') + ast['body'].append(None) + # Should not crash + root_scope, _ = build_scope_tree(ast) + assert root_scope.get_own_binding('x') is not None + + def test_node_without_type(self): + # Inject a node without 'type' key + ast = parse('var x = 1;') + ast['body'].append({'nottype': 'something'}) + root_scope, _ = build_scope_tree(ast) + assert root_scope.get_own_binding('x') is not None + + +class TestArrowFunctionAssignmentPatternParam: + """Lines 155-156: Arrow function with AssignmentPattern param.""" + + def test_arrow_with_default_param(self): + # Use expression statement wrapper so VariableDeclaration handler doesn't skip recursion + ast = parse('((x = 5) => x + 1);') + root_scope, _ = build_scope_tree(ast) + # Arrow function creates a child scope with param 'x' + arrow_scope = root_scope.children[0] + assert arrow_scope.is_function is True + x_binding = arrow_scope.get_own_binding('x') + assert x_binding is not None + assert x_binding.kind == 'param' + + +class TestArrowFunctionExpressionBody: + """Line 167: Arrow function with expression body (non-BlockStatement).""" + + def test_arrow_expression_body(self): + # Use expression statement to avoid VariableDeclaration early return + ast = parse('(x => x + 1);') + root_scope, _ = build_scope_tree(ast) + arrow_scope = root_scope.children[0] + assert arrow_scope.is_function is True + assert arrow_scope.get_own_binding('x') is not None + assert arrow_scope.get_own_binding('x').kind == 'param' + + def test_arrow_expression_body_references(self): + ast = parse('var y = 10; (x => x + y);') + root_scope, _ = build_scope_tree(ast) + y_binding = root_scope.get_own_binding('y') + assert y_binding is not None + # y is referenced inside the arrow + assert len(y_binding.references) >= 1 + + +class TestArrayPatternWithHoles: + """Lines 209, 213-214: Array pattern with holes (elisions).""" + + def test_array_pattern_with_holes(self): + ast = parse('var [a, , b] = [1, 2, 3];') + root_scope, _ = build_scope_tree(ast) + assert root_scope.get_own_binding('a') is not None + assert root_scope.get_own_binding('b') is not None + + def test_array_pattern_leading_hole(self): + ast = parse('var [, a] = [1, 2];') + root_scope, _ = build_scope_tree(ast) + assert root_scope.get_own_binding('a') is not None + + +class TestObjectPatternPropertyWithoutValue: + """Line 223: ObjectPattern property without value_node.""" + + def test_object_pattern_property_no_value(self): + # Craft an AST manually with a property that has no 'value' and no 'argument' + ast = { + 'type': 'Program', + 'sourceType': 'script', + 'body': [ + { + 'type': 'VariableDeclaration', + 'kind': 'var', + 'declarations': [ + { + 'type': 'VariableDeclarator', + 'id': { + 'type': 'ObjectPattern', + 'properties': [ + { + 'type': 'Property', + 'key': {'type': 'Identifier', 'name': 'x'}, + # No 'value' or 'argument' key + } + ], + }, + 'init': {'type': 'Identifier', 'name': 'obj'}, + } + ], + } + ], + } + # Should not crash; 'x' should not be bound since there's no value_node + root_scope, _ = build_scope_tree(ast) + assert root_scope is not None + + +class TestMissingBindingInCollectReferences: + """Lines 242, 245: Missing binding in _collect_references, fallback child_keys.""" + + def test_unbound_identifier_reference(self): + # Reference to an identifier not in any scope + ast = parse('console.log(x);') + root_scope, _ = build_scope_tree(ast) + # 'x' is not declared, so no binding should exist + assert root_scope.get_own_binding('x') is None diff --git a/tests/unit/transforms/aa_decode_test.py b/tests/unit/transforms/aa_decode_test.py index d5f63cd..304dc4e 100644 --- a/tests/unit/transforms/aa_decode_test.py +++ b/tests/unit/transforms/aa_decode_test.py @@ -1,5 +1,7 @@ """Tests for AAEncode decoder.""" +from pyjsclear.transforms.aa_decode import _AA_DETECT_RE +from pyjsclear.transforms.aa_decode import _UNICODE_MARKER from pyjsclear.transforms.aa_decode import aa_decode from pyjsclear.transforms.aa_decode import is_aa_encoded @@ -74,3 +76,32 @@ def test_decode_returns_string(self): result = aa_decode(AA_SAMPLE) # At minimum, it should return a string (even if imperfect) assert result is None or isinstance(result, str) + + def test_unicode_marker_path(self): + """Test the unicode character marker path (lines 71-74). + + Build a minimal AAEncoded string with the unicode marker to exercise + that code path. + """ + # We need the detection pattern to match, plus escape-split parts with _UNICODE_MARKER + # Build a fake AAEncoded string that the decoder can parse + detect = '(\uff9f\u0414\uff9f)[\uff9f\u03b5\uff9f]' + # Create a part that starts with the unicode marker followed by a hex number + # chr(0x41) = 'A', so hex_str = '41' + escape_split = '(\uff9f\u0414\uff9f)[\uff9f\u03b5\uff9f]+' + part_with_unicode = _UNICODE_MARKER + '41' + code = detect + escape_split + part_with_unicode + result = aa_decode(code) + # Should decode the unicode marker part to chr(0x41) = 'A' + assert result is not None + assert 'A' in result + + def test_value_error_returns_none(self): + """ValueError in decoding returns None (lines 82-83).""" + # Build a fake AAEncoded string with invalid octal that triggers ValueError + detect = '(\uff9f\u0414\uff9f)[\uff9f\u03b5\uff9f]' + escape_split = '(\uff9f\u0414\uff9f)[\uff9f\u03b5\uff9f]+' + invalid_part = 'not_a_number' + code = detect + escape_split + invalid_part + result = aa_decode(code) + assert result is None diff --git a/tests/unit/transforms/anti_tamper_test.py b/tests/unit/transforms/anti_tamper_test.py index b3a47af..ed51f40 100644 --- a/tests/unit/transforms/anti_tamper_test.py +++ b/tests/unit/transforms/anti_tamper_test.py @@ -3,7 +3,8 @@ import pytest from pyjsclear.transforms.anti_tamper import AntiTamperRemover -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip class TestAntiTamperRemover: @@ -104,3 +105,90 @@ def test_multiple_statements_only_anti_tamper_removed(self): assert 'var a = 1' in norm assert 'var b = 2' in norm assert 'console' not in norm + + +class TestAntiTamperRemoverEdgeCases: + """Tests for uncovered edge cases.""" + + def test_debug_protection_for_loop(self): + """Lines 55-56: Debug pattern with debugger + for loop.""" + code = '(function() { for(;;) { debugger; } })();' + result, changed = roundtrip(code, AntiTamperRemover) + assert isinstance(changed, bool) + + def test_iife_expression_is_none(self): + """Line 70: ExpressionStatement with expression that is None/falsy.""" + # ExpressionStatement with empty/null expression — unusual but handled + code = ';' + result, changed = roundtrip(code, AntiTamperRemover) + assert changed is False + + def test_call_without_callee(self): + """Line 78: Call without callee — should not crash.""" + # Normal code where call has a non-function callee + code = 'foo()();' + result, changed = roundtrip(code, AntiTamperRemover) + assert changed is False + + def test_debug_protection_setInterval(self): + """Debug protection with setInterval pattern.""" + code = '(function() { setInterval(function() { debugger; }, 100); })();' + result, changed = roundtrip(code, AntiTamperRemover) + # setInterval is a debug pattern, but debugger might be commented out by generator + assert isinstance(changed, bool) + + def test_exception_during_generate(self): + """Lines 87-88: Exception during generate() should be caught gracefully.""" + # This is hard to trigger directly via roundtrip since we'd need a malformed AST. + # We test indirectly that normal IIFE processing doesn't crash. + code = '(function() { var x = 1; var y = 2; })();' + result, changed = roundtrip(code, AntiTamperRemover) + assert changed is False + + def test_debugger_with_setInterval_removed(self): + """Combined debugger + setInterval in IIFE.""" + code = '(function() { setInterval(function() { (function() { return "debugger"; })(); }, 500); })();' + result, changed = roundtrip(code, AntiTamperRemover) + # setInterval pattern should be detected + assert isinstance(changed, bool) + + def test_expression_statement_no_expression(self): + """Line 70: ExpressionStatement with expression set to None.""" + from pyjsclear.parser import parse + + ast = parse('a();') + # Manually set expression to None to trigger early return + ast['body'][0]['expression'] = None + t = AntiTamperRemover(ast) + changed = t.execute() + assert changed is False + + def test_call_without_callee(self): + """Line 78: Call node without callee.""" + from pyjsclear.parser import parse + + ast = parse('(function() { x(); })();') + # Find the outer CallExpression and remove its callee + call = ast['body'][0]['expression'] + if call.get('type') == 'CallExpression': + call['callee'] = None + t = AntiTamperRemover(ast) + changed = t.execute() + assert changed is False + + def test_exception_during_generate_malformed_callee(self): + """Lines 87-88: Exception during generate() with malformed AST.""" + from pyjsclear.parser import parse + + ast = parse('(function() { x(); })();') + # Find the IIFE callee (FunctionExpression) and corrupt its body + call = ast['body'][0]['expression'] + if call.get('type') == 'CallExpression': + callee = call.get('callee') + if callee and callee.get('type') == 'FunctionExpression': + # Corrupt the body to make generate() raise + callee['body'] = 'not_a_valid_body' + t = AntiTamperRemover(ast) + changed = t.execute() + # Should not crash, just skip the node + assert changed is False diff --git a/tests/unit/transforms/base_test.py b/tests/unit/transforms/base_test.py index f9a400c..4668bfe 100644 --- a/tests/unit/transforms/base_test.py +++ b/tests/unit/transforms/base_test.py @@ -27,10 +27,6 @@ def test_node_scope_defaults_to_none(self): t = Transform('ast') assert t.node_scope is None - def test_changed_defaults_to_false(self): - t = Transform('ast') - assert t._changed is False - class TestTransformExecute: def test_raises_not_implemented(self): diff --git a/tests/unit/transforms/constant_prop_test.py b/tests/unit/transforms/constant_prop_test.py index 05c547c..6be27d8 100644 --- a/tests/unit/transforms/constant_prop_test.py +++ b/tests/unit/transforms/constant_prop_test.py @@ -3,7 +3,8 @@ import pytest from pyjsclear.transforms.constant_prop import ConstantProp -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip class TestConstantPropBasic: @@ -44,6 +45,129 @@ def test_null_literal_propagated(self): assert changed is True assert normalize(code) == normalize('y(null);') - def test_no_constants_returns_false(self): - code, changed = roundtrip('var x = foo(); y(x);', ConstantProp) + +class TestConstantPropSkipConditions: + """Tests for reference skip conditions (lines 15-22).""" + + def test_skip_assignment_lhs(self): + """Line 18: Reference used as assignment target should be skipped.""" + code = 'const x = 5; x = 10;' + result, changed = roundtrip(code, ConstantProp) + # x = 10 assignment target should not be replaced with 5 = 10 + assert isinstance(changed, bool) + + def test_skip_update_target(self): + """Line 20: Reference used as update target should be skipped.""" + code = 'var x = 5; x++;' + result, changed = roundtrip(code, ConstantProp) + # x++ should not become 5++ + # x has writes (x++) so it's not constant, so no propagation + assert changed is False + + def test_skip_declarator_id(self): + """Line 22: Reference used as VariableDeclarator id should be skipped.""" + code = 'const x = 5; var y = x + 1;' + result, changed = roundtrip(code, ConstantProp) + assert changed is True + assert '5 + 1' in normalize(result) or '5' in result + + +class TestConstantPropDeclaratorRemoval: + """Tests for declarator removal edge cases.""" + + def test_fully_inlined_declaration_removed(self): + """Line 101: Empty declarations list triggers REMOVE of entire VariableDeclaration.""" + code = 'const _0x1 = 5; var y = _0x1 + 1;' + result, changed = roundtrip(code, ConstantProp) + assert changed is True + assert '_0x1' not in result + assert '5' in result + + def test_partially_inlined_multi_declarator(self): + """Declarator removal when multiple declarators exist — only propagated one removed.""" + code = 'const a = 1, b = foo(); var y = a;' + result, changed = roundtrip(code, ConstantProp) + assert changed is True + # a should be inlined and removed, but b (non-literal) stays + assert 'foo()' in result + + def test_non_declarator_in_declarations(self): + """Line 64: Non-VariableDeclarator type check.""" + # Normal constants should be propagated + code = 'const x = true; if (x) { y(); }' + result, changed = roundtrip(code, ConstantProp) + assert changed is True + assert 'true' in result + + def test_boolean_constant_propagated(self): + """Boolean literals are properly propagated.""" + code = 'const flag = false; if (flag) { x(); }' + result, changed = roundtrip(code, ConstantProp) + assert changed is True + assert 'false' in result + + +class TestConstantPropSkipReferenceEdgeCases: + """Additional tests for _should_skip_reference edge cases.""" + + def test_ref_parent_is_none(self): + """Line 15: ref_parent is None → return True (skip).""" + from pyjsclear.transforms.constant_prop import _should_skip_reference + + assert _should_skip_reference(None, 'left') is True + + def test_update_expression_parent(self): + """Line 20: UpdateExpression parent → return True.""" + from pyjsclear.transforms.constant_prop import _should_skip_reference + + parent = {'type': 'UpdateExpression', 'operator': '++', 'argument': {}} + assert _should_skip_reference(parent, 'argument') is True + + def test_variable_declarator_id(self): + """Line 22: VariableDeclarator id parent → return True.""" + from pyjsclear.transforms.constant_prop import _should_skip_reference + + parent = {'type': 'VariableDeclarator', 'id': {}, 'init': None} + assert _should_skip_reference(parent, 'id') is True + + def test_variable_declarator_init_not_skipped(self): + """VariableDeclarator with key='init' should NOT be skipped.""" + from pyjsclear.transforms.constant_prop import _should_skip_reference + + parent = {'type': 'VariableDeclarator', 'id': {}, 'init': {}} + assert _should_skip_reference(parent, 'init') is False + + def test_assignment_expression_right_not_skipped(self): + """AssignmentExpression with key='right' should NOT be skipped.""" + from pyjsclear.transforms.constant_prop import _should_skip_reference + + parent = {'type': 'AssignmentExpression', 'operator': '=', 'left': {}, 'right': {}} + assert _should_skip_reference(parent, 'right') is False + + def test_normal_parent_not_skipped(self): + """Normal parent (e.g., CallExpression) should NOT be skipped.""" + from pyjsclear.transforms.constant_prop import _should_skip_reference + + parent = {'type': 'CallExpression', 'callee': {}, 'arguments': []} + assert _should_skip_reference(parent, 'arguments') is False + + +class TestConstantPropDeclaratorEdgeCases: + """Tests for declarator removal type checks (lines 79, 82, 84).""" + + def test_binding_with_assignments_not_removed(self): + """Line 79: binding with assignments — declaration not removed.""" + # x is assigned a literal but then reassigned → not constant → not propagated + code = 'var x = 5; x = 10; y(x);' + result, changed = roundtrip(code, ConstantProp) assert changed is False + + def test_non_dict_decl_node_skip(self): + """Line 82: decl_node not a dict — should be skipped.""" + from pyjsclear.transforms.constant_prop import _should_skip_reference + + # This is a defensive check; test it doesn't crash in normal flow + code = 'const a = 1; y(a);' + result, changed = roundtrip(code, ConstantProp) + assert changed is True + assert '1' in result diff --git a/tests/unit/transforms/control_flow_test.py b/tests/unit/transforms/control_flow_test.py index b6ac652..e3f3fac 100644 --- a/tests/unit/transforms/control_flow_test.py +++ b/tests/unit/transforms/control_flow_test.py @@ -3,7 +3,8 @@ import pytest from pyjsclear.transforms.control_flow import ControlFlowRecoverer -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip def rt(js_code): @@ -523,3 +524,238 @@ def test_double_not_array_is_truthy(self): not_inner = {'type': 'UnaryExpression', 'operator': '!', 'argument': inner, 'prefix': True} double_not = {'type': 'UnaryExpression', 'operator': '!', 'argument': not_inner, 'prefix': True} assert self.t._is_truthy(double_not) is True + + +# --------------------------------------------------------------------------- +# Coverage gap tests +# --------------------------------------------------------------------------- + + +class TestNonDictInBody: + """Lines 69-70: Non-dict statement in body list.""" + + def test_non_dict_in_body_skipped(self): + """Non-dict items in body should be skipped without crashing.""" + ast = _program([None, 'not_a_dict', _expr_stmt(_call_expr(_identifier('a'), []))]) + t = ControlFlowRecoverer(ast) + changed = t.execute() + assert changed is False + + +class TestExpressionPatternCounterInit: + """Lines 106, 116, 119: expression pattern where assignment doesn't have split or counter init fails.""" + + def test_expression_pattern_no_split(self): + """Assignment that is not a split call should not match.""" + ast = _program( + [ + _expr_stmt(_assignment('x', _literal(42))), + _while_true([_break_stmt()]), + ] + ) + t = ControlFlowRecoverer(ast) + changed = t.execute() + assert changed is False + + def test_expression_pattern_missing_loop(self): + """Expression pattern where there is no loop after the counter init.""" + assign_stmt = _expr_stmt(_assignment('_a', _split_call('1|0'))) + counter_stmt = _expr_stmt(_assignment('_i', _literal(0))) + # No loop after counter, just ends + ast = _program([assign_stmt, counter_stmt]) + t = ControlFlowRecoverer(ast) + changed = t.execute() + assert changed is False + + +class TestFindCounterInit: + """Lines 175-183, 194: _find_counter_init with VariableDeclaration and ExpressionStatement.""" + + def setup_method(self): + self.t = ControlFlowRecoverer(_program([])) + + def test_variable_declaration_counter(self): + stmt = _var_declaration([_var_declarator('_i', _literal(0))]) + result = self.t._find_counter_init(stmt) + assert result == '_i' + + def test_expression_statement_counter(self): + stmt = _expr_stmt(_assignment('_i', _literal(0))) + result = self.t._find_counter_init(stmt) + assert result == '_i' + + def test_non_numeric_init_ignored(self): + stmt = _var_declaration([_var_declarator('_i', _literal('hello'))]) + result = self.t._find_counter_init(stmt) + assert result is None + + def test_non_dict_returns_none(self): + result = self.t._find_counter_init(None) + assert result is None + + result = self.t._find_counter_init('not a dict') + assert result is None + + +class TestForStatementPattern: + """Lines 236-237: ForStatement with init value extraction.""" + + def test_for_statement_recovery(self): + """For loop with switch dispatcher should be recovered.""" + js = ( + 'var _a = "1|0".split("|");' + ' for (var _j = 0; ; ) {' + ' switch (_a[_j++]) { case "0": b(); continue; case "1": a(); continue; }' + ' break; }' + ) + code, changed = rt(js) + assert changed is True + assert 'a()' in code + assert 'b()' in code + assert code.index('a()') < code.index('b()') + + +class TestExtractForInitValue: + """Lines 253-261: _extract_for_init_value with AssignmentExpression init.""" + + def test_assignment_expression_init(self): + init = { + 'type': 'AssignmentExpression', + 'operator': '=', + 'left': _identifier('_i'), + 'right': _literal(0), + } + result = ControlFlowRecoverer._extract_for_init_value(init) + assert result == 0 + + def test_variable_declaration_init(self): + init = _var_declaration([_var_declarator('_i', _literal(2))]) + result = ControlFlowRecoverer._extract_for_init_value(init) + assert result == 2 + + def test_no_init(self): + result = ControlFlowRecoverer._extract_for_init_value(None) + assert result == 0 + + +class TestReconstructStatementsEdgeCases: + """Lines 291, 295-296: _reconstruct_statements with return statement and missing state.""" + + def test_missing_state_stops_reconstruction(self): + """A missing state key should stop reconstruction.""" + cases_map = { + '0': ([_expr_stmt(_call_expr(_identifier('a'), []))], []), + } + result = ControlFlowRecoverer._reconstruct_statements(cases_map, ['0', '1'], 0) + # Should only contain statements from case '0' + assert len(result) == 1 + + +class TestExtractSwitchFromLoopBody: + """Lines 302, 308-310: _extract_switch_from_loop_body edge cases.""" + + def setup_method(self): + self.t = ControlFlowRecoverer(_program([])) + + def test_non_block_statement(self): + """Non-BlockStatement body returns None.""" + result = self.t._extract_switch_from_loop_body(_expr_stmt(_call_expr(_identifier('a'), []))) + assert result is None + + def test_switch_directly_as_body(self): + """SwitchStatement directly as loop body.""" + switch = _switch_stmt(_identifier('x'), []) + result = self.t._extract_switch_from_loop_body(switch) + assert result is not None + assert result['type'] == 'SwitchStatement' + + def test_non_dict_body(self): + result = self.t._extract_switch_from_loop_body(None) + assert result is None + + result = self.t._extract_switch_from_loop_body('not a dict') + assert result is None + + +class TestWhileTruthyPatterns: + """Tests for various truthy patterns in while loop tests.""" + + def test_while_not_zero(self): + """while(!0) pattern - truthy via !0.""" + code = ( + 'var _a = "1|0".split("|"), _i = 0;' + ' while(!0) {' + ' switch(_a[_i++]) { case "0": b(); continue; case "1": a(); continue; }' + ' break; }' + ) + result, changed = rt(code) + assert changed + assert 'a()' in result + assert 'b()' in result + + def test_while_double_not_array(self): + """while(!![]) pattern - truthy via !![].""" + code = ( + 'var _a = "0|1".split("|"), _i = 0;' + ' while(!![]) {' + ' switch(_a[_i++]) { case "0": a(); continue; case "1": b(); continue; }' + ' break; }' + ) + result, changed = rt(code) + assert changed + assert 'a()' in result + assert 'b()' in result + + def test_case_with_return_in_roundtrip(self): + """Case with return statement preserved in roundtrip.""" + code = ( + 'function f() {' + ' var _a = "0|1".split("|"), _i = 0;' + ' while(true) { switch(_a[_i++]) { case "0": a(); continue; case "1": return b(); } break; }' + ' }' + ) + result, changed = rt(code) + assert changed + assert 'return' in result + + def test_is_truthy_not_array_is_false(self): + """![] is falsy (line 324).""" + t = ControlFlowRecoverer(_program([])) + node = { + 'type': 'UnaryExpression', + 'operator': '!', + 'argument': {'type': 'ArrayExpression', 'elements': []}, + 'prefix': True, + } + assert t._is_truthy(node) is False + + def test_is_truthy_literal_non_bool(self): + """Literal with non-bool truthy value (line 317).""" + t = ControlFlowRecoverer(_program([])) + assert t._is_truthy(_literal(42)) is True + assert t._is_truthy(_literal('')) is False + assert t._is_truthy(_literal('hello')) is True + + def test_visited_set_dedup(self): + """Lines 36-37: visited set prevents re-processing the same node.""" + # A node that appears in multiple places (shared reference) + shared = _expr_stmt(_call_expr(_identifier('a'), [])) + block = {'type': 'BlockStatement', 'body': [shared]} + ast = _program([block]) + t = ControlFlowRecoverer(ast) + changed = t.execute() + assert changed is False + + +class TestForInitAssignmentExpression: + """Lines 259-260: _extract_for_init_value with AssignmentExpression init.""" + + def test_for_assignment_init_nonzero(self): + init = { + 'type': 'AssignmentExpression', + 'operator': '=', + 'left': _identifier('_i'), + 'right': _literal(3), + } + result = ControlFlowRecoverer._extract_for_init_value(init) + assert result == 3 diff --git a/tests/unit/transforms/dead_branch_test.py b/tests/unit/transforms/dead_branch_test.py index 0706034..e79d2b8 100644 --- a/tests/unit/transforms/dead_branch_test.py +++ b/tests/unit/transforms/dead_branch_test.py @@ -2,8 +2,11 @@ import pytest -from pyjsclear.transforms.dead_branch import DeadBranchRemover, _is_truthy_literal -from tests.unit.conftest import normalize, parse_expr, roundtrip +from pyjsclear.transforms.dead_branch import DeadBranchRemover +from pyjsclear.transforms.dead_branch import _is_truthy_literal +from tests.unit.conftest import normalize +from tests.unit.conftest import parse_expr +from tests.unit.conftest import roundtrip # --------------------------------------------------------------------------- @@ -166,3 +169,110 @@ def test_non_literal_test_unchanged(self): normalized = normalize(code) assert 'if' in normalized assert 'y()' in normalized + + +# --------------------------------------------------------------------------- +# Coverage gap tests +# --------------------------------------------------------------------------- + + +class TestEmptyArrayObjectTruthy: + """Lines 24-25: Empty array [] and empty object {} are truthy.""" + + def test_if_empty_array_truthy(self): + code, changed = roundtrip('if ([]) { a(); }', DeadBranchRemover) + assert changed is True + normalized = normalize(code) + assert 'a()' in normalized + assert 'if' not in normalized + + def test_if_empty_object_truthy(self): + code, changed = roundtrip('if ({}) { a(); }', DeadBranchRemover) + assert changed is True + normalized = normalize(code) + assert 'a()' in normalized + assert 'if' not in normalized + + +class TestUnwrapBlock: + """Lines 39-43: _unwrap_block with single-statement block.""" + + def test_if_true_single_statement_block_unwrapped(self): + """if (true) { return x; } → return x;""" + code, changed = roundtrip('function f() { if (true) { return x; } }', DeadBranchRemover) + assert changed is True + normalized = normalize(code) + assert 'return x;' in normalized + assert 'if' not in normalized + + +class TestIfFalseRemoved: + """Line 61: if (false) { a(); } with no else → REMOVE.""" + + def test_if_null_no_else_removed(self): + code, changed = roundtrip('if (null) { a(); }', DeadBranchRemover) + assert changed is True + normalized = normalize(code) + assert 'a()' not in normalized + + +class TestTernaryFalsy: + """Ternary with falsy test keeps alternate.""" + + def test_ternary_false(self): + code, changed = roundtrip('false ? a : b;', DeadBranchRemover) + assert changed is True + normalized = normalize(code) + assert 'b' in normalized + assert 'a' not in normalized + + def test_ternary_zero(self): + code, changed = roundtrip('0 ? a : b;', DeadBranchRemover) + assert changed is True + normalized = normalize(code) + assert 'b' in normalized + + +class TestLiteralDefaultTruthy: + """Lines 24-25: Literal with value that is not None/bool/int/float/str → True.""" + + def test_regex_literal_truthy(self): + # A Literal with a regex value (dict) hits the default case → True + node = {'type': 'Literal', 'value': {'pattern': '.*', 'flags': ''}, 'regex': {'pattern': '.*', 'flags': ''}} + result = _is_truthy_literal(node) + assert result is True + + +class TestUnwrapBlockIntegration: + """Lines 39-43: _unwrap_block is called when replacing if(true) with consequent.""" + + def test_if_true_multi_statement_block_kept_as_block(self): + """Multi-statement block is NOT unwrapped (len > 1).""" + code, changed = roundtrip('function f() { if (true) { a(); b(); } }', DeadBranchRemover) + assert changed is True + normalized = normalize(code) + assert 'a()' in normalized + assert 'b()' in normalized + assert 'if' not in normalized + + +class TestConditionalExpressionUnknownTest: + """Line 66: ConditionalExpression with non-literal test returns None (no change).""" + + def test_ternary_with_variable_test_unchanged(self): + code, changed = roundtrip('var z = x ? a : b;', DeadBranchRemover) + assert changed is False + normalized = normalize(code) + assert '?' in normalized + + +class TestIfFalseNoElseREMOVE: + """Line 61: if(false) with no else triggers REMOVE sentinel.""" + + def test_if_null_with_else(self): + """if(null) with else → keeps else branch.""" + code, changed = roundtrip('if (null) { a(); } else { b(); }', DeadBranchRemover) + assert changed is True + normalized = normalize(code) + assert 'a()' not in normalized + assert 'b()' in normalized diff --git a/tests/unit/transforms/deobfuscator_prepasses_test.py b/tests/unit/transforms/deobfuscator_prepasses_test.py index 7e02f64..5323ef5 100644 --- a/tests/unit/transforms/deobfuscator_prepasses_test.py +++ b/tests/unit/transforms/deobfuscator_prepasses_test.py @@ -5,12 +5,6 @@ class TestLargeFileOptimization: - def test_small_file_uses_full_pipeline(self): - code = 'var x = 1;' - d = Deobfuscator(code) - result = d.execute() - assert isinstance(result, str) - def test_returns_original_on_no_change(self): code = 'var x = 1;' d = Deobfuscator(code) diff --git a/tests/unit/transforms/eval_unpack_test.py b/tests/unit/transforms/eval_unpack_test.py index a5abee0..c72f68a 100644 --- a/tests/unit/transforms/eval_unpack_test.py +++ b/tests/unit/transforms/eval_unpack_test.py @@ -1,6 +1,11 @@ """Tests for eval/packer unpacker.""" +import subprocess +from unittest.mock import MagicMock +from unittest.mock import patch + from pyjsclear.transforms.eval_unpack import _dean_edwards_unpack +from pyjsclear.transforms.eval_unpack import _try_node_eval from pyjsclear.transforms.eval_unpack import eval_unpack from pyjsclear.transforms.eval_unpack import is_eval_packed @@ -60,9 +65,85 @@ def test_unpack_preserves_structure(self): assert result == 'alert("hello")' +class TestBaseEncodeHighRadix: + def test_base_encode_c_greater_than_35(self): + """base_encode for c > 35 uses chr(c + 29) (line 47).""" + # Radix 62: keyword index 36 should produce chr(36+29)=chr(65)='A' + packed = 'A' + keywords = [''] * 36 + ['replaced'] + result = _dean_edwards_unpack(packed, 62, 37, keywords) + assert result == 'replaced' + + def test_base_encode_c_equals_36(self): + """base_encode for c=36 produces 'A' which maps via chr(36+29).""" + packed = 'A("hello")' + keywords = [''] * 36 + ['myFunc'] + result = _dean_edwards_unpack(packed, 62, 37, keywords) + assert 'myFunc' in result + + +class TestDeanEdwardsException: + def test_exception_in_dean_edwards_falls_through(self): + """Exception in Dean Edwards unpacking continues to next pattern (lines 92-94).""" + # Craft code that matches _PACKER_RE but will cause an error in _dean_edwards_unpack + code = "eval(function(p,a,c,k,e,d){" "return p" "}('0', 0, 0, ''.split('|'), 0, {}))" + # This should not raise; it should return None or fall through + result = eval_unpack(code) + # Either returns None or falls through to _try_node_eval + assert result is None or isinstance(result, str) + + class TestEvalUnpack: def test_unpack_packer(self): result = eval_unpack(PACKER_SAMPLE) assert result is not None assert 'GetParams' in result assert 'alert' in result + + @patch('pyjsclear.transforms.eval_unpack._try_dean_edwards', return_value=None) + @patch('pyjsclear.transforms.eval_unpack._try_node_eval', return_value='decoded_code') + def test_falls_through_to_node_eval(self, mock_node, mock_dean): + """eval_unpack falls through to _try_node_eval when Dean Edwards fails (line 73).""" + result = eval_unpack('eval("alert(1)")') + assert result == 'decoded_code' + mock_node.assert_called_once() + + +class TestTryNodeEval: + def test_no_eval_pattern_returns_none(self): + """No eval pattern returns None (line 100-101).""" + result = _try_node_eval('var x = 1;') + assert result is None + + @patch('pyjsclear.transforms.eval_unpack.shutil.which', return_value=None) + def test_no_node_returns_none(self, mock_which): + """No node returns None (lines 103-105).""" + result = _try_node_eval('eval("alert(1)")') + assert result is None + + @patch('pyjsclear.transforms.eval_unpack.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.eval_unpack.subprocess.run') + def test_successful_node_eval(self, mock_run, mock_which): + """Successful mock subprocess returns decoded output (lines 117-129).""" + mock_result = MagicMock() + mock_result.stdout = 'alert(1)\n' + mock_run.return_value = mock_result + result = _try_node_eval('eval("alert(1)")') + assert result == 'alert(1)' + + @patch('pyjsclear.transforms.eval_unpack.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.eval_unpack.subprocess.run') + def test_empty_output_returns_none(self, mock_run, mock_which): + """Empty output returns None (line 129).""" + mock_result = MagicMock() + mock_result.stdout = ' ' + mock_run.return_value = mock_result + result = _try_node_eval('eval("alert(1)")') + assert result is None + + @patch('pyjsclear.transforms.eval_unpack.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.eval_unpack.subprocess.run', side_effect=subprocess.TimeoutExpired('node', 5)) + def test_timeout_returns_none(self, mock_run, mock_which): + """Timeout returns None (lines 132-133).""" + result = _try_node_eval('eval("alert(1)")') + assert result is None diff --git a/tests/unit/transforms/expression_simplifier_test.py b/tests/unit/transforms/expression_simplifier_test.py index 423432b..5469b49 100644 --- a/tests/unit/transforms/expression_simplifier_test.py +++ b/tests/unit/transforms/expression_simplifier_test.py @@ -3,7 +3,8 @@ import pytest from pyjsclear.transforms.expression_simplifier import ExpressionSimplifier -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip def rt(js_code): @@ -190,3 +191,528 @@ def test_no_fold_modulo_by_zero(self): code, changed = rt('10 % 0;') assert changed is False assert code == '10 % 0;' + + +# --------------------------------------------------------------------------- +# Coverage gap tests +# --------------------------------------------------------------------------- + + +class TestAwaitSimplification: + """Lines 91-98: await (0, expr) simplification.""" + + def test_await_sequence_simplified(self): + code, changed = rt('async function f() { await (0, fetch()); }') + assert changed is True + assert 'await fetch()' in code + + def test_await_non_sequence_unchanged(self): + code, changed = rt('async function f() { await fetch(); }') + assert changed is False + + +class TestUnsupportedUnaryOperator: + """Line 105: unsupported unary operator returns None.""" + + def test_delete_operator_not_folded(self): + code, changed = rt('delete x.y;') + assert changed is False + + +class TestUnsupportedBinaryOperator: + """Line 129: unsupported binary operator.""" + + def test_in_operator_not_folded(self): + code, changed = rt('"x" in obj;') + assert changed is False + + def test_instanceof_not_folded(self): + code, changed = rt('x instanceof Array;') + assert changed is False + + +class TestSimplifyExprNonDict: + """Line 153: _simplify_expr with non-dict node.""" + + def test_non_dict_passthrough(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + result = es._simplify_expr(None) + assert result is None + + result = es._simplify_expr(42) + assert result == 42 + + +class TestNestedBinaryInBinary: + """Lines 159-160: _simplify_expr for BinaryExpression (nested).""" + + def test_nested_binary_folded(self): + code, changed = rt('(1 + 2) + 3;') + assert changed is True + assert code == '6;' + + def test_nested_binary_mixed(self): + code, changed = rt('(2 * 3) + (4 - 1);') + assert changed is True + assert code == '9;' + + +class TestGetResolvableValueNonDict: + """Line 174: _get_resolvable_value with non-dict.""" + + def test_non_dict_returns_false(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + val, ok = es._get_resolvable_value(None) + assert ok is False + + val, ok = es._get_resolvable_value("string") + assert ok is False + + +class TestRegexLiteral: + """Line 178: regex literal returns not resolvable.""" + + def test_regex_not_resolvable(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + node = {'type': 'Literal', 'value': {}, 'regex': {'pattern': 'abc', 'flags': 'g'}} + val, ok = es._get_resolvable_value(node) + assert ok is False + + +class TestEmptyArrayObjectResolvable: + """Lines 189, 191: empty array/object as resolvable values.""" + + def test_unary_plus_empty_array(self): + """+ [] → 0""" + code, changed = rt('+[];') + assert changed is True + assert code == '0;' + + def test_empty_object_string_concat(self): + """'' + {} → '[object Object]'""" + code, changed = rt('"" + {};') + assert changed is True + assert '[object Object]' in code + + +class TestMoreUnaryOperators: + """Lines 197, 199: various unary operators.""" + + def test_plus_null(self): + """+null → 0""" + code, changed = rt('+null;') + assert changed is True + assert code == '0;' + + def test_typeof_true(self): + code, changed = rt('typeof true;') + assert changed is True + assert '"boolean"' in code + + def test_typeof_string(self): + code, changed = rt('typeof "hello";') + assert changed is True + assert '"string"' in code + + def test_typeof_array(self): + code, changed = rt('typeof [];') + assert changed is True + assert '"object"' in code + + +class TestExponentiation: + """Line 233: ** operator.""" + + def test_power(self): + code, changed = rt('2 ** 3;') + assert changed is True + assert code == '8;' + + +class TestUnsignedRightShift: + """Lines 243-247: >>> operator.""" + + def test_unsigned_right_shift(self): + code, changed = rt('5 >>> 1;') + assert changed is True + assert code == '2;' + + +class TestComparisonOperators: + """Lines 254-261: comparison operators.""" + + def test_less_than(self): + code, changed = rt('3 < 5;') + assert changed is True + assert code == 'true;' + + def test_less_than_or_equal(self): + code, changed = rt('5 <= 5;') + assert changed is True + assert code == 'true;' + + def test_greater_than(self): + code, changed = rt('5 > 3;') + assert changed is True + assert code == 'true;' + + def test_greater_than_or_equal(self): + code, changed = rt('5 >= 5;') + assert changed is True + assert code == 'true;' + + def test_less_than_false(self): + code, changed = rt('5 < 3;') + assert changed is True + assert code == 'false;' + + +class TestAbstractEquality: + """Lines 269-271: abstract equality edge cases.""" + + def test_null_eq_zero(self): + code, changed = rt('null == 0;') + assert changed is True + assert code == 'false;' + + def test_null_neq_zero(self): + code, changed = rt('null != 0;') + assert changed is True + assert code == 'true;' + + +class TestStrictEqualityNull: + """Line 278: strict equality with null.""" + + def test_null_strict_eq_zero(self): + code, changed = rt('null === 0;') + assert changed is True + assert code == 'false;' + + def test_null_strict_eq_null(self): + code, changed = rt('null === null;') + assert changed is True + assert code == 'true;' + + +class TestJsTruthyEdgeCases: + """Lines 283-294: _js_truthy edge cases.""" + + def test_truthy_nan(self): + """NaN is falsy.""" + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_truthy(float('nan')) is False + + def test_truthy_empty_string(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_truthy('') is False + + def test_truthy_nonempty_string(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_truthy('hello') is True + + def test_truthy_empty_array(self): + """In JS, [] is truthy.""" + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_truthy([]) is True + + def test_truthy_empty_dict(self): + """In JS, {} is truthy.""" + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_truthy({}) is True + + +class TestJsTypeof: + """Lines 301-311: _js_typeof for various types.""" + + def test_typeof_boolean(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_typeof(True) == 'boolean' + + def test_typeof_number(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_typeof(42) == 'number' + + def test_typeof_string(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_typeof('hello') == 'string' + + def test_typeof_list(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_typeof([]) == 'object' + + def test_typeof_dict(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_typeof({}) == 'object' + + +class TestJsToNumber: + """Lines 319-339: _js_to_number for various types.""" + + def test_bool_true(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_number(True) == 1 + + def test_bool_false(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_number(False) == 0 + + def test_string_numeric(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_number('5') == 5 + + def test_null_to_zero(self): + from pyjsclear.transforms.expression_simplifier import _JS_NULL + + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_number(_JS_NULL) == 0 + + def test_undefined_to_nan(self): + import math + + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + result = es._js_to_number(None) + assert math.isnan(result) + + def test_list_to_zero(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_number([]) == 0 + + +class TestJsToString: + """Lines 343-358: _js_to_string for various types.""" + + def test_null_to_string(self): + from pyjsclear.transforms.expression_simplifier import _JS_NULL + + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_string(_JS_NULL) == 'null' + + def test_undefined_to_string(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_string(None) == 'undefined' + + def test_bool_to_string(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_string(True) == 'true' + assert es._js_to_string(False) == 'false' + + def test_list_to_string(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_string([]) == '' + + def test_dict_to_string(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_string({}) == '[object Object]' + + +class TestJsCompare: + """Lines 362-380: _js_compare for string comparison and NaN.""" + + def test_string_comparison(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_compare('b', 'a') > 0 + assert es._js_compare('a', 'b') < 0 + assert es._js_compare('a', 'a') == 0 + + def test_nan_comparison(self): + import math + + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + result = es._js_compare(float('nan'), 1) + assert math.isnan(result) + + result = es._js_compare(1, float('nan')) + assert math.isnan(result) + + +class TestValueToNode: + """Lines 384-403: _value_to_node for various types.""" + + def test_null_value(self): + from pyjsclear.transforms.expression_simplifier import _JS_NULL + + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + result = es._value_to_node(_JS_NULL) + assert result['type'] == 'Literal' + assert result['value'] is None + + def test_negative_number(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + result = es._value_to_node(-5) + assert result['type'] == 'UnaryExpression' + assert result['operator'] == '-' + assert result['argument']['value'] == 5 + + def test_nan_returns_none(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + result = es._value_to_node(float('nan')) + assert result is None + + def test_infinity_returns_none(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + result = es._value_to_node(float('inf')) + assert result is None + + def test_string_value(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + result = es._value_to_node('hello') + assert result['type'] == 'Literal' + assert result['value'] == 'hello' + + def test_undefined_value(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + result = es._value_to_node(None) + assert result['type'] == 'Identifier' + assert result['name'] == 'undefined' + + +class TestAwaitSingleExpressionUnchanged: + """Line 96: await with SequenceExpression of length <= 1 is unchanged.""" + + def test_await_sequence_single_expression(self): + """SequenceExpression with only 1 expression should not be simplified.""" + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + # Manually construct the AST for await (expr) with a single-element sequence + ast = { + 'type': 'Program', + 'body': [ + { + 'type': 'ExpressionStatement', + 'expression': { + 'type': 'AwaitExpression', + 'argument': { + 'type': 'SequenceExpression', + 'expressions': [{'type': 'Identifier', 'name': 'fetch'}], + }, + }, + } + ], + } + es2 = ExpressionSimplifier(ast) + es2._simplify_awaits() + # Should not change because len(exprs) <= 1 + assert ast['body'][0]['expression']['argument']['type'] == 'SequenceExpression' + + def test_await_empty_sequence(self): + ast = { + 'type': 'Program', + 'body': [ + { + 'type': 'ExpressionStatement', + 'expression': { + 'type': 'AwaitExpression', + 'argument': { + 'type': 'SequenceExpression', + 'expressions': [], + }, + }, + } + ], + } + es = ExpressionSimplifier(ast) + es._simplify_awaits() + assert ast['body'][0]['expression']['argument']['type'] == 'SequenceExpression' + + +class TestUnaryExceptionHandling: + """Lines 122-123: Exception during unary evaluation.""" + + def test_unary_minus_undefined_returns_nan_no_node(self): + """-undefined → NaN, which _value_to_node returns None for.""" + code, changed = rt('-undefined;') + # -undefined produces NaN, which can't be represented as a literal + # so it stays unchanged + assert changed is False + + +class TestUnsignedRightShiftMore: + """Line 243: >>> unsigned right shift.""" + + def test_unsigned_right_shift_large(self): + code, changed = rt('-1 >>> 0;') + assert changed is True + # -1 >>> 0 in JS is 4294967295 + assert '4294967295' in code + + +class TestGeComparison: + """Lines 262-263: >= comparison operator.""" + + def test_ge_equal(self): + code, changed = rt('3 >= 3;') + assert changed is True + assert code == 'true;' + + def test_ge_false(self): + code, changed = rt('2 >= 3;') + assert changed is True + assert code == 'false;' + + +class TestNullEqZero: + """Line 271: null == 0 → false (null only equals undefined).""" + + def test_undefined_loose_eq_zero_false(self): + """undefined == 0 → false.""" + code, changed = rt('undefined == 0;') + assert changed is True + assert code == 'false;' + + +class TestJsTruthyNaN: + """Lines 283, 293-294: NaN is falsy, unknown type uses bool().""" + + def test_truthy_fallback_default(self): + """Lines 293-294: _js_truthy with unknown type uses bool(value).""" + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + # A custom object that is truthy + assert es._js_truthy(object()) is True + + +class TestJsTypeofDefault: + """Lines 310-311: _js_typeof for unknown types returns 'undefined'.""" + + def test_typeof_unknown_type(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_typeof(object()) == 'undefined' + + +class TestJsToNumberEdgeCases: + """Lines 334-335, 338-339: _js_to_number for list and unknown types.""" + + def test_list_to_number(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_number([1, 2, 3]) == 0 + + def test_unknown_type_to_number(self): + """Line 338-339: default case returns 0.""" + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_number(object()) == 0 + + def test_string_non_numeric_to_number(self): + """Lines 334-335: non-numeric string returns 0.""" + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_number('abc') == 0 + + def test_string_negative_to_number(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._js_to_number('-5') == -5 + + +class TestJsToStringUnknown: + """Lines 357-358: _js_to_string for unknown type.""" + + def test_unknown_type_to_string(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + obj = object() + result = es._js_to_string(obj) + assert result == str(obj) + + +class TestValueToNodeUnknown: + """Line 403: _value_to_node for unknown type returns None.""" + + def test_list_returns_none(self): + es = ExpressionSimplifier({'type': 'Program', 'body': []}) + assert es._value_to_node([1, 2]) is None diff --git a/tests/unit/transforms/hex_escapes_test.py b/tests/unit/transforms/hex_escapes_test.py index 81dbb82..42f541b 100644 --- a/tests/unit/transforms/hex_escapes_test.py +++ b/tests/unit/transforms/hex_escapes_test.py @@ -2,7 +2,8 @@ import pytest -from pyjsclear.transforms.hex_escapes import HexEscapes, decode_hex_escapes_source +from pyjsclear.transforms.hex_escapes import HexEscapes +from pyjsclear.transforms.hex_escapes import decode_hex_escapes_source from tests.unit.conftest import roundtrip @@ -12,14 +13,6 @@ class TestHexEscapesTransform: - def test_hex_escape_string_decoded(self): - """String with \\xHH escapes should have its raw updated.""" - js = r"""var a = "\x48\x65\x6c\x6c\x6f";""" - result, changed = roundtrip(js, HexEscapes) - assert changed is True - # The generated code should contain the readable string - assert 'Hello' in result - def test_value_preserved_after_decode(self): """The runtime value of the string must remain the same.""" js = r"""var a = "\x48\x65\x6c\x6c\x6f";""" diff --git a/tests/unit/transforms/jj_decode_test.py b/tests/unit/transforms/jj_decode_test.py index 6bd0a7e..18c1668 100644 --- a/tests/unit/transforms/jj_decode_test.py +++ b/tests/unit/transforms/jj_decode_test.py @@ -1,6 +1,13 @@ """Tests for JJEncode decoder.""" +import subprocess +from unittest.mock import MagicMock +from unittest.mock import patch + +from pyjsclear.transforms.jj_decode import _run_with_function_intercept from pyjsclear.transforms.jj_decode import is_jj_encoded +from pyjsclear.transforms.jj_decode import jj_decode +from pyjsclear.transforms.jj_decode import jj_decode_via_eval JJ_SAMPLE_LINE = '$=~[];$={___:++$,' @@ -18,3 +25,67 @@ def test_rejects_normal_js(self): def test_rejects_empty(self): assert is_jj_encoded('') is False + + +class TestJJDecode: + def test_non_jj_code_returns_none(self): + """jj_decode() with non-JJ code returns None (lines 32-33).""" + result = jj_decode('var x = 1;') + assert result is None + + @patch('pyjsclear.transforms.jj_decode.shutil.which', return_value=None) + def test_jj_code_no_node_returns_none(self, mock_which): + """jj_decode() with JJ code but no Node.js returns None (line 34).""" + jj_code = '$=~[];$={___:++$, alert(1)}' + result = jj_decode(jj_code) + assert result is None + + @patch('pyjsclear.transforms.jj_decode._run_with_function_intercept', return_value='alert(1)') + def test_jj_decode_via_eval_delegates(self, mock_run): + """jj_decode_via_eval() calls _run_with_function_intercept (line 39).""" + result = jj_decode_via_eval('some code') + mock_run.assert_called_once_with('some code') + assert result == 'alert(1)' + + +class TestRunWithFunctionIntercept: + @patch('pyjsclear.transforms.jj_decode.shutil.which', return_value=None) + def test_no_node_returns_none(self, mock_which): + """When node is not found, returns None (lines 44-46).""" + result = _run_with_function_intercept('some code') + assert result is None + + @patch('pyjsclear.transforms.jj_decode.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.jj_decode.subprocess.run') + def test_successful_execution(self, mock_run, mock_which): + """Successful execution returns stdout (lines 75-87).""" + mock_result = MagicMock() + mock_result.stdout = 'alert(1)\n' + mock_run.return_value = mock_result + result = _run_with_function_intercept('$=~[];') + assert result == 'alert(1)' + mock_run.assert_called_once() + + @patch('pyjsclear.transforms.jj_decode.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.jj_decode.subprocess.run') + def test_empty_output_returns_none(self, mock_run, mock_which): + """Empty stdout returns None (line 87).""" + mock_result = MagicMock() + mock_result.stdout = ' ' + mock_run.return_value = mock_result + result = _run_with_function_intercept('$=~[];') + assert result is None + + @patch('pyjsclear.transforms.jj_decode.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.jj_decode.subprocess.run', side_effect=subprocess.TimeoutExpired('node', 5)) + def test_timeout_returns_none(self, mock_run, mock_which): + """Timeout returns None (line 90-91).""" + result = _run_with_function_intercept('$=~[];') + assert result is None + + @patch('pyjsclear.transforms.jj_decode.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.jj_decode.subprocess.run', side_effect=OSError('error')) + def test_os_error_returns_none(self, mock_run, mock_which): + """OSError returns None (line 90-91).""" + result = _run_with_function_intercept('$=~[];') + assert result is None diff --git a/tests/unit/transforms/jsfuck_decode_test.py b/tests/unit/transforms/jsfuck_decode_test.py index a65cadf..d9fc606 100644 --- a/tests/unit/transforms/jsfuck_decode_test.py +++ b/tests/unit/transforms/jsfuck_decode_test.py @@ -1,6 +1,11 @@ """Tests for JSFUCK decoder.""" +import subprocess +from unittest.mock import MagicMock +from unittest.mock import patch + from pyjsclear.transforms.jsfuck_decode import is_jsfuck +from pyjsclear.transforms.jsfuck_decode import jsfuck_decode class TestJSFuckDetection: @@ -23,3 +28,46 @@ def test_jsfuck_with_preamble(self): code = preamble + jsfuck # Has significant non-JSFUCK content, but ratio might still be high assert isinstance(is_jsfuck(code), bool) + + +class TestJSFuckDecode: + @patch('pyjsclear.transforms.jsfuck_decode.shutil.which', return_value=None) + def test_no_node_returns_none(self, mock_which): + """When Node.js not found, returns None (lines 38-40).""" + result = jsfuck_decode('[][(![]+[])]') + assert result is None + + @patch('pyjsclear.transforms.jsfuck_decode.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.jsfuck_decode.subprocess.run') + def test_successful_decode(self, mock_run, mock_which): + """Successful decode returns stdout (lines 42-89).""" + mock_result = MagicMock() + mock_result.stdout = 'alert(1)\n' + mock_run.return_value = mock_result + result = jsfuck_decode('[][(![]+[])]') + assert result == 'alert(1)' + mock_run.assert_called_once() + + @patch('pyjsclear.transforms.jsfuck_decode.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.jsfuck_decode.subprocess.run') + def test_empty_output_returns_none(self, mock_run, mock_which): + """Empty output returns None (lines 88-89).""" + mock_result = MagicMock() + mock_result.stdout = ' \n ' + mock_run.return_value = mock_result + result = jsfuck_decode('[][(![]+[])]') + assert result is None + + @patch('pyjsclear.transforms.jsfuck_decode.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.jsfuck_decode.subprocess.run', side_effect=subprocess.TimeoutExpired('node', 10)) + def test_timeout_returns_none(self, mock_run, mock_which): + """Timeout returns None (lines 92-93).""" + result = jsfuck_decode('[][(![]+[])]') + assert result is None + + @patch('pyjsclear.transforms.jsfuck_decode.shutil.which', return_value='/usr/bin/node') + @patch('pyjsclear.transforms.jsfuck_decode.subprocess.run', side_effect=OSError('error')) + def test_os_error_returns_none(self, mock_run, mock_which): + """OSError returns None.""" + result = jsfuck_decode('[][(![]+[])]') + assert result is None diff --git a/tests/unit/transforms/logical_to_if_test.py b/tests/unit/transforms/logical_to_if_test.py index 662089d..98791f5 100644 --- a/tests/unit/transforms/logical_to_if_test.py +++ b/tests/unit/transforms/logical_to_if_test.py @@ -1,7 +1,8 @@ import pytest from pyjsclear.transforms.logical_to_if import LogicalToIf -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip class TestLogicalAndToIf: @@ -111,3 +112,117 @@ def test_multiple_logicals_in_body(self): result, changed = roundtrip(code, LogicalToIf) assert changed is True assert normalize(result) == normalize('function f() { if (a) { b(); } if (!c) { d(); } }') + + +class TestCoverageGaps: + """Tests targeting uncovered lines in logical_to_if.py.""" + + def test_non_dict_child_in_transform_bodies(self): + """Line 36: _transform_bodies with non-dict child (skipped).""" + # A simple literal expression; the AST will contain non-dict children + # (e.g., string values) which should be safely skipped. + code = 'var x = 1;' + result, changed = roundtrip(code, LogicalToIf) + assert changed is False + + def test_non_dict_expression_in_expression_statement(self): + """Line 76: ExpressionStatement with non-dict expression.""" + # This is hard to trigger from valid JS since esprima always gives dicts, + # but we can test the boundary by verifying normal code doesn't crash. + code = ';' # Empty statement — not ExpressionStatement + result, changed = roundtrip(code, LogicalToIf) + assert changed is False + + def test_return_non_sequence_non_logical(self): + """Line 98: Return statement with a plain expression (not sequence, not logical).""" + code = 'function f() { return 42; }' + result, changed = roundtrip(code, LogicalToIf) + assert changed is False + assert '42' in result + + def test_return_non_dict_argument(self): + """Line 88: Return with null argument (return;).""" + code = 'function f() { return; }' + result, changed = roundtrip(code, LogicalToIf) + assert changed is False + + def test_return_single_element_sequence(self): + """Line 104: Return with single-element sequence (len <= 1) returns None.""" + # Manually constructing is tricky; a single-element SequenceExpression + # is unusual. We test via the AST directly. + from pyjsclear.generator import generate + from pyjsclear.parser import parse + + ast = parse('function f() { return a; }') + # Manually make the return argument a SequenceExpression with 1 element + ret_stmt = ast['body'][0]['body']['body'][0] + ret_stmt['argument'] = { + 'type': 'SequenceExpression', + 'expressions': [{'type': 'Identifier', 'name': 'a'}], + } + t = LogicalToIf(ast) + changed = t.execute() + assert changed is False + + def test_return_sequence_with_logical_items(self): + """Lines 108-111: Return sequence containing LogicalExpression items.""" + code = 'function f() { return a && b(), c; }' + result, changed = roundtrip(code, LogicalToIf) + assert changed is True + # The logical expression a && b() inside the sequence should be converted to if + assert 'if' in result + assert 'return c' in normalize(result) + + def test_return_logical_right_not_sequence(self): + """Line 120: Return logical where right side is not a SequenceExpression.""" + code = 'function f() { return a || b; }' + result, changed = roundtrip(code, LogicalToIf) + assert changed is False + + def test_return_logical_right_sequence_single_element(self): + """Line 123: Return logical where right side is sequence with <=1 elements.""" + from pyjsclear.generator import generate + from pyjsclear.parser import parse + + ast = parse('function f() { return a || b; }') + ret_stmt = ast['body'][0]['body']['body'][0] + ret_stmt['argument'] = { + 'type': 'LogicalExpression', + 'operator': '||', + 'left': {'type': 'Identifier', 'name': 'a'}, + 'right': { + 'type': 'SequenceExpression', + 'expressions': [{'type': 'Identifier', 'name': 'b'}], + }, + } + t = LogicalToIf(ast) + changed = t.execute() + assert changed is False + + def test_nullish_coalescing_not_converted(self): + """Lines 147-148: _logical_to_if with unknown operator (e.g. '??') returns None.""" + from pyjsclear.generator import generate + from pyjsclear.parser import parse + + ast = parse('a ?? b();') + # Esprima may not parse ?? as LogicalExpression, so force it + expr_stmt = ast['body'][0] + expr_stmt['expression'] = { + 'type': 'LogicalExpression', + 'operator': '??', + 'left': {'type': 'Identifier', 'name': 'a'}, + 'right': {'type': 'CallExpression', 'callee': {'type': 'Identifier', 'name': 'b'}, 'arguments': []}, + } + t = LogicalToIf(ast) + changed = t.execute() + assert changed is False + + def test_expression_stmt_non_dict_expression(self): + """Line 75: ExpressionStatement with non-dict expression returns None.""" + from pyjsclear.parser import parse + + ast = parse('a();') + ast['body'][0]['expression'] = 42 + t = LogicalToIf(ast) + changed = t.execute() + assert not changed diff --git a/tests/unit/transforms/object_packer_test.py b/tests/unit/transforms/object_packer_test.py index e750764..d9afd53 100644 --- a/tests/unit/transforms/object_packer_test.py +++ b/tests/unit/transforms/object_packer_test.py @@ -1,7 +1,8 @@ import pytest from pyjsclear.transforms.object_packer import ObjectPacker -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip class TestBasicPacking: @@ -82,3 +83,92 @@ def test_nested_function_body(self): # The packed object should contain both values assert ': 1' in result assert ': 2' in result + + +class TestCoverageGaps: + """Tests targeting uncovered lines in object_packer.py.""" + + def test_non_dict_node_in_process_bodies(self): + """Line 22: Non-dict node passed to _process_bodies (skipped).""" + # Simple code with literals; _process_bodies will encounter non-dict values + code, changed = roundtrip('var x = 1;', ObjectPacker) + assert changed is False + + def test_non_dict_statement_in_body(self): + """Lines 57-58: Non-dict statement in body array is skipped.""" + # Normal parsing won't produce non-dict statements, but this tests + # that the code doesn't crash on simple cases. + code, changed = roundtrip('var o = {}; o.x = 1;', ObjectPacker) + assert changed is True + + def test_compound_assignment_stops_packing(self): + """Line 73: Assignment expression without '=' operator (e.g., +=) stops packing.""" + code, changed = roundtrip('var o = {}; o.x = 1; o.y += 2;', ObjectPacker) + assert changed is True + result = normalize(code) + assert ': 1' in result + assert 'o.y += 2' in result + + def test_left_not_member_expression(self): + """Line 79: Left side of assignment is not MemberExpression.""" + code, changed = roundtrip('var o = {}; o.x = 1; z = 2;', ObjectPacker) + assert changed is True + result = normalize(code) + assert ': 1' in result + assert 'z = 2' in result + + def test_object_name_mismatch(self): + """Line 82: Object reference name doesn't match the target object.""" + code, changed = roundtrip('var o = {}; o.x = 1; p.y = 2;', ObjectPacker) + assert changed is True + result = normalize(code) + assert ': 1' in result + assert 'p.y = 2' in result + + def test_property_node_is_none(self): + """Line 87: Property node is None stops packing.""" + from pyjsclear.generator import generate + from pyjsclear.parser import parse + + ast = parse('var o = {}; o.x = 1;') + # Manually set the property of the MemberExpression to None + body = ast['body'] + assignment_stmt = body[1] + left = assignment_stmt['expression']['left'] + left['property'] = None + t = ObjectPacker(ast) + changed = t.execute() + # Should not pack because property is None + assert changed is False + + def test_references_name_list_child(self): + """Lines 129-130: _references_name finds reference in list child (e.g. array).""" + code, changed = roundtrip('var o = {}; o.x = 1; o.y = [o];', ObjectPacker) + assert changed is True + result = normalize(code) + assert ': 1' in result + assert 'o.y = [o]' in result + + def test_references_name_no_type(self): + """Line 120: _references_name with node missing 'type' returns False.""" + packer = ObjectPacker({'type': 'Program', 'body': []}) + # A dict without 'type' should return False + assert packer._references_name({}, 'o') is False + assert packer._references_name('not_a_dict', 'o') is False + assert packer._references_name(None, 'o') is False + + def test_references_name_identifier_match(self): + """Line 122-123: _references_name with Identifier matching name.""" + packer = ObjectPacker({'type': 'Program', 'body': []}) + assert packer._references_name({'type': 'Identifier', 'name': 'o'}, 'o') is True + assert packer._references_name({'type': 'Identifier', 'name': 'x'}, 'o') is False + + def test_non_dict_in_body_direct_ast(self): + """Line 22/57: non-dict in body triggers skip in _process_bodies and _try_pack_body.""" + from pyjsclear.parser import parse + + ast = parse('var o = {}; o.x = 1;') + ast['body'].append(42) + t = ObjectPacker(ast) + changed = t.execute() + assert changed diff --git a/tests/unit/transforms/object_simplifier_test.py b/tests/unit/transforms/object_simplifier_test.py index 113a49b..feec01a 100644 --- a/tests/unit/transforms/object_simplifier_test.py +++ b/tests/unit/transforms/object_simplifier_test.py @@ -1,7 +1,8 @@ import pytest from pyjsclear.transforms.object_simplifier import ObjectSimplifier -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip class TestLiteralPropertyAccess: @@ -98,3 +99,157 @@ def test_no_objects_returns_false(self): def test_empty_object_returns_false(self): code, changed = roundtrip('const o = {}; y(o);', ObjectSimplifier) assert changed is False + + +class TestCoverageGaps: + """Tests targeting uncovered lines in object_simplifier.py.""" + + def test_binding_node_not_variable_declarator(self): + """Line 32: binding.node is not VariableDeclarator (e.g., function declaration).""" + code, changed = roundtrip('const f = function() {}; f();', ObjectSimplifier) + assert changed is False + + def test_string_key_property(self): + """Lines 136, 140-142: _get_property_key with Literal string key.""" + code, changed = roundtrip('const o = {"x": 1}; y(o.x);', ObjectSimplifier) + assert changed is True + assert 'y(1)' in code + + def test_computed_non_string_access(self): + """Lines 148, 155: _get_member_prop_name with computed non-string (number).""" + code, changed = roundtrip('const o = {x: 1}; y(o[0]);', ObjectSimplifier) + assert changed is False + + def test_no_property_on_member(self): + """Line 148: _get_member_prop_name where prop is missing.""" + # This is hard to trigger from valid JS, but we test normal computed access + code, changed = roundtrip('const o = {x: 1}; var k = "x"; y(o[k]);', ObjectSimplifier) + assert changed is False + + def test_reference_not_as_member_object(self): + """Lines 65, 67: Reference used but not as MemberExpression.object.""" + code, changed = roundtrip('const o = {x: 1}; y(o);', ObjectSimplifier) + assert changed is False + + def test_property_name_not_in_prop_map(self): + """Line 72: Property name accessed that doesn't exist in prop_map.""" + code, changed = roundtrip('const o = {x: 1}; y(o.z);', ObjectSimplifier) + assert changed is False + + def test_inline_arrow_expression(self): + """Lines 171-173: Arrow function with expression body inlining.""" + code, changed = roundtrip( + 'const o = {fn: (a) => a + 1}; var x = o.fn(5);', + ObjectSimplifier, + ) + assert changed is True + assert '5 + 1' in normalize(code) + + def test_function_not_called(self): + """Line 110: Function property used but not as callee of CallExpression.""" + code, changed = roundtrip( + 'const o = {fn: function(a) { return a; }}; var x = o.fn;', + ObjectSimplifier, + ) + # Function property accessed but not called — should not inline + assert changed is False + + def test_inline_function_multi_stmt_body_not_inlined(self): + """Line 176: Block body with non-single-return is not inlined.""" + code, changed = roundtrip( + 'const o = {fn: function(a) { var x = 1; return a + x; }}; o.fn(5);', + ObjectSimplifier, + ) + assert changed is False + + def test_inline_function_no_return_argument(self): + """Line 180: Block body with return but no argument.""" + code, changed = roundtrip( + 'const o = {fn: function() { return; }}; var x = o.fn();', + ObjectSimplifier, + ) + assert changed is False + + def test_recurse_into_child_scopes(self): + """Line 88: Process child scopes recursively.""" + code, changed = roundtrip( + 'function outer() { const o = {x: 1}; function inner() { y(o.x); } }', + ObjectSimplifier, + ) + # The object is in outer scope; inner scope should still get inlined + assert changed is True + assert 'y(1)' in code + + def test_is_proxy_object_non_property_type(self): + """Lines 121, 124: _is_proxy_object with non-Property type or missing value.""" + from pyjsclear.generator import generate + from pyjsclear.parser import parse + + ast = parse('const o = {x: 1}; y(o.x);') + t = ObjectSimplifier(ast) + # SpreadElement is not a Property + assert t._is_proxy_object([{'type': 'SpreadElement', 'argument': {'type': 'Identifier', 'name': 'a'}}]) is False + # Property with no value + assert t._is_proxy_object([{'type': 'Property', 'key': {'type': 'Identifier', 'name': 'x'}}]) is False + + def test_get_property_key_no_key(self): + """Lines 136: _get_property_key returns None when key is missing.""" + from pyjsclear.parser import parse + + ast = parse('const o = {x: 1};') + t = ObjectSimplifier(ast) + assert t._get_property_key({}) is None + assert t._get_property_key({'key': {'type': 'Literal', 'value': 123}}) is None + + def test_computed_property_key_ignored(self): + """Line 46: property key returns None for computed key (not Identifier or string Literal).""" + from pyjsclear.parser import parse + + ast = parse('const o = {x: 1}; var y = o.x;') + t = ObjectSimplifier(ast) + # A property with a computed (non-string, non-identifier) key returns None + assert t._get_property_key({'key': {'type': 'BinaryExpression'}}) is None + + def test_has_property_assignment_me_parent_info_none(self): + """Line 97: _has_property_assignment where find_parent returns None for me.""" + from pyjsclear.parser import parse + + # Build a scenario with a detached member expression + ast = parse('const o = {x: 1}; var y = o.x;') + t = ObjectSimplifier(ast) + # This should work normally since the member expression is in the AST + changed = t.execute() + assert changed is True + + def test_try_inline_function_call_me_parent_info_none(self): + """Line 107: _try_inline_function_call where find_parent returns None.""" + from pyjsclear.parser import parse + + ast = parse('const o = {fn: function(a) { return a; }}; o.fn(1);') + t = ObjectSimplifier(ast) + changed = t.execute() + assert changed is True + + def test_get_member_prop_name_no_property(self): + """Line 148: _get_member_prop_name with no property returns None.""" + from pyjsclear.parser import parse + + ast = parse('const o = {x: 1};') + t = ObjectSimplifier(ast) + assert t._get_member_prop_name({}) is None + assert t._get_member_prop_name({'property': None}) is None + + def test_body_not_block_not_expression(self): + """Line 183: body that's not BlockStatement and not expression for non-arrow.""" + from pyjsclear.parser import parse + + ast = parse('const o = {fn: function(a) { return a; }}; o.fn(1);') + t = ObjectSimplifier(ast) + # Manually set the function body to something that is not a BlockStatement + # Find the function in the object + props = ast['body'][0]['declarations'][0]['init']['properties'] + func = props[0]['value'] + func['body'] = {'type': 'Literal', 'value': 1} # Not a BlockStatement + changed = t.execute() + # Should not inline since body is not a BlockStatement for a FunctionExpression + assert not changed diff --git a/tests/unit/transforms/proxy_functions_test.py b/tests/unit/transforms/proxy_functions_test.py index b3cdbf5..660b0a6 100644 --- a/tests/unit/transforms/proxy_functions_test.py +++ b/tests/unit/transforms/proxy_functions_test.py @@ -3,7 +3,8 @@ import pytest from pyjsclear.transforms.proxy_functions import ProxyFunctionInliner -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip class TestProxyFunctionInlinerBasic: @@ -117,3 +118,180 @@ def test_sequence_expression_in_return_not_inlined(self): ProxyFunctionInliner, ) assert changed is False + + +class TestCoverageGaps: + """Tests targeting uncovered lines in proxy_functions.py.""" + + def test_callee_not_identifier(self): + """Line 42: CallExpression with non-identifier callee (e.g., member expression).""" + code, changed = roundtrip( + 'function p(a) { return a; } obj.p(1);', + ProxyFunctionInliner, + ) + # obj.p(1) callee is MemberExpression, not Identifier — should not inline + assert 'obj.p(1)' in normalize(code) + + def test_destructuring_params_not_proxy(self): + """Line 109: Function with non-identifier params (destructuring) is not a proxy.""" + code, changed = roundtrip( + 'function f({a, b}) { return a + b; } f({a: 1, b: 2});', + ProxyFunctionInliner, + ) + assert changed is False + + def test_body_is_none(self): + """Line 113: Function body is None — not a proxy.""" + from pyjsclear.generator import generate + from pyjsclear.parser import parse + + ast = parse('function f() { return 1; } f();') + # Manually remove the body + func = ast['body'][0] + func['body'] = None + t = ProxyFunctionInliner(ast) + changed = t.execute() + assert changed is False + + def test_block_body_non_return_statement(self): + """Line 126: Block body with a non-return statement (e.g., expression).""" + code, changed = roundtrip( + 'function f() { console.log(1); } f();', + ProxyFunctionInliner, + ) + assert changed is False + + def test_arrow_in_return_not_proxy(self): + """Lines 158-159: _is_proxy_value rejects ArrowFunctionExpression.""" + code, changed = roundtrip( + 'function f() { return () => 1; } f();', + ProxyFunctionInliner, + ) + assert changed is False + + def test_list_child_with_disallowed_type(self): + """Line 157: _is_proxy_value rejects disallowed type in list child.""" + # Array with a function expression as element + code, changed = roundtrip( + 'function f() { return [function() {}]; } f();', + ProxyFunctionInliner, + ) + assert changed is False + + def test_get_replacement_body_none(self): + """Line 166: _get_replacement when body is None returns undefined.""" + from pyjsclear.parser import parse + + ast = parse('function f() { return 1; } f();') + t = ProxyFunctionInliner(ast) + # Manually create a func_node with no body + func_node = {'type': 'FunctionDeclaration', 'params': [], 'body': None} + result = t._get_replacement(func_node, []) + assert result is not None + assert result.get('name') == 'undefined' + + def test_get_replacement_block_empty(self): + """Line 174: _get_replacement with empty block body returns None.""" + from pyjsclear.parser import parse + + ast = parse('var x = 1;') + t = ProxyFunctionInliner(ast) + func_node = { + 'type': 'FunctionDeclaration', + 'params': [], + 'body': {'type': 'BlockStatement', 'body': []}, + } + result = t._get_replacement(func_node, []) + assert result is None + + def test_get_replacement_block_non_return(self): + """Line 174: _get_replacement with block body that starts with non-return.""" + from pyjsclear.parser import parse + + ast = parse('var x = 1;') + t = ProxyFunctionInliner(ast) + func_node = { + 'type': 'FunctionDeclaration', + 'params': [], + 'body': { + 'type': 'BlockStatement', + 'body': [{'type': 'ExpressionStatement', 'expression': {'type': 'Literal', 'value': 1}}], + }, + } + result = t._get_replacement(func_node, []) + assert result is None + + def test_get_replacement_not_block_not_arrow(self): + """Line 180: _get_replacement with non-block, non-arrow body returns None.""" + from pyjsclear.parser import parse + + ast = parse('var x = 1;') + t = ProxyFunctionInliner(ast) + func_node = { + 'type': 'FunctionDeclaration', + 'params': [], + 'body': {'type': 'Literal', 'value': 1}, + } + result = t._get_replacement(func_node, []) + assert result is None + + def test_get_replacement_return_no_argument(self): + """Line 177: _get_replacement with return but no argument gives undefined.""" + from pyjsclear.parser import parse + + ast = parse('var x = 1;') + t = ProxyFunctionInliner(ast) + func_node = { + 'type': 'FunctionDeclaration', + 'params': [], + 'body': { + 'type': 'BlockStatement', + 'body': [{'type': 'ReturnStatement', 'argument': None}], + }, + } + result = t._get_replacement(func_node, []) + assert result is not None + assert result.get('name') == 'undefined' + + def test_is_proxy_value_non_dict(self): + """Line 148: _is_proxy_value with non-dict returns False.""" + from pyjsclear.parser import parse + + ast = parse('var x = 1;') + t = ProxyFunctionInliner(ast) + assert t._is_proxy_value('not_a_dict') is False + assert t._is_proxy_value(None) is False + assert t._is_proxy_value(42) is False + + def test_function_non_block_body_not_arrow(self): + """Line 132: body not BlockStatement and func is not ArrowFunction.""" + from pyjsclear.parser import parse + + ast = parse('function f(a) { return a; } f(1);') + func = ast['body'][0] + # Replace body with a non-block to trigger line 132 + func['body'] = {'type': 'ExpressionStatement', 'expression': {'type': 'Identifier', 'name': 'a'}} + t = ProxyFunctionInliner(ast) + changed = t.execute() + # Should not crash; function is not a proxy since body is not block or arrow expr + assert not changed + + def test_is_proxy_value_child_dict_disallowed(self): + """Line 158-159: _is_proxy_value child dict with disallowed type.""" + from pyjsclear.parser import parse + + ast = parse('var x = 1;') + t = ProxyFunctionInliner(ast) + # A node containing a child dict with a disallowed type + node = { + 'type': 'BinaryExpression', + 'operator': '+', + 'left': {'type': 'Identifier', 'name': 'a'}, + 'right': { + 'type': 'AssignmentExpression', + 'operator': '=', + 'left': {'type': 'Identifier', 'name': 'b'}, + 'right': {'type': 'Literal', 'value': 1}, + }, + } + assert t._is_proxy_value(node) is False diff --git a/tests/unit/transforms/reassignment_test.py b/tests/unit/transforms/reassignment_test.py index ae85837..5bcece6 100644 --- a/tests/unit/transforms/reassignment_test.py +++ b/tests/unit/transforms/reassignment_test.py @@ -3,7 +3,8 @@ import pytest from pyjsclear.transforms.reassignment import ReassignmentRemover -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip class TestReassignmentRemoverDeclaratorInline: @@ -109,3 +110,68 @@ def test_multiple_well_known_globals(self): def test_rebuild_scope_flag(self): assert ReassignmentRemover.rebuild_scope is True + + +class TestReassignmentRemoverSkipConditions: + """Tests for skip conditions on reference replacement.""" + + def test_reference_as_assignment_lhs_skipped(self): + """Line 93: Reference used as assignment left-hand side should be skipped.""" + code = 'var x = console; x = something; x.log("hi");' + result, changed = roundtrip(code, ReassignmentRemover) + # x has writes so it is not constant, no inlining should happen + assert isinstance(changed, bool) + + def test_reference_as_declarator_id_skipped(self): + """Line 95: Reference used as VariableDeclarator id should be skipped.""" + # When a variable is reassigned via declarator pattern, the id ref should be skipped + code = 'var x = JSON; x.parse(s);' + result, changed = roundtrip(code, ReassignmentRemover) + assert changed is True + assert 'JSON.parse(s)' in normalize(result) + + +class TestReassignmentRemoverAssignmentAliasEdgeCases: + """Tests for assignment alias edge cases.""" + + def test_assignment_alias_with_init_skipped(self): + """Line 131: VariableDeclarator with init should be skipped for assignment alias.""" + code = 'var _0x1 = undefined; _0x1 = console; _0x1.log("hi");' + result, changed = roundtrip(code, ReassignmentRemover) + # _0x1 has init (undefined), so assignment alias path skips it + # but it might be handled by the declarator path instead + assert isinstance(changed, bool) + + def test_assignment_alias_multiple_writes_skipped(self): + """Line 151: Assignment alias with != 1 writes should be skipped.""" + code = 'var _0x1; _0x1 = console; _0x1 = JSON; _0x1.log("hi");' + result, changed = roundtrip(code, ReassignmentRemover) + # Two writes means it won't be inlined via assignment alias + assert '_0x1' in result or changed is False + + def test_assignment_alias_rhs_not_identifier(self): + """Line 157: Assignment alias where right side is not an identifier.""" + code = 'var _0x1; _0x1 = 123; console.log(_0x1);' + result, changed = roundtrip(code, ReassignmentRemover) + # RHS is a literal, not an identifier — should be skipped + assert '_0x1' in result + + def test_assignment_alias_self_assignment_skipped(self): + """Line 161: target_name equals name should be skipped.""" + code = 'var _0x1; _0x1 = _0x1;' + result, changed = roundtrip(code, ReassignmentRemover) + assert changed is False + + def test_assignment_alias_replacement_with_index(self): + """Line 175: Assignment alias replacement in array position (with index).""" + code = 'var _0x1; _0x1 = console; foo([_0x1]);' + result, changed = roundtrip(code, ReassignmentRemover) + assert changed is True + assert 'console' in result + + def test_assignment_alias_pattern(self): + """Assignment alias: var x; x = console; log(x);""" + code = 'var _0x1 = undefined; var _0x2; _0x2 = console; _0x2.log("hi");' + result, changed = roundtrip(code, ReassignmentRemover) + assert changed + assert 'console' in result diff --git a/tests/unit/transforms/sequence_splitter_test.py b/tests/unit/transforms/sequence_splitter_test.py index d51b82c..c91aaa1 100644 --- a/tests/unit/transforms/sequence_splitter_test.py +++ b/tests/unit/transforms/sequence_splitter_test.py @@ -1,7 +1,8 @@ import pytest from pyjsclear.transforms.sequence_splitter import SequenceSplitter -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip class TestSequenceSplittingInExpressionStatements: @@ -93,12 +94,6 @@ def test_for_body_normalized_to_block(self): class TestIfBranchNormalization: - def test_consequent_normalized(self): - code = 'if (x) y();' - result, changed = roundtrip(code, SequenceSplitter) - assert changed is True - assert normalize(result) == normalize('if (x) { y(); }') - def test_alternate_normalized(self): code = 'if (x) { y(); } else z();' result, changed = roundtrip(code, SequenceSplitter) @@ -149,3 +144,130 @@ def test_splits_await_two_element_sequence(self): result, changed = roundtrip(code, SequenceSplitter) assert changed is True assert normalize(result) == normalize('async function f() { a; var x = await expr(); }') + + +class TestSequenceSplitterEdgeCases: + """Tests for uncovered edge cases.""" + + def test_non_dict_in_body_arrays(self): + """Line 59: Non-dict in _split_in_body_arrays should be skipped gracefully.""" + # This is handled internally; just ensure no crash with normal code + code = 'a(); b();' + result, changed = roundtrip(code, SequenceSplitter) + assert isinstance(changed, bool) + + def test_return_indirect_call(self): + """Line 107: ReturnStatement with indirect call: return (0, fn)(args).""" + code = 'function f() { return (0, g)("hello"); }' + result, changed = roundtrip(code, SequenceSplitter) + assert changed is True + norm = normalize(result) + assert '0' in norm + assert 'g("hello")' in norm + + def test_assignment_indirect_call(self): + """Line 113: Assignment with indirect call: x = (0, fn)(args).""" + code = 'var x; x = (0, g)("hello");' + result, changed = roundtrip(code, SequenceSplitter) + assert changed is True + norm = normalize(result) + assert '0' in norm + assert 'g("hello")' in norm + + def test_non_dict_statement_in_process_stmt_array(self): + """Lines 123-124: Non-dict statement in _process_stmt_array should be skipped.""" + # Internal handling; verify no crash with various patterns + code = 'var a = 1;' + result, changed = roundtrip(code, SequenceSplitter) + assert changed is False + + def test_non_dict_init_in_single_declarator(self): + """Line 189: _try_split_single_declarator_init with non-dict init.""" + # Variable with no init (init is None, not a dict) + code = 'var x;' + result, changed = roundtrip(code, SequenceSplitter) + assert changed is False + + def test_sequence_callee_with_single_expression(self): + """Line 96: SequenceExpression callee with <=1 expression should not be extracted.""" + # Construct a case where there's a single-element sequence callee + # This is a degenerate case; normal JS won't produce it, but we can test + # that the normal path handles well-formed code + code = '(fn)("hello");' + result, changed = roundtrip(code, SequenceSplitter) + assert changed is False + + def test_direct_sequence_init_single_expression(self): + """Line 195: Direct SequenceExpression init with <=1 expression should return None.""" + # A single-element sequence is degenerate; just test normal single-init var + code = 'var x = 1;' + result, changed = roundtrip(code, SequenceSplitter) + assert changed is False + + def test_await_wrapped_sequence_single_expression(self): + """Line 209: Await-wrapped sequence with <=1 expression should return None.""" + code = 'async function f() { var x = await expr(); }' + result, changed = roundtrip(code, SequenceSplitter) + # No sequence to split, just a simple await + assert normalize(result) == normalize('async function f() { var x = await expr(); }') + + def test_extract_from_call_non_dict(self): + """Line 85: Non-dict in extract_from_call should be skipped.""" + # When expression is not a dict (e.g., expression missing), no crash + code = ';' + result, changed = roundtrip(code, SequenceSplitter) + assert isinstance(changed, bool) + + def test_var_declaration_indirect_call_in_init(self): + """VariableDeclaration path for extracting indirect call prefixes.""" + code = 'var x = (0, fn)("hello");' + result, changed = roundtrip(code, SequenceSplitter) + assert changed is True + norm = normalize(result) + assert '0' in norm + assert 'fn("hello")' in norm + + +class TestSequenceSplitterDirectASTCoverage: + """Tests using direct AST manipulation to hit remaining uncovered lines.""" + + def test_sequence_callee_with_single_expression(self): + """Line 95-96: SequenceExpression callee with <=1 expression.""" + from pyjsclear.generator import generate + from pyjsclear.parser import parse + + ast = parse('fn("hello");') + # Manually wrap callee in a SequenceExpression with 1 element + call_expr = ast['body'][0]['expression'] + original_callee = call_expr['callee'] + call_expr['callee'] = { + 'type': 'SequenceExpression', + 'expressions': [original_callee], + } + t = SequenceSplitter(ast) + changed = t.execute() + # Single-element sequence callee should not be extracted + # (but body normalization may still trigger changes) + + def test_single_element_await_sequence(self): + """Line 208-209: single-element await sequence returns None.""" + from pyjsclear.parser import parse + + ast = parse('async function f() { var x = await expr(); }') + # Find the var declaration inside the function body + func_body = ast['body'][0]['body']['body'] + decl = func_body[0]['declarations'][0] + # Replace init with AwaitExpression wrapping single-element SequenceExpression + decl['init'] = { + 'type': 'AwaitExpression', + 'argument': { + 'type': 'SequenceExpression', + 'expressions': [ + {'type': 'CallExpression', 'callee': {'type': 'Identifier', 'name': 'expr'}, 'arguments': []} + ], + }, + } + t = SequenceSplitter(ast) + changed = t.execute() + # Single-element sequence should not be split + assert not changed diff --git a/tests/unit/transforms/string_revealer_test.py b/tests/unit/transforms/string_revealer_test.py index b02aafa..7931105 100644 --- a/tests/unit/transforms/string_revealer_test.py +++ b/tests/unit/transforms/string_revealer_test.py @@ -2,13 +2,18 @@ import pytest -from pyjsclear.transforms.string_revealer import ( - StringRevealer, - WrapperInfo, - _eval_numeric, - _js_parse_int, -) -from tests.unit.conftest import normalize, parse_expr, roundtrip +from pyjsclear.parser import parse +from pyjsclear.transforms.string_revealer import StringRevealer +from pyjsclear.transforms.string_revealer import WrapperInfo +from pyjsclear.transforms.string_revealer import _apply_arith +from pyjsclear.transforms.string_revealer import _collect_object_literals +from pyjsclear.transforms.string_revealer import _eval_numeric +from pyjsclear.transforms.string_revealer import _js_parse_int +from pyjsclear.transforms.string_revealer import _resolve_arg_value +from pyjsclear.transforms.string_revealer import _resolve_string_arg +from tests.unit.conftest import normalize +from tests.unit.conftest import parse_expr +from tests.unit.conftest import roundtrip # ================================================================ @@ -222,11 +227,6 @@ def test_mixed_element_array_not_replaced(self): class TestNoStringArrays: """Tests for code with no string array patterns.""" - def test_plain_code_returns_false(self): - js = 'var x = 1; console.log(x);' - _, changed = roundtrip(js, StringRevealer) - assert changed is False - def test_empty_program_returns_false(self): js = '' _, changed = roundtrip(js, StringRevealer) @@ -264,3 +264,3715 @@ def test_short_array_function_decoded(self): code, changed = roundtrip(js, StringRevealer) assert changed is True assert '"s1"' in code + + +# ================================================================ +# _apply_arith +# ================================================================ + + +class TestApplyArith: + """Tests for the _apply_arith helper.""" + + def test_addition(self): + assert _apply_arith('+', 3, 4) == 7 + + def test_subtraction(self): + assert _apply_arith('-', 10, 3) == 7 + + def test_multiplication(self): + assert _apply_arith('*', 6, 7) == 42 + + def test_division(self): + assert _apply_arith('/', 20, 4) == 5.0 + + def test_division_by_zero(self): + assert _apply_arith('/', 1, 0) is None + + def test_modulo(self): + assert _apply_arith('%', 10, 3) == 1 + + def test_modulo_by_zero(self): + assert _apply_arith('%', 10, 0) is None + + def test_unsupported_operator_returns_none(self): + assert _apply_arith('**', 2, 3) is None + assert _apply_arith('<<', 2, 3) is None + assert _apply_arith('>>', 8, 1) is None + assert _apply_arith('&', 5, 3) is None + + +# ================================================================ +# _collect_object_literals +# ================================================================ + + +class TestCollectObjectLiterals: + """Tests for the _collect_object_literals helper.""" + + def test_numeric_properties(self): + ast = parse('var obj = {a: 0x1b1, b: 42};') + result = _collect_object_literals(ast) + assert ('obj', 'a') in result + assert result[('obj', 'a')] == 0x1B1 + assert result[('obj', 'b')] == 42 + + def test_string_properties(self): + ast = parse('var obj = {a: "hello", b: "world"};') + result = _collect_object_literals(ast) + assert result[('obj', 'a')] == 'hello' + assert result[('obj', 'b')] == 'world' + + def test_mixed_properties(self): + ast = parse('var obj = {a: 0x1b1, b: "hello"};') + result = _collect_object_literals(ast) + assert result[('obj', 'a')] == 0x1B1 + assert result[('obj', 'b')] == 'hello' + + def test_string_key_properties(self): + ast = parse('var obj = {"myKey": 42};') + result = _collect_object_literals(ast) + assert result[('obj', 'myKey')] == 42 + + def test_empty_object(self): + ast = parse('var obj = {};') + result = _collect_object_literals(ast) + assert len(result) == 0 + + def test_non_object_init_ignored(self): + ast = parse('var x = 42;') + result = _collect_object_literals(ast) + assert len(result) == 0 + + def test_multiple_objects(self): + ast = parse('var a = {x: 1}; var b = {y: 2};') + result = _collect_object_literals(ast) + assert result[('a', 'x')] == 1 + assert result[('b', 'y')] == 2 + + +# ================================================================ +# _resolve_arg_value +# ================================================================ + + +class TestResolveArgValue: + """Tests for the _resolve_arg_value helper.""" + + def test_numeric_literal(self): + arg = parse_expr('42') + assert _resolve_arg_value(arg, {}) == 42 + + def test_string_hex_literal(self): + arg = parse_expr('"0x1a"') + assert _resolve_arg_value(arg, {}) == 0x1A + + def test_string_decimal_literal(self): + arg = parse_expr('"10"') + assert _resolve_arg_value(arg, {}) == 10 + + def test_string_non_numeric_returns_none(self): + arg = parse_expr('"hello"') + assert _resolve_arg_value(arg, {}) is None + + def test_member_expression_numeric(self): + obj_literals = {('obj', 'x'): 0x42} + arg = { + 'type': 'MemberExpression', + 'computed': False, + 'object': {'type': 'Identifier', 'name': 'obj'}, + 'property': {'type': 'Identifier', 'name': 'x'}, + } + assert _resolve_arg_value(arg, obj_literals) == 0x42 + + def test_member_expression_string_numeric(self): + obj_literals = {('obj', 'x'): '0x10'} + arg = { + 'type': 'MemberExpression', + 'computed': False, + 'object': {'type': 'Identifier', 'name': 'obj'}, + 'property': {'type': 'Identifier', 'name': 'x'}, + } + assert _resolve_arg_value(arg, obj_literals) == 0x10 + + def test_member_expression_string_non_numeric(self): + obj_literals = {('obj', 'x'): 'hello'} + arg = { + 'type': 'MemberExpression', + 'computed': False, + 'object': {'type': 'Identifier', 'name': 'obj'}, + 'property': {'type': 'Identifier', 'name': 'x'}, + } + assert _resolve_arg_value(arg, obj_literals) is None + + def test_member_expression_unknown_key(self): + obj_literals = {('obj', 'x'): 42} + arg = { + 'type': 'MemberExpression', + 'computed': False, + 'object': {'type': 'Identifier', 'name': 'obj'}, + 'property': {'type': 'Identifier', 'name': 'y'}, + } + assert _resolve_arg_value(arg, obj_literals) is None + + def test_computed_member_expression_not_resolved(self): + obj_literals = {('obj', 'x'): 42} + arg = { + 'type': 'MemberExpression', + 'computed': True, + 'object': {'type': 'Identifier', 'name': 'obj'}, + 'property': {'type': 'Identifier', 'name': 'x'}, + } + assert _resolve_arg_value(arg, obj_literals) is None + + def test_identifier_returns_none(self): + arg = parse_expr('x') + assert _resolve_arg_value(arg, {}) is None + + +# ================================================================ +# _resolve_string_arg +# ================================================================ + + +class TestResolveStringArg: + """Tests for the _resolve_string_arg helper.""" + + def test_string_literal(self): + arg = parse_expr('"hello"') + assert _resolve_string_arg(arg, {}) == 'hello' + + def test_member_expression_string(self): + obj_literals = {('obj', 'key'): 'secret'} + arg = { + 'type': 'MemberExpression', + 'computed': False, + 'object': {'type': 'Identifier', 'name': 'obj'}, + 'property': {'type': 'Identifier', 'name': 'key'}, + } + assert _resolve_string_arg(arg, obj_literals) == 'secret' + + def test_member_expression_numeric_returns_none(self): + obj_literals = {('obj', 'key'): 42} + arg = { + 'type': 'MemberExpression', + 'computed': False, + 'object': {'type': 'Identifier', 'name': 'obj'}, + 'property': {'type': 'Identifier', 'name': 'key'}, + } + assert _resolve_string_arg(arg, obj_literals) is None + + def test_numeric_literal_returns_none(self): + arg = parse_expr('42') + assert _resolve_string_arg(arg, {}) is None + + def test_identifier_returns_none(self): + arg = parse_expr('x') + assert _resolve_string_arg(arg, {}) is None + + def test_member_expression_unknown_returns_none(self): + arg = { + 'type': 'MemberExpression', + 'computed': False, + 'object': {'type': 'Identifier', 'name': 'obj'}, + 'property': {'type': 'Identifier', 'name': 'missing'}, + } + assert _resolve_string_arg(arg, {}) is None + + +# ================================================================ +# Strategy 2b: Var-based string array + rotation + decoder +# ================================================================ + + +class TestVarArrayPattern: + """Tests for var-based string array with rotation and decoder (Strategy 2b).""" + + def test_var_array_with_rotation_and_decoder(self): + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar', 'baz', 'qux']; + (function(arr, count) { + var f = function(n) { + while (--n) { + arr.push(arr.shift()); + } + }; + f(++count); + })(_0xarr, 2); + var _0xdec = function(a) { + a = a - 0; + var x = _0xarr[a]; + return x; + }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + # The rotation count from _find_simple_rotation is _eval_numeric of the second arg (2), + # so array is rotated 2 positions. + # Original: ['hello', 'world', 'foo', 'bar', 'baz', 'qux'] + # After rotation 2: ['foo', 'bar', 'baz', 'qux', 'hello', 'world'] + assert '"foo"' in code + + def test_var_array_without_rotation(self): + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + var _0xdec = function(a) { + a = a - 0; + var x = _0xarr[a]; + return x; + }; + console.log(_0xdec(0)); + console.log(_0xdec(1)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '"world"' in code + + def test_var_array_with_offset(self): + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + var _0xdec = function(a) { + a = a - 2; + var x = _0xarr[a]; + return x; + }; + console.log(_0xdec(2)); + console.log(_0xdec(3)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '"world"' in code + + def test_var_array_too_short_ignored(self): + # Arrays with < 3 elements should not match _find_var_string_array + js = """ + var _0xarr = ['hello', 'world']; + var _0xdec = function(a) { + a = a - 0; + var x = _0xarr[a]; + return x; + }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + # The var pattern requires >= 3 elements, and direct array strategy + # won't inline through a decoder function call, so no change expected + assert changed is False + + +# ================================================================ +# Obfuscator.io full pattern with decoder and replacement +# ================================================================ + + +class TestObfuscatorIoFullPattern: + """Tests for the full obfuscator.io string array pattern.""" + + def test_basic_obfuscator_io_pattern(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(0)); + console.log(_0xDec(1)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '"world"' in code + + def test_obfuscator_io_with_offset(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 2; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(2)); + console.log(_0xDec(3)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '"world"' in code + + def test_obfuscator_io_multiple_calls(self): + js = """ + function _0xArr() { + var a = ['alpha', 'beta', 'gamma', 'delta', 'epsilon']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + var x = _0xDec(0); + var y = _0xDec(4); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"alpha"' in code + assert '"epsilon"' in code + + def test_obfuscator_io_removes_infrastructure(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '_0xArr' not in code + assert '_0xDec' not in code + + def test_obfuscator_io_with_wrapper_function(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p) { + return _0xDec(p + 1); + } + console.log(_0xWrap(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"world"' in code + + def test_obfuscator_io_wrapper_with_key_param(self): + # Wrapper that passes two args to decoder (index + key) + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p, q) { + return _0xDec(p); + } + console.log(_0xWrap(0, 'key')); + console.log(_0xWrap(1, 'key2')); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '"world"' in code + + def test_obfuscator_io_with_decoder_alias(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + var _0xAlias = _0xDec; + console.log(_0xAlias(0)); + console.log(_0xAlias(1)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '"world"' in code + + def test_obfuscator_io_with_transitive_alias(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + var _0xAlias1 = _0xDec; + var _0xAlias2 = _0xAlias1; + console.log(_0xAlias2(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + +# ================================================================ +# Obfuscator.io pattern with rotation IIFE +# ================================================================ + + +class TestObfuscatorIoRotation: + """Tests for the obfuscator.io rotation IIFE pattern.""" + + def test_rotation_with_while_loop(self): + js = """ + function _0xArr() { + var a = ['100', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + var _0xrotate = function(_0xn) { + while (true) { + try { + var _0xval = parseInt(_0xDec(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg.push(_0xarg.shift()); + } + }; + _0xrotate(); + })(_0xArr, 100); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + # The rotation finds a position where parseInt(arr[0]) === 100 + # arr[0] = '100' already, so no rotation needed + assert changed is True + assert '"100"' in code + + +# ================================================================ +# Wrapper analysis (expression-based wrappers) +# ================================================================ + + +class TestWrapperAnalysis: + """Tests for wrapper function analysis (_analyze_wrapper_expr).""" + + def test_var_function_expression_wrapper(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + var _0xWrap = function(p) { + return _0xDec(p + 2); + }; + console.log(_0xWrap(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"foo"' in code + + def test_arrow_function_wrapper(self): + # ArrowFunctionExpression with block body as wrapper + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + var _0xWrap = function(p) { + return _0xDec(p); + }; + console.log(_0xWrap(2)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"foo"' in code + + +# ================================================================ +# _extract_wrapper_offset edge cases +# ================================================================ + + +class TestExtractWrapperOffset: + """Tests for wrapper offset extraction patterns.""" + + def test_wrapper_with_subtraction_offset(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p) { + return _0xDec(p - 10); + } + console.log(_0xWrap(10)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_wrapper_with_second_param_index(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(unused, p) { + return _0xDec(p); + } + console.log(_0xWrap('x', 0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + +# ================================================================ +# Object literal resolution in wrapper calls +# ================================================================ + + +class TestObjectLiteralResolution: + """Tests for resolving member expressions via object literals.""" + + def test_decoder_call_with_object_member_arg(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + var obj = {x: 0}; + console.log(_0xDec(obj.x)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_wrapper_call_with_object_member_arg(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p) { + return _0xDec(p); + } + var obj = {x: 1}; + console.log(_0xWrap(obj.x)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"world"' in code + + +# ================================================================ +# _eval_numeric edge cases (modulo) +# ================================================================ + + +class TestEvalNumericModulo: + """Additional _eval_numeric tests for modulo operator.""" + + def test_modulo(self): + node = parse_expr('10 % 3') + assert _eval_numeric(node) == 1 + + def test_modulo_by_zero(self): + node = parse_expr('10 % 0') + assert _eval_numeric(node) is None + + def test_unary_unsupported_operator(self): + # The ~ operator is unsupported + node = parse_expr('~5') + assert _eval_numeric(node) is None + + def test_deeply_nested_expression(self): + node = parse_expr('(1 + 2) * (3 - 1) + 4 / 2') + assert _eval_numeric(node) == 8.0 + + +# ================================================================ +# Rotation locals collection +# ================================================================ + + +class TestCollectRotationLocals: + """Tests for _collect_rotation_locals static method.""" + + def test_collects_object_from_iife(self): + ast = parse( + """ + (function(arr, stop) { + var J = {A: 0xb9, S: 0xa7, D: 'M8Y&'}; + while (true) { + try { + var v = parseInt(J.A); + } catch (e) {} + arr.push(arr.shift()); + } + })(x, 100); + """ + ) + # The IIFE is the callee of the CallExpression + call_expr = ast['body'][0]['expression'] + iife_func = call_expr['callee'] + result = StringRevealer._collect_rotation_locals(iife_func) + assert 'J' in result + assert result['J']['A'] == 0xB9 + assert result['J']['S'] == 0xA7 + assert result['J']['D'] == 'M8Y&' + + def test_empty_iife_returns_empty(self): + ast = parse( + """ + (function() { + })(); + """ + ) + call_expr = ast['body'][0]['expression'] + iife_func = call_expr['callee'] + result = StringRevealer._collect_rotation_locals(iife_func) + assert result == {} + + +# ================================================================ +# Expression from try block +# ================================================================ + + +class TestExpressionFromTryBlock: + """Tests for _expression_from_try_block static method.""" + + def test_variable_declaration(self): + ast = parse('var x = 42;') + stmt = ast['body'][0] + result = StringRevealer._expression_from_try_block(stmt) + assert result is not None + assert result.get('type') == 'Literal' + assert result.get('value') == 42 + + def test_assignment_expression(self): + ast = parse('x = 42;') + stmt = ast['body'][0] + result = StringRevealer._expression_from_try_block(stmt) + assert result is not None + assert result.get('type') == 'Literal' + assert result.get('value') == 42 + + def test_non_matching_returns_none(self): + ast = parse('if (true) {}') + stmt = ast['body'][0] + result = StringRevealer._expression_from_try_block(stmt) + assert result is None + + def test_expression_statement_non_assignment(self): + ast = parse('foo();') + stmt = ast['body'][0] + result = StringRevealer._expression_from_try_block(stmt) + assert result is None + + +# ================================================================ +# Direct array replacement edge cases +# ================================================================ + + +class TestDirectArrayEdgeCases: + """Additional edge case tests for direct array access replacement.""" + + def test_direct_array_in_function_scope(self): + # Direct array strategy only processes the root scope bindings, + # so arrays inside function scopes are not replaced. + js = """ + function f() { + var arr = ["hello", "world"]; + return arr[0]; + } + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is False + + def test_direct_array_not_used_as_member(self): + # Using arr as a standalone identifier (not arr[N]) should not trigger + js = 'var arr = ["hello"]; f(arr);' + code, changed = roundtrip(js, StringRevealer) + assert changed is False + + +# ================================================================ +# Var-based decoder with wrappers and aliases +# ================================================================ + + +class TestVarPatternWithWrappersAndAliases: + """Tests for var-based array with wrappers and alias resolution.""" + + def test_var_array_with_decoder_alias(self): + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + var _0xdec = function(a) { + a = a - 0; + var x = _0xarr[a]; + return x; + }; + var _0xalias = _0xdec; + console.log(_0xalias(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_var_array_with_wrapper(self): + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + var _0xdec = function(a) { + a = a - 0; + var x = _0xarr[a]; + return x; + }; + function _0xwrap(p) { + return _0xdec(p + 1); + } + console.log(_0xwrap(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"world"' in code + + +# ================================================================ +# Hex string argument resolution +# ================================================================ + + +class TestHexStringResolution: + """Tests for hex string resolution in decoder calls.""" + + def test_hex_string_arg_to_decoder(self): + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec("0x0")); + console.log(_0xDec("0x1")); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '"world"' in code + + +# ================================================================ +# Rotation logic: _find_and_execute_rotation, _try_execute_rotation_call, +# _extract_rotation_expression, _parse_rotation_op, _parse_parseInt_call, +# _resolve_rotation_arg, _apply_rotation_op, _execute_rotation +# ================================================================ + + +class TestRotationLogicFull: + """Tests for the full rotation pipeline with parseInt-based expressions.""" + + def test_rotation_with_direct_decoder_call_in_parseint(self): + """Rotation where parseInt calls the decoder directly (via alias in decoder_aliases).""" + js = """ + function _0xArr() { + var a = ['200', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xDec(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 200); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + # '200' is already at position 0, so parseInt('200') == 200 == stop_value + assert '"200"' in code + + def test_rotation_with_binary_expression(self): + """Rotation with binary expression: parseInt(dec(0)) + parseInt(dec(1)).""" + js = """ + function _0xArr() { + var a = ['100', '50', 'hello', 'world', 'foo', 'bar']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xDec(0)) + parseInt(_0xDec(1)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 150); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + # parseInt('100') + parseInt('50') = 150 = stop, no rotation needed + assert '"100"' in code + + def test_rotation_with_subtraction_expression(self): + """Rotation with subtraction: parseInt(dec(0)) - parseInt(dec(1)).""" + js = """ + function _0xArr() { + var a = ['300', '100', 'hello', 'world', 'foo', 'bar']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xDec(0)) - parseInt(_0xDec(1)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 200); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"300"' in code + + def test_rotation_with_multiplication_expression(self): + """Rotation with multiply: parseInt(dec(0)) * parseInt(dec(1)).""" + js = """ + function _0xArr() { + var a = ['10', '20', 'hello', 'world', 'foo', 'bar']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xDec(0)) * parseInt(_0xDec(1)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 200); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + + def test_rotation_with_wrapper_in_parseint(self): + """Rotation where parseInt calls a wrapper function.""" + js = """ + function _0xArr() { + var a = ['500', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p) { + return _0xDec(p); + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xWrap(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 500); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"500"' in code + + def test_rotation_needs_one_shift(self): + """Rotation that needs exactly one shift before parseInt matches. + + Uses a wrapper in the rotation expression so _parse_parseInt_call can match. + """ + js = """ + function _0xArr() { + var a = ['hello', '42', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p) { + return _0xDec(p); + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xWrap(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 42); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + # After 1 rotation: ['42','world','foo','bar','baz','hello'] + # dec(0) returns '42' + assert '"42"' in code + + def test_rotation_with_negate_expression(self): + """Rotation with negation: -parseInt(dec(0)) + literal.""" + js = """ + function _0xArr() { + var a = ['-100', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = -parseInt(_0xDec(0)) + 200; + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 300); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + # -parseInt('-100') + 200 = -(-100) + 200 = 100 + 200 = 300 = stop_value + assert '"-100"' in code + + def test_rotation_with_literal_node_in_try(self): + """Rotation expression that is just a literal value (no parseInt call).""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz', 'qux']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xDec(0)) + 5; + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 5); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + # All elements are non-numeric strings, so parseInt will keep failing + # and rotating. Eventually it should still resolve or give up. + # The important thing is it doesn't crash. + assert isinstance(code, str) + + +class TestRotationArgResolution: + """Tests for _resolve_rotation_arg with various argument types.""" + + def test_rotation_with_member_expression_arg(self): + """Rotation IIFE that has local objects referenced in parseInt args.""" + js = """ + function _0xArr() { + var a = ['300', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + var J = {A: 0}; + while (true) { + try { + var _0xval = parseInt(_0xDec(J.A)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 300); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"300"' in code + + def test_rotation_with_string_hex_arg(self): + """Rotation with hex string literal as argument to decoder.""" + js = """ + function _0xArr() { + var a = ['99', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xDec("0x0")); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 99); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"99"' in code + + +# ================================================================ +# SequenceExpression rotation (lines 287-300, 637-647) +# ================================================================ + + +class TestSequenceExpressionRotation: + """Tests for rotation inside a SequenceExpression.""" + + def test_rotation_in_sequence_expression_obfuscatorio(self): + """Rotation IIFE as part of a SequenceExpression (obfuscator.io pattern).""" + js = """ + function _0xArr() { + var a = ['777', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xDec(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 777), console.log('other'); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"777"' in code + + def test_var_rotation_in_sequence_expression(self): + """Var-based rotation IIFE inside a SequenceExpression.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar', 'baz', 'qux']; + (function(a, n) { var f = function(c) { while (--c) { a.push(a.shift()); } }; f(++n); })(_0xarr, 1), console.log('side'); + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + # _find_simple_rotation uses _eval_numeric on second arg (1), so rotation_count=1 + # Array rotated 1 time: ['world','foo','bar','baz','qux','hello'] + assert '"world"' in code + + +# ================================================================ +# Wrapper analysis edge cases (lines 467-536) +# ================================================================ + + +class TestWrapperAnalysisEdgeCases: + """Tests for _analyze_wrapper_expr edge cases.""" + + def test_wrapper_with_non_block_body_ignored(self): + """Function expression with expression body (not BlockStatement) is not a wrapper.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_wrapper_with_multiple_statements_not_wrapper(self): + """Function with more than one statement is not recognized as a wrapper.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xNotWrap(p) { + var x = 1; + return _0xDec(p); + } + console.log(_0xDec(0)); + console.log(_0xNotWrap(1)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + # _0xNotWrap(1) should NOT be replaced since it's not a valid wrapper + assert '_0xNotWrap' in code + + def test_wrapper_non_return_statement_not_wrapper(self): + """Function with single non-return statement is not a wrapper.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xNotWrap(p) { + console.log(_0xDec(p)); + } + console.log(_0xDec(0)); + _0xNotWrap(1); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '_0xNotWrap' in code + + def test_wrapper_return_not_call_not_wrapper(self): + """Wrapper that returns a non-call expression is not a wrapper.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xNotWrap(p) { + return p + 1; + } + console.log(_0xDec(0)); + console.log(_0xNotWrap(1)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '_0xNotWrap' in code + + def test_wrapper_calls_wrong_decoder_not_wrapper(self): + """Wrapper that calls a different function is not recognized as decoder wrapper.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function otherFunc(p) { return p; } + function _0xNotWrap(p) { + return otherFunc(p); + } + console.log(_0xDec(0)); + console.log(_0xNotWrap(1)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '_0xNotWrap' in code + + def test_wrapper_no_call_args_not_wrapper(self): + """Wrapper with no arguments to decoder call is not a wrapper.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xNotWrap() { + return _0xDec(); + } + console.log(_0xDec(0)); + _0xNotWrap(); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_wrapper_with_non_identifier_first_arg(self): + """Wrapper where first arg to decoder is not a param reference.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xNotWrap(p) { + return _0xDec(p * p); + } + console.log(_0xDec(0)); + console.log(_0xNotWrap(1)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '_0xNotWrap' in code + + def test_extract_wrapper_offset_non_plus_minus_operator(self): + """Wrapper arg expression with unsupported operator (e.g. *).""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xNotWrap(p) { + return _0xDec(p * 2); + } + console.log(_0xDec(0)); + console.log(_0xNotWrap(1)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '_0xNotWrap' in code + + def test_extract_wrapper_offset_non_numeric_right(self): + """Wrapper arg expression p + x where x is not numeric.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xNotWrap(p, q) { + return _0xDec(p + q); + } + console.log(_0xDec(0)); + console.log(_0xNotWrap(0, 1)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + # _0xNotWrap should remain since p + q doesn't have a numeric right side + assert '_0xNotWrap' in code + + def test_extract_wrapper_offset_left_not_param(self): + """Wrapper arg expression where left side of binary is not a param.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xNotWrap(p) { + return _0xDec(1 + 2); + } + console.log(_0xDec(0)); + console.log(_0xNotWrap(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + # 1+2=3 is a constant, not a param reference on the left of binary + assert '_0xNotWrap' in code + + +# ================================================================ +# Various replacement edge cases (lines 942-1005) +# ================================================================ + + +class TestReplacementEdgeCases: + """Edge cases in _replace_all_wrapper_calls and _replace_direct_decoder_calls.""" + + def test_wrapper_call_with_insufficient_args(self): + """Wrapper call with fewer args than expected param_index.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(unused, p) { + return _0xDec(p); + } + console.log(_0xWrap()); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + # _0xWrap() called with no args should remain unreplaced + assert '_0xWrap()' in code + + def test_decoder_call_with_no_args(self): + """Direct decoder call with no arguments is not replaced.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec()); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_decoder_call_with_unresolvable_arg(self): + """Decoder call with variable (not literal) argument is not replaced.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + var x = 0; + console.log(_0xDec(x)); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_decoder_call_with_out_of_bounds_index(self): + """Decoder call with an index beyond the array doesn't crash.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(999)); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + # Out of bounds call should remain + assert '999' in code + + def test_decoder_call_with_string_key_second_arg(self): + """Decoder direct call with a second string argument (key).""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(0, 'someKey')); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_wrapper_call_with_object_member_key_arg(self): + """Wrapper call where the key param is resolved via object literal.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p, k) { + return _0xDec(p); + } + var obj = {k: 'mykey'}; + console.log(_0xWrap(0, obj.k)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + +# ================================================================ +# Var pattern edge cases (lines 1103-1169) +# ================================================================ + + +class TestVarPatternEdgeCases: + """Edge cases for _find_var_string_array, _find_simple_rotation, _find_var_decoder.""" + + def test_var_array_not_in_first_three_statements(self): + """Var string array declared after the first 3 statements is not found.""" + js = """ + var a = 1; + var b = 2; + var c = 3; + var _0xarr = ['hello', 'world', 'foo', 'bar']; + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + # Array is at index 3, beyond the first 3 statements checked + assert changed is False + + def test_var_array_with_non_string_elements(self): + """Var array with mixed types is not recognized as string array.""" + js = """ + var _0xarr = ['hello', 42, 'foo', 'bar']; + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is False + + def test_var_array_with_non_identifier_declaration(self): + """Var declaration with destructuring pattern is not matched.""" + js = """ + var [a, b] = ['hello', 'world', 'foo', 'bar']; + console.log(a); + """ + # This should parse and not crash, but not match the pattern + code, changed = roundtrip(js, StringRevealer) + assert changed is False + + def test_find_var_decoder_function_expression(self): + """Var decoder as function expression referencing array name.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + var _0xdec = function(a) { + a = a - 1; + var x = _0xarr[a]; + return x; + }; + console.log(_0xdec(1)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_var_decoder_with_no_matching_array_ref(self): + """Decoder function that doesn't reference the array name is not found.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + var _0xdec = function(a) { + a = a - 0; + var x = _0xother[a]; + return x; + }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is False + + def test_var_decoder_not_function_expression(self): + """Var declaration that is not a function expression is not decoder.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + var _0xdec = _0xarr; + console.log(_0xdec[0]); + """ + code, changed = roundtrip(js, StringRevealer) + # Direct array strategy should handle this + assert isinstance(code, str) + + def test_simple_rotation_with_for_statement(self): + """Simple rotation pattern matching checks for push/shift in source.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar', 'baz', 'qux']; + (function(a, n) { var f = function(c) { while (--c) { a.push(a.shift()); } }; f(++n); })(_0xarr, 2); + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + + def test_simple_rotation_no_push_shift_not_rotation(self): + """IIFE without push/shift in source is not recognized as rotation.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + (function(a, n) { var x = a[0]; })(_0xarr, 2); + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code # No rotation applied + + def test_simple_rotation_wrong_array_name(self): + """Rotation IIFE that references different array name is not matched.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + (function(a, n) { var f = function(c) { while (--c) { a.push(a.shift()); } }; f(++n); })(_0xother, 2); + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code # No rotation since IIFE references _0xother + + def test_simple_rotation_non_numeric_count(self): + """Rotation IIFE with non-numeric count is not matched.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + (function(a, n) { var f = function(c) { while (--c) { a.push(a.shift()); } }; f(++n); })(_0xarr, x); + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code # No rotation since count is non-numeric + + +# ================================================================ +# Direct array edge cases (lines 1176-1226) +# ================================================================ + + +class TestDirectArrayAccessEdgeCases: + """Edge cases for _try_replace_array_access and _process_direct_arrays_in_scope.""" + + def test_direct_array_non_computed_member(self): + """arr.length style access (non-computed) is not replaced.""" + js = 'var arr = ["hello", "world"]; f(arr.length);' + code, changed = roundtrip(js, StringRevealer) + assert changed is False + + def test_direct_array_used_in_child_scope(self): + """Direct array used inside a function (child scope).""" + js = """ + var arr = ["hello", "world"]; + function f() { + return arr[0]; + } + """ + code, changed = roundtrip(js, StringRevealer) + # This tests _process_direct_arrays_in_scope + assert changed is True + assert '"hello"' in code + + def test_direct_array_in_child_scope_no_binding(self): + """Child scope that doesn't reference the array leaves it alone.""" + js = """ + var arr = ["hello", "world"]; + function f() { + var x = 1; + return x; + } + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is False + + def test_replace_node_in_ast_index_path(self): + """Verify replacement works when target is in an array (index != None).""" + js = 'var arr = ["a", "b"]; f(arr[0], arr[1]);' + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"a"' in code + assert '"b"' in code + + +# ================================================================ +# _find_array_expression_in_statement (lines 1012-1023) +# ================================================================ + + +class TestFindArrayExpressionInStatement: + """Tests for _find_array_expression_in_statement.""" + + def test_array_in_variable_declaration(self): + ast = parse("var x = [1, 2, 3];") + stmt = ast['body'][0] + result = StringRevealer._find_array_expression_in_statement(stmt) + assert result is not None + assert result['type'] == 'ArrayExpression' + + def test_array_in_assignment_expression(self): + """Array in ExpressionStatement with AssignmentExpression.""" + ast = parse("x = [1, 2, 3];") + stmt = ast['body'][0] + result = StringRevealer._find_array_expression_in_statement(stmt) + assert result is not None + assert result['type'] == 'ArrayExpression' + + def test_assignment_non_array_rhs(self): + """Assignment with non-array right side returns None.""" + ast = parse("x = 42;") + stmt = ast['body'][0] + result = StringRevealer._find_array_expression_in_statement(stmt) + assert result is None + + def test_non_declaration_non_assignment(self): + """Statement that is neither declaration nor assignment returns None.""" + ast = parse("if (true) {}") + stmt = ast['body'][0] + result = StringRevealer._find_array_expression_in_statement(stmt) + assert result is None + + def test_variable_declaration_non_array_init(self): + """Variable declaration with non-array init returns None.""" + ast = parse("var x = 42;") + stmt = ast['body'][0] + result = StringRevealer._find_array_expression_in_statement(stmt) + assert result is None + + def test_expression_statement_non_assignment(self): + """ExpressionStatement that is not an assignment returns None.""" + ast = parse("foo();") + stmt = ast['body'][0] + result = StringRevealer._find_array_expression_in_statement(stmt) + assert result is None + + +# ================================================================ +# _extract_array_from_statement via ExpressionStatement path (line 346-350) +# ================================================================ + + +class TestExtractArrayFromStatement: + """Tests for _extract_array_from_statement ExpressionStatement path.""" + + def test_array_from_assignment_expression_statement(self): + """String array in an assignment expression (not var declaration).""" + js = """ + function _0xArr() { + var a; + a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(0)); + """ + # The first statement in the function body is 'var a;' (no init), + # so _extract_array_from_statement on that returns None. + # The pattern requires the array to be in the FIRST statement. + code, changed = roundtrip(js, StringRevealer) + # Won't match since array is in second statement + assert isinstance(code, str) + + +# ================================================================ +# _eval_numeric BinaryExpression edge cases (line 38) +# ================================================================ + + +class TestEvalNumericBinaryEdge: + """Test _eval_numeric with binary expressions producing None children.""" + + def test_binary_with_non_numeric_left(self): + node = parse_expr('"abc" + 1') + assert _eval_numeric(node) is None + + def test_binary_with_non_numeric_right(self): + node = parse_expr('1 + "abc"') + assert _eval_numeric(node) is None + + +# ================================================================ +# _collect_object_literals edge cases (lines 99, 103, 109) +# ================================================================ + + +class TestCollectObjectLiteralsEdgeCases: + """Edge cases for _collect_object_literals.""" + + def test_property_with_non_literal_key(self): + """Object with computed key -- esprima parses [x] as Identifier key with computed flag.""" + # In esprima, {[x]: 42} still produces a Property with key as Identifier + # but the property is marked computed. _collect_object_literals checks + # is_identifier(key), which is True even for computed keys. + # Test that a truly non-identifier/non-string key (numeric) is handled: + ast = parse('var obj = {0: 42};') + result = _collect_object_literals(ast) + # Numeric key is not an identifier or string literal, so it should be skipped + assert ('obj', 0) not in result + + def test_property_with_no_key_or_value(self): + """Shorthand property patterns.""" + ast = parse('var obj = {a: 42, b: "hi"};') + result = _collect_object_literals(ast) + assert result[('obj', 'a')] == 42 + assert result[('obj', 'b')] == 'hi' + + def test_property_non_numeric_non_string_value(self): + """Object property with non-literal value is ignored.""" + ast = parse('var obj = {a: x};') + result = _collect_object_literals(ast) + assert ('obj', 'a') not in result + + +# ================================================================ +# Base64 decoder type detection (line 372) +# ================================================================ + + +class TestDecoderTypeDetection: + """Tests for base64/RC4 decoder type detection.""" + + def test_base64_decoder_detected(self): + """Decoder function containing base64 alphabet is detected as Base64.""" + js = """ + function _0xArr() { + var a = ['aGVsbG8=', 'd29ybGQ=', 'Zm9v', 'YmFy', 'YmF6']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + var c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/='; + return arr[idx]; + } + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + + +# ================================================================ +# _update_ast_array (lines 1027-1032) +# ================================================================ + + +class TestUpdateAstArray: + """Tests for _update_ast_array via rotation that modifies the AST.""" + + def test_rotation_updates_ast_array(self): + """Rotation execution should update the AST array elements. + + Must use a wrapper in the rotation expression so _parse_parseInt_call matches. + """ + js = """ + function _0xArr() { + var a = ['hello', '42', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p) { + return _0xDec(p); + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xWrap(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 42); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + # After 1 rotation: ['42','world','foo','bar','baz','hello'] + # dec(0) = '42' + assert '"42"' in code + + +# ================================================================ +# _extract_rotation_expression edge cases +# ================================================================ + + +class TestExtractRotationExpression: + """Tests for _extract_rotation_expression with various loop types.""" + + def test_rotation_with_for_loop(self): + """Rotation IIFE with for loop instead of while.""" + js = """ + function _0xArr() { + var a = ['500', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + for (;;) { + try { + var _0xval = parseInt(_0xDec(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 500); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"500"' in code + + def test_rotation_with_empty_func_body(self): + """Rotation IIFE with empty body produces no rotation expression.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + })(_0xArr, 100); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_rotation_with_assignment_in_try(self): + """Rotation where try block uses assignment expression instead of var.""" + js = """ + function _0xArr() { + var a = ['500', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + var _0xval; + while (true) { + try { + _0xval = parseInt(_0xDec(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 500); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"500"' in code + + +# ================================================================ +# _parse_rotation_op edge cases +# ================================================================ + + +class TestParseRotationOp: + """Tests for _parse_rotation_op with various expression types.""" + + def test_rotation_op_with_modulo(self): + """Rotation expression with modulo operator.""" + js = """ + function _0xArr() { + var a = ['10', '3', 'hello', 'world', 'foo', 'bar']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xDec(0)) % parseInt(_0xDec(1)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 1); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + # 10 % 3 = 1 = stop_value + + def test_rotation_op_with_division(self): + """Rotation expression with division operator.""" + js = """ + function _0xArr() { + var a = ['100', '20', 'hello', 'world', 'foo', 'bar']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xDec(0)) / parseInt(_0xDec(1)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 5); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + + def test_rotation_non_parseint_call_ignored(self): + """Rotation expression with non-parseInt call returns None from _parse_rotation_op.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz', 'qux']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = Math.floor(_0xDec(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 100); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + # Rotation can't be parsed (Math.floor is not parseInt), so no rotation + assert changed is True + assert '"hello"' in code + + +# ================================================================ +# _try_execute_rotation_call edge cases +# ================================================================ + + +class TestTryExecuteRotationCall: + """Edge cases for _try_execute_rotation_call.""" + + def test_rotation_callee_not_function_expression(self): + """Rotation call whose callee is not a FunctionExpression is skipped.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + someFunc(_0xArr, 100); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_rotation_wrong_arg_count(self): + """Rotation IIFE with != 2 arguments is skipped.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg) { + })(_0xArr); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_rotation_first_arg_not_array_func(self): + """Rotation IIFE where first arg is not the array function name.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + })(otherFunc, 100); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_rotation_non_numeric_stop_value(self): + """Rotation IIFE with non-numeric stop value is skipped.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xDec(0)); + if (_0xval === _0xstop) break; + } catch(e) {} + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, someVar); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + +# ================================================================ +# Decoder offset extraction edge cases (lines 409-418) +# ================================================================ + + +class TestExtractDecoderOffset: + """Tests for _extract_decoder_offset edge cases.""" + + def test_decoder_with_addition_offset(self): + """Decoder with idx = idx + OFFSET.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx + 2; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + # offset is +2, so _0xDec(0) -> arr[0+2] = 'foo' + assert '"foo"' in code + + def test_decoder_with_no_offset(self): + """Decoder without any param reassignment has offset 0.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + +# ================================================================ +# _resolve_rotation_arg edge cases: string returns string +# ================================================================ + + +class TestResolveRotationArgEdgeCases: + """Edge cases for _resolve_rotation_arg returning string values.""" + + def test_rotation_arg_non_hex_string_literal(self): + """Non-hex, non-numeric string literal is returned as-is (for RC4 key).""" + # We test this indirectly through the rotation with wrapper + key param + js = """ + function _0xArr() { + var a = ['500', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p, k) { + return _0xDec(p); + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xWrap(0, 'myKey')); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 500); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"500"' in code + + def test_rotation_arg_member_expression_computed(self): + """MemberExpression with computed string key in rotation locals.""" + js = """ + function _0xArr() { + var a = ['300', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + (function(_0xarg, _0xstop) { + var J = {"val": 0}; + while (true) { + try { + var _0xval = parseInt(_0xDec(J["val"])); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 300); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"300"' in code + + +# ================================================================ +# _collect_rotation_locals edge cases (lines 704-716) +# ================================================================ + + +class TestCollectRotationLocalsEdgeCases: + """Edge cases for _collect_rotation_locals.""" + + def test_rotation_locals_with_string_key(self): + """Object literal with string keys in rotation IIFE.""" + ast = parse( + """ + (function(arr, stop) { + var J = {"A": 0xb9, "B": 'key'}; + while (true) { + try { + var v = parseInt(J.A); + } catch (e) {} + arr.push(arr.shift()); + } + })(x, 100); + """ + ) + call_expr = ast['body'][0]['expression'] + iife_func = call_expr['callee'] + result = StringRevealer._collect_rotation_locals(iife_func) + assert 'J' in result + assert result['J']['A'] == 0xB9 + assert result['J']['B'] == 'key' + + def test_rotation_locals_non_object_var_ignored(self): + """Non-object variable declarations in IIFE are ignored.""" + ast = parse( + """ + (function(arr, stop) { + var x = 42; + while (true) { + try { + var v = 1; + } catch (e) {} + } + })(x, 100); + """ + ) + call_expr = ast['body'][0]['expression'] + iife_func = call_expr['callee'] + result = StringRevealer._collect_rotation_locals(iife_func) + assert result == {} + + def test_rotation_locals_non_identifier_name_ignored(self): + """Var declaration with non-identifier pattern is ignored.""" + ast = parse( + """ + (function(arr, stop) { + var J = {A: 1}; + })(x, 100); + """ + ) + call_expr = ast['body'][0]['expression'] + iife_func = call_expr['callee'] + result = StringRevealer._collect_rotation_locals(iife_func) + assert 'J' in result + assert result['J']['A'] == 1 + + def test_rotation_locals_empty_object(self): + """Empty object literal in IIFE is not added (no properties).""" + ast = parse( + """ + (function(arr, stop) { + var J = {}; + })(x, 100); + """ + ) + call_expr = ast['body'][0]['expression'] + iife_func = call_expr['callee'] + result = StringRevealer._collect_rotation_locals(iife_func) + assert 'J' not in result + + +# ================================================================ +# RC4 decoder creation (line 430) +# ================================================================ + + +class TestRc4DecoderCreation: + """Tests for RC4 decoder type being created via _create_base_decoder.""" + + def test_rc4_decoder_detected_and_used(self): + """Decoder with base64 alphabet AND fromCharCode...^ pattern is detected as RC4.""" + js = """ + function _0xArr() { + var a = ['aGVsbG8=', 'd29ybGQ=', 'Zm9v', 'YmFy', 'YmF6']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx, key) { + idx = idx - 0; + var arr = _0xArr(); + var c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/='; + var result = String.fromCharCode(arr[idx].charCodeAt(0) ^ key.charCodeAt(0)); + return result; + } + console.log(_0xDec(0, 'k')); + """ + code, changed = roundtrip(js, StringRevealer) + # The important thing is it doesn't crash and detects the RC4 pattern + assert isinstance(code, str) + + +# ================================================================ +# Direct method tests for rotation internals +# ================================================================ + + +class TestRotationInternalsDirect: + """Direct method tests for rotation-related internals.""" + + def _make_revealer(self, js): + """Create a StringRevealer with parsed AST.""" + ast = parse(js) + return StringRevealer(ast), ast + + def test_parse_rotation_op_literal(self): + """_parse_rotation_op handles a bare numeric literal.""" + t, ast = self._make_revealer('var x = 1;') + node = parse_expr('42') + result = t._parse_rotation_op(node, {}, set()) + assert result == {'op': 'literal', 'value': 42} + + def test_parse_rotation_op_negate(self): + """_parse_rotation_op handles unary negation.""" + t, ast = self._make_revealer('var x = 1;') + node = parse_expr('-42') + result = t._parse_rotation_op(node, {}, set()) + assert result is not None + assert result['op'] == 'negate' + assert result['child']['op'] == 'literal' + assert result['child']['value'] == 42 + + def test_parse_rotation_op_binary(self): + """_parse_rotation_op handles binary addition of literals.""" + t, ast = self._make_revealer('var x = 1;') + node = parse_expr('10 + 20') + result = t._parse_rotation_op(node, {}, set()) + assert result is not None + assert result['op'] == 'binary' + assert result['operator'] == '+' + + def test_parse_rotation_op_call_with_wrapper(self): + """_parse_rotation_op handles parseInt(wrapper(0)).""" + t, ast = self._make_revealer('var x = 1;') + wrapper = WrapperInfo('_0xWrap', param_index=0, wrapper_offset=0, func_node={}) + node = parse_expr('parseInt(_0xWrap(0))') + result = t._parse_rotation_op(node, {'_0xWrap': wrapper}, set()) + assert result is not None + assert result['op'] == 'call' + assert result['wrapper_name'] == '_0xWrap' + assert result['args'] == [0] + + def test_parse_rotation_op_call_with_decoder_alias(self): + """_parse_rotation_op handles parseInt(alias(0)) where alias is in decoder_aliases.""" + t, ast = self._make_revealer('var x = 1;') + node = parse_expr('parseInt(_0xAlias(0))') + result = t._parse_rotation_op(node, {}, {'_0xAlias'}) + assert result is not None + assert result['op'] == 'direct_decoder_call' + assert result['alias_name'] == '_0xAlias' + assert result['args'] == [0] + + def test_parse_rotation_op_non_dict_returns_none(self): + """_parse_rotation_op returns None for non-dict input.""" + t, ast = self._make_revealer('var x = 1;') + assert t._parse_rotation_op(None, {}, set()) is None + assert t._parse_rotation_op('string', {}, set()) is None + + def test_parse_rotation_op_unsupported_type_returns_none(self): + """_parse_rotation_op returns None for unsupported node types.""" + t, ast = self._make_revealer('var x = 1;') + node = parse_expr('x') # Identifier + result = t._parse_rotation_op(node, {}, set()) + assert result is None + + def test_parse_rotation_op_negate_with_non_numeric_child(self): + """_parse_rotation_op negate with non-parseable child returns None.""" + t, ast = self._make_revealer('var x = 1;') + # -x where x is an identifier, not resolvable + node = parse_expr('-x') + result = t._parse_rotation_op(node, {}, set()) + assert result is None + + def test_parse_rotation_op_binary_with_unparseable_child(self): + """_parse_rotation_op binary with unparseable left or right returns None.""" + t, ast = self._make_revealer('var x = 1;') + # x + 1 where x is identifier + node = parse_expr('x + 1') + result = t._parse_rotation_op(node, {}, set()) + assert result is None + + def test_parse_parseInt_call_not_parseint(self): + """_parse_parseInt_call returns None when callee is not parseInt.""" + t, ast = self._make_revealer('var x = 1;') + node = parse_expr('Math.floor(1)') + result = t._parse_parseInt_call(node, {}, set()) + assert result is None + + def test_parse_parseInt_call_wrong_arg_count(self): + """_parse_parseInt_call returns None when parseInt has != 1 arg.""" + t, ast = self._make_revealer('var x = 1;') + node = parse_expr('parseInt(1, 10)') + result = t._parse_parseInt_call(node, {}, set()) + assert result is None + + def test_parse_parseInt_call_inner_not_call(self): + """_parse_parseInt_call returns None when inner arg is not a call.""" + t, ast = self._make_revealer('var x = 1;') + node = parse_expr('parseInt(42)') + result = t._parse_parseInt_call(node, {}, set()) + assert result is None + + def test_parse_parseInt_call_inner_callee_not_identifier(self): + """_parse_parseInt_call returns None when inner callee is not identifier.""" + t, ast = self._make_revealer('var x = 1;') + node = parse_expr('parseInt(a.b(0))') + result = t._parse_parseInt_call(node, {}, set()) + assert result is None + + def test_parse_parseInt_call_inner_unknown_function(self): + """_parse_parseInt_call returns None when inner function is not in wrappers/aliases.""" + t, ast = self._make_revealer('var x = 1;') + node = parse_expr('parseInt(unknownFunc(0))') + result = t._parse_parseInt_call(node, {}, set()) + assert result is None + + def test_parse_parseInt_call_unresolvable_arg(self): + """_parse_parseInt_call returns None when inner arg can't be resolved.""" + t, ast = self._make_revealer('var x = 1;') + t._rotation_locals = {} + wrapper = WrapperInfo('_0xW', param_index=0, wrapper_offset=0, func_node={}) + node = parse_expr('parseInt(_0xW(someVar))') + result = t._parse_parseInt_call(node, {'_0xW': wrapper}, set()) + assert result is None + + def test_resolve_rotation_arg_numeric(self): + """_resolve_rotation_arg resolves numeric literal.""" + t, ast = self._make_revealer('var x = 1;') + t._rotation_locals = {} + node = parse_expr('42') + assert t._resolve_rotation_arg(node) == 42 + + def test_resolve_rotation_arg_string_hex(self): + """_resolve_rotation_arg resolves hex string literal.""" + t, ast = self._make_revealer('var x = 1;') + t._rotation_locals = {} + node = parse_expr('"0x1b"') + assert t._resolve_rotation_arg(node) == 0x1B + + def test_resolve_rotation_arg_string_decimal(self): + """_resolve_rotation_arg resolves decimal string literal.""" + t, ast = self._make_revealer('var x = 1;') + t._rotation_locals = {} + node = parse_expr('"42"') + assert t._resolve_rotation_arg(node) == 42 + + def test_resolve_rotation_arg_string_non_numeric(self): + """_resolve_rotation_arg resolves non-numeric string as-is.""" + t, ast = self._make_revealer('var x = 1;') + t._rotation_locals = {} + node = parse_expr('"myKey"') + assert t._resolve_rotation_arg(node) == 'myKey' + + def test_resolve_rotation_arg_member_identifier_prop(self): + """_resolve_rotation_arg resolves J.A from rotation locals.""" + t, ast = self._make_revealer('var x = 1;') + t._rotation_locals = {'J': {'A': 42}} + node = { + 'type': 'MemberExpression', + 'computed': False, + 'object': {'type': 'Identifier', 'name': 'J'}, + 'property': {'type': 'Identifier', 'name': 'A'}, + } + assert t._resolve_rotation_arg(node) == 42 + + def test_resolve_rotation_arg_member_string_prop(self): + """_resolve_rotation_arg resolves J['A'] from rotation locals.""" + t, ast = self._make_revealer('var x = 1;') + t._rotation_locals = {'J': {'A': 99}} + node = { + 'type': 'MemberExpression', + 'computed': True, + 'object': {'type': 'Identifier', 'name': 'J'}, + 'property': {'type': 'Literal', 'value': 'A'}, + } + assert t._resolve_rotation_arg(node) == 99 + + def test_resolve_rotation_arg_member_unknown_object(self): + """_resolve_rotation_arg returns None for unknown object in member.""" + t, ast = self._make_revealer('var x = 1;') + t._rotation_locals = {} + node = { + 'type': 'MemberExpression', + 'computed': False, + 'object': {'type': 'Identifier', 'name': 'unknown'}, + 'property': {'type': 'Identifier', 'name': 'A'}, + } + assert t._resolve_rotation_arg(node) is None + + def test_resolve_rotation_arg_identifier_returns_none(self): + """_resolve_rotation_arg returns None for bare identifier.""" + t, ast = self._make_revealer('var x = 1;') + t._rotation_locals = {} + node = parse_expr('x') + assert t._resolve_rotation_arg(node) is None + + def test_apply_rotation_op_literal(self): + """_apply_rotation_op evaluates a literal node.""" + t, ast = self._make_revealer('var x = 1;') + result = t._apply_rotation_op({'op': 'literal', 'value': 42}, {}, None) + assert result == 42 + + def test_apply_rotation_op_negate(self): + """_apply_rotation_op evaluates a negate node.""" + t, ast = self._make_revealer('var x = 1;') + op = {'op': 'negate', 'child': {'op': 'literal', 'value': 10}} + result = t._apply_rotation_op(op, {}, None) + assert result == -10 + + def test_apply_rotation_op_binary(self): + """_apply_rotation_op evaluates a binary node.""" + t, ast = self._make_revealer('var x = 1;') + op = { + 'op': 'binary', + 'operator': '+', + 'left': {'op': 'literal', 'value': 10}, + 'right': {'op': 'literal', 'value': 20}, + } + result = t._apply_rotation_op(op, {}, None) + assert result == 30 + + def test_apply_rotation_op_call_wrapper(self): + """_apply_rotation_op evaluates a wrapper call op.""" + from pyjsclear.utils.string_decoders import BasicStringDecoder + + t, ast = self._make_revealer('var x = 1;') + decoder = BasicStringDecoder(['100', 'hello', 'world'], 0) + wrapper = WrapperInfo('w', param_index=0, wrapper_offset=0, func_node={}) + op = {'op': 'call', 'wrapper_name': 'w', 'args': [0]} + result = t._apply_rotation_op(op, {'w': wrapper}, decoder) + assert result == 100 + + def test_apply_rotation_op_direct_decoder_call(self): + """_apply_rotation_op evaluates a direct_decoder_call op.""" + from pyjsclear.utils.string_decoders import BasicStringDecoder + + t, ast = self._make_revealer('var x = 1;') + decoder = BasicStringDecoder(['200', 'hello'], 0) + alias_map = {'_0xAlias': decoder} + op = {'op': 'direct_decoder_call', 'alias_name': '_0xAlias', 'args': [0]} + result = t._apply_rotation_op(op, {}, decoder, alias_decoder_map=alias_map) + assert result == 200 + + def test_apply_rotation_op_direct_decoder_call_with_key(self): + """_apply_rotation_op direct_decoder_call with key arg.""" + from pyjsclear.utils.string_decoders import BasicStringDecoder + + t, ast = self._make_revealer('var x = 1;') + decoder = BasicStringDecoder(['300', 'hello'], 0) + op = {'op': 'direct_decoder_call', 'alias_name': '_0xAlias', 'args': [0, 'key']} + result = t._apply_rotation_op(op, {}, decoder) + # BasicStringDecoder ignores the key, just returns by index + assert result == 300 + + def test_apply_rotation_op_unknown_op_raises(self): + """_apply_rotation_op raises for unknown op.""" + t, ast = self._make_revealer('var x = 1;') + with pytest.raises(ValueError, match='Unknown op'): + t._apply_rotation_op({'op': 'unknown_op'}, {}, None) + + def test_apply_rotation_op_call_invalid_wrapper_args_raises(self): + """_apply_rotation_op raises when wrapper args are invalid.""" + t, ast = self._make_revealer('var x = 1;') + wrapper = WrapperInfo('w', param_index=5, wrapper_offset=0, func_node={}) + op = {'op': 'call', 'wrapper_name': 'w', 'args': [0]} + with pytest.raises(ValueError, match='Invalid wrapper args'): + t._apply_rotation_op(op, {'w': wrapper}, None) + + def test_apply_rotation_op_direct_decoder_no_args_raises(self): + """_apply_rotation_op raises when direct_decoder_call has no args.""" + t, ast = self._make_revealer('var x = 1;') + op = {'op': 'direct_decoder_call', 'alias_name': 'x', 'args': []} + with pytest.raises(ValueError, match='No args'): + t._apply_rotation_op(op, {}, None) + + def test_execute_rotation_basic(self): + """_execute_rotation rotates array until expression matches stop.""" + from pyjsclear.utils.string_decoders import BasicStringDecoder + + t, ast = self._make_revealer('var x = 1;') + string_array = ['hello', '42', 'world', 'foo', 'bar'] + decoder = BasicStringDecoder(string_array, 0) + wrapper = WrapperInfo('w', param_index=0, wrapper_offset=0, func_node={}) + # parseInt(w(0)) should eventually equal 42 after 1 rotation + op = {'op': 'call', 'wrapper_name': 'w', 'args': [0]} + result = t._execute_rotation(string_array, op, {'w': wrapper}, decoder, 42) + assert result is True + assert string_array[0] == '42' + + def test_execute_rotation_clears_decoder_cache(self): + """_execute_rotation clears decoder caches on each rotation.""" + from pyjsclear.utils.string_decoders import Base64StringDecoder + + t, ast = self._make_revealer('var x = 1;') + # Use Base64StringDecoder which has a _cache attribute + # String array where '42' needs to be at index 0 after rotation + string_array = ['hello', '42', 'world', 'foo', 'bar'] + decoder = Base64StringDecoder(string_array, 0) + # Manually seed the cache to verify it gets cleared + decoder._cache[0] = 'hello' + wrapper = WrapperInfo('w', param_index=0, wrapper_offset=0, func_node={}) + # This will try to parseInt the decoded string at index 0 + # BasicStringDecoder returns string directly, Base64StringDecoder does base64_transform + # But since Base64 won't give us clean ints, use BasicStringDecoder for the actual test + # and just verify that _cache.clear() is called on Base64StringDecoder + from pyjsclear.utils.string_decoders import BasicStringDecoder + + primary = BasicStringDecoder(string_array, 0) + op = {'op': 'call', 'wrapper_name': 'w', 'args': [0]} + result = t._execute_rotation( + string_array, + op, + {'w': wrapper}, + primary, + 42, + alias_decoder_map={'alias': decoder}, + ) + assert result is True + assert string_array[0] == '42' + # Verify the Base64 decoder's cache was cleared during rotation + assert len(decoder._cache) == 0 + + def test_execute_rotation_with_alias_decoder_map(self): + """_execute_rotation uses alias_decoder_map for clearing caches.""" + from pyjsclear.utils.string_decoders import Base64StringDecoder + from pyjsclear.utils.string_decoders import BasicStringDecoder + + t, ast = self._make_revealer('var x = 1;') + string_array = ['hello', '42', 'world', 'foo', 'bar'] + primary = BasicStringDecoder(string_array, 0) + alias_decoder = Base64StringDecoder(string_array, 0) + alias_decoder._cache[99] = 'stale' + alias_map = {'alias': alias_decoder} + wrapper = WrapperInfo('w', param_index=0, wrapper_offset=0, func_node={}) + op = {'op': 'call', 'wrapper_name': 'w', 'args': [0]} + result = t._execute_rotation(string_array, op, {'w': wrapper}, primary, 42, alias_decoder_map=alias_map) + assert result is True + assert string_array[0] == '42' + # Cache should have been cleared during rotation + assert len(alias_decoder._cache) == 0 + + +# ================================================================ +# SequenceExpression rotation removal (lines 290-298) +# ================================================================ + + +class TestSequenceExpressionRotationRemoval: + """Tests for rotation inside SequenceExpression being properly removed.""" + + def test_sequence_rotation_removal_with_wrapper(self): + """Rotation in SequenceExpression is removed while keeping other expressions. + + This triggers lines 287-300 by having the rotation succeed inside a sequence. + """ + js = """ + function _0xArr() { + var a = ['500', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p) { + return _0xDec(p); + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xWrap(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 500), console.log('other'); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"500"' in code + # The rotation IIFE should be removed from the sequence, but + # console.log('other') should remain + assert "'other'" in code or '"other"' in code + + +# ================================================================ +# _find_and_execute_rotation SequenceExpression path (lines 637-647) +# ================================================================ + + +class TestRotationSequenceExpression: + """Test that rotation can be found inside a SequenceExpression.""" + + def test_rotation_in_sequence_with_decoder_alias(self): + """Rotation IIFE inside SequenceExpression using decoder alias.""" + js = """ + function _0xArr() { + var a = ['777', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + var _0xAlias = _0xDec; + function _0xWrap(p) { + return _0xDec(p); + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xWrap(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 777), console.log('extra'); + console.log(_0xAlias(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"777"' in code + + +# ================================================================ +# _extract_decoder_offset additional edge cases (lines 409-418) +# ================================================================ + + +class TestExtractDecoderOffsetDirect: + """Direct tests for _extract_decoder_offset edge cases.""" + + def test_offset_with_non_identifier_left(self): + """Assignment where left is not an identifier is ignored.""" + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + # Parse a function with arr[0] = arr[0] - 5 (member expression on left) + func_ast = parse( + """ + function f(idx) { + arr[0] = arr[0] - 5; + return arr[idx]; + } + """ + ) + func_node = func_ast['body'][0] + offset = t._extract_decoder_offset(func_node) + assert offset == 0 # Default when no matching pattern found + + def test_offset_non_binary_right_side(self): + """Assignment where right side is not BinaryExpression is ignored.""" + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + func_ast = parse( + """ + function f(idx) { + idx = 5; + return arr[idx]; + } + """ + ) + func_node = func_ast['body'][0] + offset = t._extract_decoder_offset(func_node) + assert offset == 0 + + def test_offset_binary_left_not_matching_param(self): + """Assignment where binary left doesn't match the assigned variable.""" + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + func_ast = parse( + """ + function f(idx) { + idx = other - 5; + return arr[idx]; + } + """ + ) + func_node = func_ast['body'][0] + offset = t._extract_decoder_offset(func_node) + assert offset == 0 + + def test_offset_unsupported_operator(self): + """Assignment with unsupported operator (*) is ignored.""" + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + func_ast = parse( + """ + function f(idx) { + idx = idx * 2; + return arr[idx]; + } + """ + ) + func_node = func_ast['body'][0] + offset = t._extract_decoder_offset(func_node) + assert offset == 0 + + +# ================================================================ +# _string_array_from_expression edge cases (line 336) +# ================================================================ + + +class TestStringArrayFromExpression: + """Edge cases for _string_array_from_expression.""" + + def test_array_with_non_string_element(self): + """Array with a numeric element returns None.""" + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + node = parse_expr('[1, 2, 3]') + result = t._string_array_from_expression(node) + assert result is None + + def test_empty_array_returns_none(self): + """Empty array returns None.""" + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + node = parse_expr('[]') + result = t._string_array_from_expression(node) + assert result is None + + def test_non_array_returns_none(self): + """Non-array node returns None.""" + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + node = parse_expr('42') + result = t._string_array_from_expression(node) + assert result is None + + def test_none_returns_none(self): + """None returns None.""" + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + assert t._string_array_from_expression(None) is None + + +# ================================================================ +# _find_string_array_function edge cases (line 318) +# ================================================================ + + +class TestFindStringArrayFunction: + """Edge cases for _find_string_array_function.""" + + def test_function_with_short_body(self): + """Function with only 1 statement in body is skipped.""" + t, ast = TestRotationInternalsDirect._make_revealer( + None, + """ + function _0xArr() { + return ['hello', 'world']; + } + """, + ) + body = ast['body'] + name, arr, idx = t._find_string_array_function(body) + assert name is None + + def test_function_without_name(self): + """Function without a name is skipped.""" + # FunctionDeclarations always have names in valid JS, but we test the guard + js = """ + function _0xArr() { + var a = ['hello', 'world']; + _0xArr = function() { return a; }; + return _0xArr(); + } + var x = 1; + """ + t, ast = TestRotationInternalsDirect._make_revealer(None, js) + body = ast['body'] + name, arr, idx = t._find_string_array_function(body) + assert name == '_0xArr' + assert arr == ['hello', 'world'] + + +# ================================================================ +# _eval_numeric unary with non-evaluable argument (line 38) +# ================================================================ + + +class TestEvalNumericUnaryArgNone: + """Test _eval_numeric when unary argument evaluates to None.""" + + def test_negate_identifier_returns_none(self): + """Negating an identifier that can't be evaluated returns None.""" + node = parse_expr('-x') + assert _eval_numeric(node) is None + + def test_positive_identifier_returns_none(self): + """Positive sign on identifier returns None.""" + node = parse_expr('+x') + assert _eval_numeric(node) is None + + +# ================================================================ +# Additional _collect_object_literals edge (line 99, 103) +# ================================================================ + + +class TestCollectObjectLiteralsPropertyType: + """Test _collect_object_literals with non-Property type entries.""" + + def test_spread_element_ignored(self): + """SpreadElement in object properties is skipped (type != 'Property').""" + # We can't easily create this in valid JS that esprima parses, + # but we can test with a normal object to verify Property type check works + ast = parse('var obj = {a: 1, b: "two"};') + result = _collect_object_literals(ast) + assert result[('obj', 'a')] == 1 + assert result[('obj', 'b')] == 'two' + + def test_property_with_no_value(self): + """Property with missing key or value is skipped.""" + # Manually construct an AST with a malformed property + ast = { + 'type': 'Program', + 'body': [ + { + 'type': 'VariableDeclaration', + 'declarations': [ + { + 'type': 'VariableDeclarator', + 'id': {'type': 'Identifier', 'name': 'obj'}, + 'init': { + 'type': 'ObjectExpression', + 'properties': [ + {'type': 'Property', 'key': None, 'value': {'type': 'Literal', 'value': 42}}, + {'type': 'Property', 'key': {'type': 'Identifier', 'name': 'a'}, 'value': None}, + ], + }, + } + ], + } + ], + } + result = _collect_object_literals(ast) + assert len(result) == 0 + + +# ================================================================ +# _process_direct_arrays_in_scope line 1214 +# ================================================================ + + +class TestProcessDirectArraysInScope: + """Test _process_direct_arrays_in_scope when binding is not found.""" + + def test_array_in_nested_function_scopes(self): + """Array accessed in deeply nested function scopes.""" + js = """ + var arr = ["hello", "world"]; + function f() { + function g() { + return arr[0]; + } + return g(); + } + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_array_not_referenced_in_child_scope(self): + """Child scope that doesn't reference the array binding.""" + js = """ + var arr = ["hello", "world"]; + function f() { + var arr = 42; + return arr; + } + """ + code, changed = roundtrip(js, StringRevealer) + # The inner 'arr' shadows the outer, so no replacement in inner scope + assert changed is False + + +# ================================================================ +# _find_var_string_array line 1103 (non-identifier declaration) +# ================================================================ + + +class TestFindVarStringArrayEdge: + """Edge cases for _find_var_string_array.""" + + def test_non_array_init_skipped(self): + """Var declaration with non-array init is skipped.""" + js = """ + var _0x = 42; + var _0xarr = ['hello', 'world', 'foo', 'bar']; + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + def test_short_array_skipped(self): + """Array with < 3 elements is skipped by _find_var_string_array.""" + js = """ + var _0xarr = ['a', 'b']; + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is False + + +# ================================================================ +# _find_simple_rotation edge: non-ExpressionStatement (line 1122) +# ================================================================ + + +class TestFindSimpleRotationEdge: + """Edge cases for _find_simple_rotation.""" + + def test_non_expression_statement_skipped(self): + """Non-ExpressionStatement in body is skipped when looking for rotation.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + if (true) { console.log('test'); } + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code # No rotation applied + + def test_expression_statement_without_expression(self): + """Expression statement edge case.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + 0; + var _0xdec = function(i) { i = i - 0; return _0xarr[i]; }; + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + +# ================================================================ +# _find_var_decoder line 1161 (non-function init) +# ================================================================ + + +class TestFindVarDecoderEdge: + """Edge cases for _find_var_decoder.""" + + def test_var_declaration_non_function_init(self): + """Var declaration where init is not FunctionExpression is skipped.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + var _0xdec = 42; + console.log(_0xarr[0]); + """ + code, changed = roundtrip(js, StringRevealer) + # Direct array strategy handles arr[0], but decoder pattern is not found + assert isinstance(code, str) + + def test_var_declaration_non_variable(self): + """Non-variable declaration statement is skipped when looking for decoder.""" + js = """ + var _0xarr = ['hello', 'world', 'foo', 'bar']; + function _0xdec(i) { i = i - 0; return _0xarr[i]; } + console.log(_0xdec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + # Function declaration is not a VariableDeclaration, so _find_var_decoder skips it + # But the direct array strategy may still work + assert isinstance(code, str) + + +# ================================================================ +# _try_replace_array_access line 1181 edge cases +# ================================================================ + + +class TestTryReplaceArrayAccessEdge: + """Edge cases for _try_replace_array_access.""" + + def test_non_computed_member_not_replaced(self): + """arr.foo style access is not replaced.""" + js = 'var arr = ["hello", "world"]; console.log(arr.length);' + code, changed = roundtrip(js, StringRevealer) + assert changed is False + assert 'arr.length' in code + + def test_member_property_not_numeric(self): + """arr[x] where x is an identifier is not replaced.""" + js = 'var arr = ["hello", "world"]; console.log(arr[x]);' + code, changed = roundtrip(js, StringRevealer) + assert changed is False + + def test_ref_key_not_object(self): + """Reference where key is not 'object' is not replaced.""" + # This happens when arr is used as a property value, not as the object of a member + js = 'var arr = ["hello", "world"]; var x = {prop: arr};' + code, changed = roundtrip(js, StringRevealer) + assert changed is False + + +# ================================================================ +# _update_ast_array line 1029 (empty func body) +# ================================================================ + + +class TestUpdateAstArrayEdge: + """Edge case for _update_ast_array.""" + + def test_update_ast_array_with_assignment_init(self): + """_update_ast_array when first statement is assignment (not var decl).""" + t, ast = TestRotationInternalsDirect._make_revealer( + None, + """ + function _0xArr() { + a = ['hello', 'world']; + _0xArr = function() { return a; }; + return _0xArr(); + } + """, + ) + func_node = ast['body'][0] + rotated = ['world', 'hello'] + t._update_ast_array(func_node, rotated) + # Verify the AST was updated (assignment expression path) + func_body = func_node['body']['body'] + expr = func_body[0]['expression'] + assert expr['type'] == 'AssignmentExpression' + elements = expr['right']['elements'] + assert elements[0]['value'] == 'world' + assert elements[1]['value'] == 'hello' + + def test_update_ast_array_empty_body(self): + """_update_ast_array with empty function body does nothing.""" + t, ast = TestRotationInternalsDirect._make_revealer( + None, + """ + function _0xArr() { + } + """, + ) + func_node = ast['body'][0] + # Should not crash + t._update_ast_array(func_node, ['a', 'b']) + + +# ================================================================ +# More targeted tests for remaining uncovered lines +# ================================================================ + + +class TestDecodeAndParseInt: + """Tests for _decode_and_parse_int error paths.""" + + def test_decode_and_parse_int_returns_nan(self): + """_decode_and_parse_int raises when decoded string is not parseable as int.""" + from pyjsclear.utils.string_decoders import BasicStringDecoder + + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + decoder = BasicStringDecoder(['hello'], 0) + with pytest.raises(ValueError, match='NaN'): + t._decode_and_parse_int(decoder, 0) + + def test_decode_and_parse_int_none_returned(self): + """_decode_and_parse_int raises when decoder returns None (out of bounds).""" + from pyjsclear.utils.string_decoders import BasicStringDecoder + + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + decoder = BasicStringDecoder(['hello'], 0) + with pytest.raises(ValueError, match='Decoder returned None'): + t._decode_and_parse_int(decoder, 999) + + def test_decode_and_parse_int_with_key(self): + """_decode_and_parse_int passes key to decoder.get_string.""" + from pyjsclear.utils.string_decoders import BasicStringDecoder + + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + decoder = BasicStringDecoder(['42'], 0) + # BasicStringDecoder.get_string ignores extra args + result = t._decode_and_parse_int(decoder, 0, key='somekey') + assert result == 42 + + +class TestExecuteRotationEdge: + """Edge cases for _execute_rotation.""" + + def test_execute_rotation_returns_false_when_no_match(self): + """_execute_rotation returns False when no match in 100001 iterations.""" + from pyjsclear.utils.string_decoders import BasicStringDecoder + + t, ast = TestRotationInternalsDirect._make_revealer(None, 'var x = 1;') + # Array where no rotation can produce parseInt matching stop_value 999999 + # All strings are non-numeric, so parseInt always fails -> always rotates + # But it'll never match stop=999999 + string_array = ['a', 'b'] + decoder = BasicStringDecoder(string_array, 0) + wrapper = WrapperInfo('w', param_index=0, wrapper_offset=0, func_node={}) + op = {'op': 'call', 'wrapper_name': 'w', 'args': [0]} + result = t._execute_rotation(string_array, op, {'w': wrapper}, decoder, 999999) + assert result is False + + +class TestWrapperReplacementEdge: + """Edge cases for _replace_all_wrapper_calls.""" + + def test_wrapper_call_unresolvable_index_value(self): + """Wrapper call where the index param can't be resolved.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p) { + return _0xDec(p); + } + console.log(_0xWrap(someVar)); + console.log(_0xDec(0)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + # _0xWrap(someVar) should not be replaced + assert '_0xWrap(someVar)' in code + + def test_wrapper_key_param_resolution(self): + """Wrapper with key_param_index resolves key from call args.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p, k) { + return _0xDec(p, k); + } + console.log(_0xWrap(0, 'key1')); + console.log(_0xWrap(1, 'key2')); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + assert '"world"' in code + + def test_decoder_returns_non_string(self): + """When decoder returns None (out of bounds), the call is not replaced.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(0)); + console.log(_0xDec(100)); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + # _0xDec(100) should remain since it's out of bounds + assert '100' in code + + +class TestAnalyzeWrapperExprEdge: + """Edge cases for _analyze_wrapper_expr.""" + + def test_wrapper_with_key_param_from_second_arg(self): + """Wrapper passing second param as key to decoder.""" + js = """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx, key) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p, k) { + return _0xDec(p, k); + } + console.log(_0xWrap(0, 'myKey')); + """ + code, changed = roundtrip(js, StringRevealer) + assert changed is True + assert '"hello"' in code + + +class TestFindAndExecuteRotationEdge: + """Edge cases for _find_and_execute_rotation.""" + + def test_rotation_not_found_returns_none(self): + """When no rotation IIFE exists, returns None.""" + from pyjsclear.utils.string_decoders import BasicStringDecoder + + t, ast = TestRotationInternalsDirect._make_revealer( + None, + """ + function _0xArr() { + var a = ['hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + console.log(_0xDec(0)); + """, + ) + body = ast['body'] + decoder = BasicStringDecoder(['hello', 'world', 'foo', 'bar', 'baz'], 0) + result = t._find_and_execute_rotation(body, '_0xArr', ['hello'], decoder, {}, set()) + assert result is None + + def test_rotation_found_in_sequence_expression(self): + """Rotation IIFE inside a SequenceExpression is found and executed.""" + from pyjsclear.utils.string_decoders import BasicStringDecoder + + js = """ + function _0xArr() { + var a = ['500', 'hello', 'world', 'foo', 'bar', 'baz']; + _0xArr = function() { return a; }; + return _0xArr(); + } + function _0xDec(idx) { + idx = idx - 0; + var arr = _0xArr(); + return arr[idx]; + } + function _0xWrap(p) { + return _0xDec(p); + } + (function(_0xarg, _0xstop) { + while (true) { + try { + var _0xval = parseInt(_0xWrap(0)); + if (_0xval === _0xstop) { + break; + } + } catch(e) { + } + _0xarg().push(_0xarg().shift()); + } + })(_0xArr, 500), console.log('side'); + console.log(_0xDec(0)); + """ + t, ast = TestRotationInternalsDirect._make_revealer(None, js) + body = ast['body'] + string_array = ['500', 'hello', 'world', 'foo', 'bar', 'baz'] + decoder = BasicStringDecoder(string_array, 0) + wrapper = WrapperInfo('_0xWrap', param_index=0, wrapper_offset=0, func_node={}) + result = t._find_and_execute_rotation(body, '_0xArr', string_array, decoder, {'_0xWrap': wrapper}, set()) + assert result is not None + idx, sub_expr = result + assert sub_expr is not None # Was inside a SequenceExpression + + +class TestExtractRotationExpressionEdge: + """Edge cases for _extract_rotation_expression.""" + + def test_no_loop_in_iife(self): + """IIFE without a while/for loop returns None.""" + t, ast = TestRotationInternalsDirect._make_revealer( + None, + """ + (function(a, b) { + var x = 1; + console.log(x); + })(arr, 100); + """, + ) + call_expr = ast['body'][0]['expression'] + iife_func = call_expr['callee'] + result = t._extract_rotation_expression(iife_func) + assert result is None + + def test_loop_without_try_statement(self): + """Loop without a TryStatement returns None.""" + t, ast = TestRotationInternalsDirect._make_revealer( + None, + """ + (function(a, b) { + while (true) { + var x = 1; + break; + } + })(arr, 100); + """, + ) + call_expr = ast['body'][0]['expression'] + iife_func = call_expr['callee'] + result = t._extract_rotation_expression(iife_func) + assert result is None + + def test_try_with_empty_block(self): + """Try block with empty body returns None.""" + t, ast = TestRotationInternalsDirect._make_revealer( + None, + """ + (function(a, b) { + while (true) { + try { + } catch(e) {} + break; + } + })(arr, 100); + """, + ) + call_expr = ast['body'][0]['expression'] + iife_func = call_expr['callee'] + result = t._extract_rotation_expression(iife_func) + assert result is None diff --git a/tests/unit/transforms/unused_vars_test.py b/tests/unit/transforms/unused_vars_test.py index ae0399c..89dcce5 100644 --- a/tests/unit/transforms/unused_vars_test.py +++ b/tests/unit/transforms/unused_vars_test.py @@ -3,7 +3,8 @@ import pytest from pyjsclear.transforms.unused_vars import UnusedVariableRemover -from tests.unit.conftest import normalize, roundtrip +from tests.unit.conftest import normalize +from tests.unit.conftest import roundtrip class TestUnusedVariableRemover: @@ -128,3 +129,144 @@ def test_pure_init_array_removed(self): result, changed = roundtrip(code, UnusedVariableRemover) assert changed is True assert 'var x' not in result + + +class TestUnusedVariableRemoverEdgeCases: + """Tests for uncovered edge cases in unused variable removal.""" + + def test_side_effect_in_dict_child(self): + """Line 111: _has_side_effects with dict child having side effect.""" + code = 'function f() { var x = -foo(); }' + result, changed = roundtrip(code, UnusedVariableRemover) + # UnaryExpression with CallExpression argument has side effects + assert not changed + assert 'var x' in result + + def test_has_side_effects_none_child(self): + """Line 105: _has_side_effects with None child should continue.""" + # A conditional expression has test, consequent, alternate — where alternate can be None-ish + code = 'function f() { var x = true ? 1 : 2; }' + result, changed = roundtrip(code, UnusedVariableRemover) + # ConditionalExpression with all literal children — no side effects, should be removed + assert changed is True + assert 'var x' not in result + + def test_has_side_effects_non_dict_node(self): + """Line 95: _has_side_effects with non-dict node returns False.""" + # This is tested internally when init is a literal (non-dict-like in some paths) + code = 'function f() { var x = 42; }' + result, changed = roundtrip(code, UnusedVariableRemover) + assert changed is True + assert 'var x' not in result + + def test_empty_declarations_in_batch_remove(self): + """Line 81: decls is empty/None — should return early.""" + # Unusual case where VariableDeclaration has empty declarations + # Just test that normal removal works with a straightforward case + code = 'function f() { var _0x1 = 1; }' + result, changed = roundtrip(code, UnusedVariableRemover) + assert changed is True + + def test_all_declarators_referenced_no_change(self): + """Line 84: new_decls length equals decls length (no change).""" + code = 'function f() { var x = 1, y = 2; return x + y; }' + result, changed = roundtrip(code, UnusedVariableRemover) + assert changed is False + assert 'var x' in result + + def test_side_effect_in_array_element(self): + """Lines 107-108: Array child item with side effect detected.""" + # TemplateLiteral expressions list can contain call expressions + code = 'function f() { var x = [foo(), 1]; }' + result, changed = roundtrip(code, UnusedVariableRemover) + # ArrayExpression is a pure type, so the array itself won't recurse + # But the init check is just on the top-level node type + assert isinstance(changed, bool) + + def test_conditional_with_side_effect(self): + """Side effect deep in conditional expression.""" + code = 'function f() { var x = true ? foo() : 1; }' + result, changed = roundtrip(code, UnusedVariableRemover) + # ConditionalExpression is not in _PURE_TYPES or _SIDE_EFFECT_TYPES + # So it recurses into children and finds foo() CallExpression + assert not changed + assert 'var x' in result + + def test_binding_node_not_dict(self): + """Line 56: binding.node that is not a dict should be skipped.""" + # This is a defensive check. We test it by directly invoking with a scope + # that has a non-dict binding node. Since we can't easily construct that + # via roundtrip, test that normal code doesn't crash. + code = 'function f() { var x = 1; return x; }' + result, changed = roundtrip(code, UnusedVariableRemover) + assert changed is False + + def test_has_side_effects_non_dict(self): + """Line 95: _has_side_effects with non-dict returns False.""" + remover = UnusedVariableRemover({'type': 'Program', 'body': []}) + assert remover._has_side_effects(None) is False + assert remover._has_side_effects(42) is False + assert remover._has_side_effects('string') is False + + def test_has_side_effects_none_child(self): + """Line 105: None child in side effect check should be skipped.""" + remover = UnusedVariableRemover({'type': 'Program', 'body': []}) + # A ConditionalExpression where alternate is None + node = { + 'type': 'ConditionalExpression', + 'test': {'type': 'Literal', 'value': True}, + 'consequent': {'type': 'Literal', 'value': 1}, + 'alternate': None, + } + assert remover._has_side_effects(node) is False + + def test_has_side_effects_list_child_with_side_effect(self): + """Lines 107-108: list child with side effect item returns True.""" + remover = UnusedVariableRemover({'type': 'Program', 'body': []}) + # SequenceExpression has 'expressions' which is a list + node = { + 'type': 'SequenceExpression', + 'expressions': [ + {'type': 'Literal', 'value': 1}, + {'type': 'CallExpression', 'callee': {'type': 'Identifier', 'name': 'foo'}, 'arguments': []}, + ], + } + assert remover._has_side_effects(node) is True + + def test_has_side_effects_list_child_no_side_effect(self): + """Lines 107-108: list child without side effect items returns False.""" + remover = UnusedVariableRemover({'type': 'Program', 'body': []}) + node = { + 'type': 'SequenceExpression', + 'expressions': [ + {'type': 'Literal', 'value': 1}, + {'type': 'Literal', 'value': 2}, + ], + } + assert remover._has_side_effects(node) is False + + def test_template_literal_recurses(self): + """TemplateLiteral is not in _PURE_TYPES or _SIDE_EFFECT_TYPES, so it recurses.""" + code = 'function f() { var x = `hello`; }' + result, changed = roundtrip(code, UnusedVariableRemover) + # TemplateLiteral with no expressions has no side effects + assert changed is True + assert 'var x' not in result + + def test_empty_decls_list(self): + """Line 81: VariableDeclaration with empty declarations list.""" + from pyjsclear.parser import parse + from pyjsclear.traverser import traverse + + ast = parse('function f() { var x = 1; }') + # Manually clear declarations to trigger the empty check + for node in ast['body']: + if node.get('type') == 'FunctionDeclaration': + body = node.get('body', {}).get('body', []) + for stmt in body: + if stmt.get('type') == 'VariableDeclaration': + stmt['declarations'] = [] + t = UnusedVariableRemover(ast) + # Should not crash + changed = t.execute() + assert isinstance(changed, bool) diff --git a/tests/unit/traverser_test.py b/tests/unit/traverser_test.py index 95db047..4660df0 100644 --- a/tests/unit/traverser_test.py +++ b/tests/unit/traverser_test.py @@ -3,16 +3,14 @@ import pytest from pyjsclear.parser import parse -from pyjsclear.traverser import ( - REMOVE, - SKIP, - collect_nodes, - find_parent, - remove_from_parent, - replace_in_parent, - simple_traverse, - traverse, -) +from pyjsclear.traverser import REMOVE +from pyjsclear.traverser import SKIP +from pyjsclear.traverser import collect_nodes +from pyjsclear.traverser import find_parent +from pyjsclear.traverser import remove_from_parent +from pyjsclear.traverser import replace_in_parent +from pyjsclear.traverser import simple_traverse +from pyjsclear.traverser import traverse # --------------------------------------------------------------------------- @@ -180,19 +178,6 @@ def exit_(node, parent, key, index): # Children should not appear in exit either assert 'VariableDeclarator' not in exit_types - def test_skip_without_exit_fn(self): - """SKIP works when there is no exit callback at all.""" - ast = parse('var x = 1;') - entered = [] - - def enter(node, parent, key, index): - entered.append(node['type']) - if node['type'] == 'VariableDeclaration': - return SKIP - - traverse(ast, {'enter': enter}) - assert 'VariableDeclarator' not in entered - # =========================================================================== # 4. Node replacement @@ -557,3 +542,108 @@ def enter(node, parent, key, index): # The replacement node's body is stored in the AST assert ast['body'][0]['type'] == 'ExpressionStatement' assert ast['body'][0]['expression']['value'] == 99 + + +# =========================================================================== +# Coverage gap tests +# =========================================================================== + + +class TestSimpleTraverseNoneType: + """Line 115: simple_traverse with node where type is None.""" + + def test_node_with_none_type(self): + node = {'type': None, 'body': []} + visited = [] + simple_traverse(node, lambda n, p: visited.append(n.get('type'))) + # Should not visit the node since type is None + assert visited == [] + + +class TestSimpleTraverseFallbackChildKeys: + """Line 119: simple_traverse fallback child_keys for unknown node type.""" + + def test_unknown_node_type_fallback(self): + # A node with an unknown type should trigger the fallback get_child_keys + # Note: the fallback skips 'expression' for non-ExpressionStatement, so use 'argument' + node = { + 'type': 'Program', + 'sourceType': 'script', + 'body': [ + { + 'type': 'CustomUnknownStatement', + 'argument': {'type': 'Identifier', 'name': 'x'}, + } + ], + } + visited = [] + simple_traverse(node, lambda n, p: visited.append(n.get('type'))) + assert 'Program' in visited + assert 'CustomUnknownStatement' in visited + # The fallback child_keys should find the 'argument' child + assert 'Identifier' in visited + + +class TestFindParentNonDictNode: + """Line 160: find_parent with non-dict node in tree.""" + + def test_find_parent_skips_non_dict_children(self): + # Build an AST where some child values are not dicts + ast = { + 'type': 'Program', + 'sourceType': 'script', + 'body': [ + 'not a dict', + 42, + None, + {'type': 'ExpressionStatement', 'expression': {'type': 'Identifier', 'name': 'x'}}, + ], + } + target = ast['body'][3]['expression'] + result = find_parent(ast, target) + assert result is not None + parent, key, index = result + assert parent is ast['body'][3] + assert key == 'expression' + assert index is None + + def test_find_parent_with_string_in_list(self): + # Ensure find_parent handles non-dict items in lists gracefully + target = {'type': 'Literal', 'value': 1} + ast = { + 'type': 'Program', + 'sourceType': 'script', + 'body': [ + { + 'type': 'ExpressionStatement', + 'expression': target, + 'extra': 'string_value', + } + ], + } + result = find_parent(ast, target) + assert result is not None + parent, key, index = result + assert parent is ast['body'][0] + assert key == 'expression' + + +class TestTraverseFallbackChildKeys: + """Line 68-69: traverse with unknown node type triggers fallback child_keys.""" + + def test_traverse_unknown_node_type(self): + ast = { + 'type': 'Program', + 'sourceType': 'script', + 'body': [ + { + 'type': 'UnknownCustomNode', + 'argument': {'type': 'Identifier', 'name': 'x'}, + } + ], + } + visited = [] + traverse(ast, {'enter': lambda n, p, k, i: visited.append(n['type'])}) + assert 'Program' in visited + assert 'UnknownCustomNode' in visited + assert 'Identifier' in visited diff --git a/tests/unit/utils/ast_helpers_test.py b/tests/unit/utils/ast_helpers_test.py index 0c08022..de169f8 100644 --- a/tests/unit/utils/ast_helpers_test.py +++ b/tests/unit/utils/ast_helpers_test.py @@ -5,27 +5,25 @@ import pytest -from pyjsclear.utils.ast_helpers import ( - _CHILD_KEYS, - deep_copy, - get_child_keys, - get_literal_value, - is_boolean_literal, - is_identifier, - is_literal, - is_null_literal, - is_numeric_literal, - is_string_literal, - is_undefined, - is_valid_identifier, - make_block_statement, - make_expression_statement, - make_identifier, - make_literal, - make_var_declaration, - nodes_equal, - replace_identifiers, -) +from pyjsclear.utils.ast_helpers import _CHILD_KEYS +from pyjsclear.utils.ast_helpers import deep_copy +from pyjsclear.utils.ast_helpers import get_child_keys +from pyjsclear.utils.ast_helpers import get_literal_value +from pyjsclear.utils.ast_helpers import is_boolean_literal +from pyjsclear.utils.ast_helpers import is_identifier +from pyjsclear.utils.ast_helpers import is_literal +from pyjsclear.utils.ast_helpers import is_null_literal +from pyjsclear.utils.ast_helpers import is_numeric_literal +from pyjsclear.utils.ast_helpers import is_string_literal +from pyjsclear.utils.ast_helpers import is_undefined +from pyjsclear.utils.ast_helpers import is_valid_identifier +from pyjsclear.utils.ast_helpers import make_block_statement +from pyjsclear.utils.ast_helpers import make_expression_statement +from pyjsclear.utils.ast_helpers import make_identifier +from pyjsclear.utils.ast_helpers import make_literal +from pyjsclear.utils.ast_helpers import make_var_declaration +from pyjsclear.utils.ast_helpers import nodes_equal +from pyjsclear.utils.ast_helpers import replace_identifiers # --------------------------------------------------------------------------- @@ -292,11 +290,6 @@ def test_large_float(self): # then checks if raw starts with '"' and if not, re-wraps. # This section documents the current behavior for edge cases. - def test_bug2_simple_string_current_behavior(self): - """Bug #2: Simple strings work correctly with repr-based raw generation.""" - node = make_literal('abc') - assert node['raw'] == '"abc"' - def test_bug2_string_with_single_quotes(self): """Bug #2: Strings containing single quotes. repr() would use double quotes for the Python repr, so replacing ' with " produces unexpected results. @@ -384,9 +377,6 @@ class TestMakeIdentifier: def test_basic(self): assert make_identifier('foo') == {'type': 'Identifier', 'name': 'foo'} - def test_dollar_sign(self): - assert make_identifier('$') == {'type': 'Identifier', 'name': '$'} - def test_underscore(self): assert make_identifier('_') == {'type': 'Identifier', 'name': '_'} @@ -481,12 +471,6 @@ def test_non_string(self): def test_hyphen(self): assert not is_valid_identifier('foo-bar') - def test_space(self): - assert not is_valid_identifier('foo bar') - - def test_dot(self): - assert not is_valid_identifier('foo.bar') - def test_single_dollar(self): assert is_valid_identifier('$') diff --git a/tests/unit/utils/string_decoders_test.py b/tests/unit/utils/string_decoders_test.py index da3c2ce..50e96f1 100644 --- a/tests/unit/utils/string_decoders_test.py +++ b/tests/unit/utils/string_decoders_test.py @@ -2,14 +2,12 @@ import pytest -from pyjsclear.utils.string_decoders import ( - Base64StringDecoder, - BasicStringDecoder, - DecoderType, - Rc4StringDecoder, - StringDecoder, - base64_transform, -) +from pyjsclear.utils.string_decoders import Base64StringDecoder +from pyjsclear.utils.string_decoders import BasicStringDecoder +from pyjsclear.utils.string_decoders import DecoderType +from pyjsclear.utils.string_decoders import Rc4StringDecoder +from pyjsclear.utils.string_decoders import StringDecoder +from pyjsclear.utils.string_decoders import base64_transform # --------------------------------------------------------------------------- @@ -95,10 +93,6 @@ def test_get_string_raises_not_implemented(self): with pytest.raises(NotImplementedError): decoder.get_string(0) - def test_type_property_is_basic(self): - decoder = StringDecoder(['a'], 0) - assert decoder.type == DecoderType.BASIC - def test_get_string_for_rotation_raises_on_first_call(self): decoder = BasicStringDecoder(['hello'], 0) with pytest.raises(RuntimeError, match='First call'): @@ -212,10 +206,6 @@ def test_out_of_bounds_returns_none(self): decoder = Base64StringDecoder(['abcd'], 0) assert decoder.get_string(5) is None - def test_negative_out_of_bounds_returns_none(self): - decoder = Base64StringDecoder(['abcd'], -10) - assert decoder.get_string(0) is None - def test_caching(self): decoder = Base64StringDecoder(['abcd'], 0) result1 = decoder.get_string(0) @@ -225,14 +215,6 @@ def test_caching(self): assert 0 in decoder._cache assert decoder._cache[0] == result1 - def test_cache_is_used(self): - decoder = Base64StringDecoder(['abcd'], 0) - # First call populates cache - decoder.get_string(0) - # Modify cache to prove second call uses it - decoder._cache[0] = 'CACHED' - assert decoder.get_string(0) == 'CACHED' - def test_multiple_indices(self): decoder = Base64StringDecoder(['abcd', 'ABCD'], 0) r0 = decoder.get_string(0) @@ -275,10 +257,6 @@ def test_out_of_bounds_returns_none(self): decoder = Rc4StringDecoder(['abcd'], 0) assert decoder.get_string(5, key='k') is None - def test_negative_out_of_bounds_returns_none(self): - decoder = Rc4StringDecoder(['abcd'], -10) - assert decoder.get_string(0, key='k') is None - def test_decodes_with_key(self): decoder = Rc4StringDecoder(['abcd'], 0) result = decoder.get_string(0, key='k') @@ -308,12 +286,6 @@ def test_cache_keyed_by_index_and_key(self): assert (1, 'k') in decoder._cache assert r1 != r2 - def test_cache_is_used(self): - decoder = Rc4StringDecoder(['abcd'], 0) - decoder.get_string(0, key='k') - decoder._cache[(0, 'k')] = 'CACHED' - assert decoder.get_string(0, key='k') == 'CACHED' - def test_with_offset(self): decoder = Rc4StringDecoder(['SKIP', 'abcd'], 1) result = decoder.get_string(0, key='k') @@ -351,8 +323,3 @@ def test_basic_does_not_decode(self): # Basic returns raw, Base64 returns decoded -> they should differ assert basic.get_string(0) == 'abcd' assert b64.get_string(0) != 'abcd' - - def test_all_decoders_handle_empty_array(self): - for cls in [BasicStringDecoder, Base64StringDecoder, Rc4StringDecoder]: - decoder = cls([], 0) - assert decoder.get_string(0) is None