js-confuser-vm 0.0.3 → 0.0.5

package/dist/transforms/bytecode/specializedOpcodes.js

@@ -0,0 +1,103 @@
+import { SOURCE_NODE_SYM } from "../../compiler.js";
+import { nextFreeSlot, U16_MAX } from "../utils/op-utils.js";
+
+// Creates specialized opcodes for the most frequent (OPCODE + single_integer_operand) pairs.
+// Example: [OP.LOAD_CONST, 1] becomes [SPECIALIZED_LOAD_CONST_1].
+// Only instructions with *exactly one numeric operand* are considered.
+// MAKE_CLOSURE and any instruction with zero / multiple operands are skipped.
+// Runs after selfModifying but before resolveLabels (operands stay plain numbers).
+export function specializedOpcodes(bc, compiler) {
+  // ── Collect used opcodes exactly as specified ─────────────────────────────
+  const usedOpcodes = new Set(Object.keys(compiler.OP_NAME).map(k => parseInt(k, 10)).filter(v => !isNaN(v)));
+  if (usedOpcodes.size > U16_MAX) return {
+    bytecode: bc
+  };
+
+  // ── Step 1: count frequency of eligible (op, operand) pairs ───────────────
+  const freqMap = new Map();
+  for (const instr of bc) {
+    const op = instr[0];
+    if (op === null || op === compiler.OP.MAKE_CLOSURE) continue;
+
+    // Must have exactly one operand and it must be a plain number
+    if (instr.length !== 2) continue;
+    const operand = instr[1];
+    const key = `${op},${operand}`;
+    const entry = freqMap.get(key);
+    if (entry) {
+      entry.count++;
+    } else {
+      freqMap.set(key, {
+        op,
+        operand,
+        count: 1
+      });
+    }
+  }
+
+  // ── Step 2: keep combinations that appear >= 2 times, sort by frequency ───
+  const candidates = Array.from(freqMap.values()).filter(e => e.count >= 1).sort((a, b) => b.count - a.count);
+  if (candidates.length === 0) return {
+    bytecode: bc
+  };
+
+  // ── Step 3: assign free opcode slots to the best candidates ───────────────
+  const sigToSpecial = new Map();
+  const specializedOps = {};
+  for (let i = 0; i < candidates.length; i++) {
+    const specialOp = nextFreeSlot(usedOpcodes);
+    if (specialOp === -1) break;
+    const {
+      op: originalOp,
+      operand
+    } = candidates[i];
+    const key = `${originalOp},${JSON.stringify(operand)}`;
+    sigToSpecial.set(key, specialOp);
+    specializedOps[specialOp] = {
+      originalOp,
+      operand
+    };
+
+    // Register a human-readable name for disassembly / debugging
+    const originalName = compiler.OP_NAME[originalOp] ?? `OP_${originalOp}`;
+    compiler.OP_NAME[specialOp] = `${originalName}_${JSON.stringify(operand)}`;
+  }
+
+  // Store mapping so the interpreter knows how to dispatch the specialized op
+  compiler.SPECIALIZED_OPS = specializedOps;
+
+  // ── Step 4: replace matching instructions with the new single-byte opcode ─
+  const result = [];
+  for (const instr of bc) {
+    const op = instr[0];
+    // Only consider instructions with exactly one numeric operand
+    if (op === null || instr.length !== 2 || op === compiler.OP.MAKE_CLOSURE) {
+      result.push(instr);
+      continue;
+    }
+    const operand = instr[1];
+    const key = `${op},${JSON.stringify(operand)}`;
+    if (sigToSpecial.has(key)) {
+      const specialOpCode = sigToSpecial.get(key);
+      const operandAsObject = typeof operand === "object" && operand ? operand : {
+        type: "number",
+        value: operand,
+        resolvedValue: operand
+      };
+      const newOperand = {
+        ...operandAsObject,
+        placeholder: true
+      };
+      const newInstr = [specialOpCode, newOperand];
+
+      // Preserve source-node information for error reporting
+      newInstr[SOURCE_NODE_SYM] = instr[SOURCE_NODE_SYM];
+      result.push(newInstr);
+    } else {
+      result.push(instr);
+    }
+  }
+  return {
+    bytecode: result
+  };
+}

package/dist/transforms/runtime/macroOpcodes.js

@@ -0,0 +1,88 @@
+import * as t from "@babel/types";
+import traverseImport from "@babel/traverse";
+import { ok } from "assert";
+const traverse = traverseImport.default || traverseImport;
+
+// Extract the real statement list from a SwitchCase consequent, normalising
+// the two forms that appear in the runtime:
+//   • A single wrapping BlockStatement  →  use its .body
+//   • Statements listed directly        →  use as-is
+// In both cases trailing BreakStatement / EmptyStatement are filtered out.
+function extractCaseBody(switchCase) {
+  let stmts;
+  if (switchCase.consequent.length === 1 && t.isBlockStatement(switchCase.consequent[0])) {
+    stmts = switchCase.consequent[0].body;
+  } else {
+    stmts = switchCase.consequent;
+  }
+  return stmts.filter(s => !t.isBreakStatement(s) && !t.isEmptyStatement(s));
+}
+
+// Append a generated switch case for every entry in compiler.MACRO_OPS.
+// Each case inlines the constituent case bodies directly — no operand stack,
+// no substitution needed.  Because every opcode handler now reads its own
+// operands via this._operand(), those calls naturally consume the inline
+// operands that macroOpcodes.ts embedded on the macro instruction.
+// Must be called BEFORE applyShuffleOpcodes so the new cases get shuffled.
+export function applyMacroOpcodes(ast, compiler) {
+  let switchStatement = null;
+  traverse(ast, {
+    SwitchStatement(path) {
+      if (path.node.leadingComments?.some(c => c.value.includes("@SWITCH"))) {
+        switchStatement = path.node;
+        path.stop();
+      }
+    }
+  });
+  ok(switchStatement, "Could not find @SWITCH statement for macro opcodes");
+
+  // Build a map  opName → SwitchCase  from the existing OP.xxx case tests.
+  const nameToCaseMap = new Map();
+  for (const sc of switchStatement.cases) {
+    const test = sc.test;
+    if (test && t.isMemberExpression(test) && t.isIdentifier(test.object, {
+      name: "OP"
+    }) && t.isIdentifier(test.property)) {
+      nameToCaseMap.set(test.property.name, sc);
+    }
+  }
+  for (const [macroOpStr, constituentOps] of Object.entries(compiler.MACRO_OPS)) {
+    const macroOpCode = Number(macroOpStr);
+    const N = constituentOps.length;
+
+    // Resolve each constituent op value → case node via OP_NAME lookup.
+    const constituentCases = [];
+    let allFound = true;
+    for (const opVal of constituentOps) {
+      const opName = compiler.OP_NAME[opVal];
+      if (!opName) {
+        allFound = false;
+        break;
+      }
+      const found = nameToCaseMap.get(opName);
+      if (!found) {
+        allFound = false;
+        break;
+      }
+      constituentCases.push(found);
+    }
+    if (!allFound) continue;
+    const opNames = constituentOps.map(v => compiler.OP_NAME[v] ?? `OP_${v}`);
+
+    // ── Build the macro case body ──────────────────────────────────────────
+    // Clone and inline each sub-instruction's case body directly.
+    // No operand substitution needed: each body already calls this._operand()
+    // to read its own operands, which will consume the inline operands that
+    // macroOpcodes.ts embedded on the macro instruction in order.
+    const bodyStmts = [];
+    for (let i = 0; i < N; i++) {
+      const subStmts = extractCaseBody(constituentCases[i]).map(s => t.cloneNode(s, true));
+      if (subStmts.length > 0) {
+        t.addComment(subStmts[0], "leading", ` ${opNames[i]}`, true);
+        bodyStmts.push(...subStmts);
+      }
+    }
+    bodyStmts.push(t.breakStatement());
+    switchStatement.cases.push(t.switchCase(t.numericLiteral(macroOpCode), [t.blockStatement(bodyStmts)]));
+  }
+}

package/dist/transforms/runtime/minify.js

@@ -0,0 +1 @@
+export { minify as applyMinify } from "../../minify.js";

package/dist/transforms/runtime/shuffleOpcodes.js

@@ -0,0 +1,20 @@
+import traverseImport from "@babel/traverse";
+import { ok } from "assert";
+import { shuffle } from "../utils/random-utils.js";
+const traverse = traverseImport.default || traverseImport;
+
+// Randomly reorder the switch cases inside the @SWITCH statement so the
+// opcode handler order varies per build.
+export function applyShuffleOpcodes(ast) {
+  let switchStatement = null;
+  traverse(ast, {
+    SwitchStatement(path) {
+      if (path.node.leadingComments?.some(c => c.value.includes("@SWITCH"))) {
+        switchStatement = path.node;
+        path.stop();
+      }
+    }
+  });
+  ok(switchStatement, "Could not find opcode handlers switch statement");
+  switchStatement.cases = shuffle(switchStatement.cases);
+}

package/dist/transforms/runtime/specializedOpcodes.js

@@ -0,0 +1,102 @@
+import * as t from "@babel/types";
+import traverseImport from "@babel/traverse";
+import { ok } from "assert";
+const traverse = traverseImport.default || traverseImport;
+
+// Extract the real statement list from a SwitchCase consequent (identical to the
+// helper used by applyMacroOpcodes so the two files stay in sync).
+function extractCaseBody(switchCase) {
+  let stmts;
+  if (switchCase.consequent.length === 1 && t.isBlockStatement(switchCase.consequent[0])) {
+    stmts = switchCase.consequent[0].body;
+  } else {
+    stmts = switchCase.consequent;
+  }
+  return stmts.filter(s => !t.isBreakStatement(s) && !t.isEmptyStatement(s));
+}
+
+// Inline a fixed numeric operand in place of every `this._operand()` call.
+// Because specialized opcodes are only created for instructions that have
+// *exactly one* numeric operand, every `_operand()` call inside the original
+// handler is replaced by the constant value that was baked into the opcode.
+function inlineFixedOperand(bodyStmts, resolvedValue) {
+  // Wrap the statements in a temporary BlockStatement so traverse has a root.
+  // The replacement mutates the original statement objects in place.
+  traverse(t.blockStatement(bodyStmts), {
+    noScope: true,
+    CallExpression(path) {
+      const callee = path.node.callee;
+      if (t.isMemberExpression(callee) && t.isThisExpression(callee.object) && t.isIdentifier(callee.property, {
+        name: "_operand"
+      }) && path.node.arguments.length === 0) {
+        path.replaceWith(t.numericLiteral(resolvedValue));
+      }
+    }
+  });
+}
+
+// Append a generated switch case for every entry in compiler.SPECIALIZED_OPS.
+// Each case is a clone of the original opcode’s handler with `this._operand()`
+// replaced by the constant integer that was captured at compile time.
+// Must be called AFTER applyMacroOpcodes (so the original cases exist) but
+// BEFORE applyShuffleOpcodes so the new specialized cases also get shuffled.
+export function applySpecializedOpcodes(ast, bytecode, compiler) {
+  let switchStatement = null;
+  traverse(ast, {
+    SwitchStatement(path) {
+      if (path.node.leadingComments?.some(c => c.value.includes("@SWITCH"))) {
+        switchStatement = path.node;
+        path.stop();
+      }
+    }
+  });
+  ok(switchStatement, "Could not find @SWITCH statement for specialized opcodes");
+
+  // Build a map  opName → SwitchCase  from the existing OP.xxx case tests.
+  const nameToCaseMap = new Map();
+  for (const sc of switchStatement.cases) {
+    const test = sc.test;
+    if (test && t.isMemberExpression(test) && t.isIdentifier(test.object, {
+      name: "OP"
+    }) && t.isIdentifier(test.property)) {
+      nameToCaseMap.set(test.property.name, sc);
+    }
+  }
+  if (!compiler.SPECIALIZED_OPS) return;
+  for (const [specialOpStr, info] of Object.entries(compiler.SPECIALIZED_OPS)) {
+    const specialOpCode = Number(specialOpStr);
+    const {
+      originalOp,
+      operand
+    } = info;
+    const newName = compiler.OP_NAME[specialOpCode];
+    const originalName = compiler.OP_NAME[originalOp];
+    if (!originalName) continue;
+    const originalCase = nameToCaseMap.get(originalName);
+    if (!originalCase) continue;
+
+    // Clone the original handler body
+    const bodyStmts = extractCaseBody(originalCase).map(s => t.cloneNode(s, true));
+    const placedOperand = info.resolvedOperand || {
+      resolvedValue: 1337
+    };
+    ok(placedOperand !== undefined, `Could not find operand for original opcode ${newName}`);
+    const resolvedValue = placedOperand?.resolvedValue ?? placedOperand;
+    if (typeof resolvedValue !== "number") {
+      console.error(resolvedValue);
+    }
+    ok(typeof resolvedValue === "number", "Expected a numeric operand value");
+
+    // Replace this._operand() with the baked-in constant
+    inlineFixedOperand(bodyStmts, resolvedValue);
+
+    // Add a leading comment so the generated source stays readable
+    if (bodyStmts.length > 0) {
+      t.addComment(bodyStmts[0], "leading", ` ${compiler.OP_NAME[specialOpCode]} (specialized)`, true);
+    }
+    bodyStmts.push(t.breakStatement());
+
+    // Insert the new specialized case into the big switch
+    switchStatement.cases.push(t.switchCase(t.numericLiteral(specialOpCode), [t.blockStatement(bodyStmts)]));
+  }
+}

package/dist/transforms/utils/op-utils.js

@@ -0,0 +1,25 @@
+import { getRandomInt } from "./random-utils.js";
+export const U16_MAX = 0xffff; // bytecode operands are u16
+
+/** Returns the next free opcode slot, or -1 when the space is exhausted. */
+export function nextFreeSlot(usedOpcodes) {
+  if (usedOpcodes.size > U16_MAX) return -1;
+  let attempts = 0;
+  while (attempts++ < 512) {
+    const candidate = getRandomInt(0, U16_MAX);
+    if (!usedOpcodes.has(candidate)) {
+      usedOpcodes.add(candidate);
+      return candidate;
+    }
+  }
+  // Fallback: linear scan from a random start
+  const start = getRandomInt(0, U16_MAX);
+  for (let i = 0; i <= U16_MAX; i++) {
+    const v = start + i & U16_MAX;
+    if (!usedOpcodes.has(v)) {
+      usedOpcodes.add(v);
+      return v;
+    }
+  }
+  return -1;
+}

package/dist/{random.js → transforms/utils/random-utils.js}

@@ -14,9 +14,9 @@ export function getRandomInt(min, max) {
   return Math.floor(Math.random() * (max - min + 1)) + min;
 }
 
-/**
- * Shuffles an array in-place using the Fisher-Yates algorithm.
- * @param array - The array to shuffle (mutated)
+/**
+ * Shuffles an array in-place using the Fisher-Yates algorithm.
+ * @param array - The array to shuffle (mutated)
  */
 export function shuffle(array) {
   for (let i = array.length - 1; i > 0; i--) {

package/dist/types.js

@@ -1,9 +1,11 @@
 // Bytecode supports both real instructions and IR pseudo-instructions
-// Real instruction: [OP.ADD, 5]
+// Real instruction: [OP.ADD, 5]  or multi-operand: [OP.MAKE_CLOSURE, labelRef, 2, 3, 0]
 // IR instruction: [null, { type: "defineLabel", label: "FN_ENTRY_1" }]
 
 // IR instructions are used to hold symbolic information during compilation
-// All "null" instructions are dropped before assembly time
+// All "null" instructions are dropped before assembly time.
+// Instructions may carry any number of operands; the flat output serializes
+// each operand as a separate u16 slot in the bytecode array.
 
 export function constantOperand(value) {
   return {

package/index.ts

@@ -1,22 +1,34 @@
-import JsConfuserVM from "./src/index.ts";
-import { readFileSync, writeFileSync } from "fs";
-
-async function main() {
-  // Compile and write the output to a file
-  const sourceCode = readFileSync("input.js", "utf-8");
-  const { code: output } = await JsConfuserVM.obfuscate(sourceCode, {
-    selfModifying: true,
-  });
-
-  writeFileSync("output.js", output, "utf-8");
-
-  // Eval the code like our test suite does
-  var window = { TEST_OUTPUT: null };
-  eval(output);
-  console.log(window.TEST_OUTPUT);
-
-  // Minify using Google Closure Compiler (optional)
-  // import("./minify.js");
-}
-
-main();
+import JsConfuserVM from "./src/index.ts";
+import { readFileSync, writeFileSync } from "fs";
+
+async function main() {
+  // Compile and write the output to a file
+  const sourceCode = readFileSync("input.js", "utf-8");
+
+  const { code: orginalOutput } = await JsConfuserVM.obfuscate(sourceCode, {});
+
+  const { code: output } = await JsConfuserVM.obfuscate(sourceCode, {
+    target: "browser", // or "node"
+    // randomizeOpcodes: true, // randomize the opcode numbers?
+    // shuffleOpcodes: true, // shuffle order of opcode handlers in the runtime?
+    // encodeBytecode: true, // encode bytecode? when off, comments for instructions are added
+    // selfModifying: true, // do self-modifying bytecode for function bodies?
+    // macroOpcodes: true, // create combined opcodes for repeated instruction sequences?
+    // specializedOpcodes: true, // create specialized opcodes for commonly used opcode+operand pairs?
+    // timingChecks: true, // add timing checks to detect debuggers?
+    // minify: true, // pass final output through Google Closure Compiler? (
+  });
+
+  writeFileSync("output.original.js", orginalOutput, "utf-8");
+  writeFileSync("output.js", output, "utf-8");
+
+  // Eval the code like our test suite does
+  var window = { TEST_OUTPUT: null };
+  eval(output);
+  console.log(window.TEST_OUTPUT);
+
+  // Minify using Google Closure Compiler (optional)
+  // import("./minify.js");
+}
+
+main();

package/jest-strip-types.js

@@ -1,10 +1,10 @@
-import { stripTypeScriptTypes } from 'node:module';
-
-export default {
-  process(code, filePath) {
-    if (filePath.endsWith('.ts')) {
-      return { code: stripTypeScriptTypes(code) };
-    }
-    return { code };
-  },
-};
+import { stripTypeScriptTypes } from 'node:module';
+
+export default {
+  process(code, filePath) {
+    if (filePath.endsWith('.ts')) {
+      return { code: stripTypeScriptTypes(code) };
+    }
+    return { code };
+  },
+};

package/jest.config.js

@@ -1,28 +1,35 @@
-const OPTIONS_MATRIX = [
-  { displayName: "default", VM_OPTIONS: {} },
-  { displayName: "randomizeOpcodes", VM_OPTIONS: { randomizeOpcodes: true } },
-  { displayName: "shuffleOpcodes", VM_OPTIONS: { shuffleOpcodes: true } },
-  { displayName: "encodeBytecode", VM_OPTIONS: { encodeBytecode: true } },
-  { displayName: "selfModifying", VM_OPTIONS: { selfModifying: true } },
-  { displayName: "timingChecks", VM_OPTIONS: { timingChecks: true } },
-  {
-    displayName: "all",
-    VM_OPTIONS: {
-      randomizeOpcodes: true,
-      shuffleOpcodes: true,
-      encodeBytecode: true,
-      selfModifying: true,
-      timingChecks: true,
-    },
-  },
-];
-
-export default {
-  projects: OPTIONS_MATRIX.map(({ displayName, VM_OPTIONS }) => ({
-    displayName,
-    extensionsToTreatAsEsm: [".ts"],
-    moduleFileExtensions: ["ts", "js", "json"],
-    transform: { "\\.ts$": "./jest-strip-types.js" },
-    globals: { VM_OPTIONS },
-  })),
-};
+const OPTIONS_MATRIX = [
+  { displayName: "default", VM_OPTIONS: {} },
+  { displayName: "randomizeOpcodes", VM_OPTIONS: { randomizeOpcodes: true } },
+  { displayName: "shuffleOpcodes", VM_OPTIONS: { shuffleOpcodes: true } },
+  { displayName: "encodeBytecode", VM_OPTIONS: { encodeBytecode: true } },
+  { displayName: "selfModifying", VM_OPTIONS: { selfModifying: true } },
+  { displayName: "timingChecks", VM_OPTIONS: { timingChecks: true } },
+  { displayName: "macroOpcodes", VM_OPTIONS: { macroOpcodes: true } },
+  {
+    displayName: "specializedOpcodes",
+    VM_OPTIONS: { specializedOpcodes: true },
+  },
+  {
+    displayName: "all",
+    VM_OPTIONS: {
+      randomizeOpcodes: true,
+      shuffleOpcodes: true,
+      encodeBytecode: true,
+      selfModifying: true,
+      timingChecks: true,
+      macroOpcodes: true,
+      specializedOpcodes: true,
+    },
+  },
+];
+
+export default {
+  projects: OPTIONS_MATRIX.map(({ displayName, VM_OPTIONS }) => ({
+    displayName,
+    extensionsToTreatAsEsm: [".ts"],
+    moduleFileExtensions: ["ts", "js", "json"],
+    transform: { "\\.ts$": "./jest-strip-types.js" },
+    globals: { VM_OPTIONS },
+  })),
+};

package/package.json

@@ -1,48 +1,49 @@
-{
-  "name": "js-confuser-vm",
-  "version": "0.0.3",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "babel src --out-dir dist --extensions '.ts,.js'",
-    "index": "NODE_OPTIONS=\"--disable-warning=ExperimentalWarning\" node index.ts",
-    "test": "NODE_OPTIONS=\"--experimental-vm-modules --experimental-strip-types --disable-warning=ExperimentalWarning\" jest --coverage --coverageReporters=html --selectProjects default",
-    "test-all": "NODE_OPTIONS=\"--experimental-vm-modules --experimental-strip-types --disable-warning=ExperimentalWarning\" jest --coverage --coverageReporters=html",
-    "test262": "NODE_OPTIONS=\"--experimental-vm-modules --experimental-strip-types --disable-warning=ExperimentalWarning\" node test262-scripts/run-test262.ts",
-    "prepublishOnly": "npm run build && npm run test"
-  },
-  "type": "module",
-  "keywords": [
-    "vm",
-    "virtual machine",
-    "obfuscator",
-    "obfuscation",
-    "uglify",
-    "code protection",
-    "javascript obfuscator",
-    "js obfuscator"
-  ],
-  "author": "MichaelXF",
-  "license": "MIT",
-  "description": "",
-  "dependencies": {
-    "@babel/generator": "^7.29.1",
-    "@babel/parser": "^7.29.0",
-    "@babel/traverse": "^7.29.0",
-    "@babel/types": "^7.29.0",
-    "google-closure-compiler": "^20260216.0.0",
-    "json5": "^2.2.3"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.28.6",
-    "@babel/core": "^7.29.0",
-    "@babel/preset-env": "^7.29.0",
-    "@babel/preset-typescript": "^7.28.5",
-    "@types/node": "^25.3.0",
-    "babel-plugin-module-resolver": "^5.0.2",
-    "babel-plugin-replace-import-extension": "^1.1.5",
-    "jest": "^30.2.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}
+{
+  "name": "js-confuser-vm",
+  "version": "0.0.5",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "babel src --out-dir dist --extensions \".ts,.js\"",
+    "index": "cross-env NODE_OPTIONS=\"--disable-warning=ExperimentalWarning\" node index.ts",
+    "test": "cross-env NODE_OPTIONS=\"--experimental-vm-modules --experimental-strip-types --disable-warning=ExperimentalWarning\" jest --coverage --coverageReporters=html --selectProjects default",
+    "test-all": "cross-env NODE_OPTIONS=\"--experimental-vm-modules --experimental-strip-types --disable-warning=ExperimentalWarning\" jest --coverage --coverageReporters=html",
+    "test262": "cross-env NODE_OPTIONS=\"--experimental-vm-modules --experimental-strip-types --disable-warning=ExperimentalWarning\" node test262-scripts/run-test262.ts",
+    "prepublishOnly": "npm run build && npm run test"
+  },
+  "type": "module",
+  "keywords": [
+    "vm",
+    "virtual machine",
+    "obfuscator",
+    "obfuscation",
+    "uglify",
+    "code protection",
+    "javascript obfuscator",
+    "js obfuscator"
+  ],
+  "author": "MichaelXF",
+  "license": "MIT",
+  "description": "",
+  "dependencies": {
+    "@babel/generator": "^7.29.1",
+    "@babel/parser": "^7.29.0",
+    "@babel/traverse": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "google-closure-compiler": "^20260216.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.29.0",
+    "@babel/preset-env": "^7.29.0",
+    "@babel/preset-typescript": "^7.28.5",
+    "@types/node": "^25.3.0",
+    "babel-plugin-module-resolver": "^5.0.2",
+    "babel-plugin-replace-import-extension": "^1.1.5",
+    "cross-env": "^10.1.0",
+    "glob": "^13.0.6",
+    "jest": "^30.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}