js-confuser-vm 0.0.4 → 0.0.6

package/dist/transforms/bytecode/specializedOpcodes.js

@@ -0,0 +1,113 @@
+import { SOURCE_NODE_SYM } from "../../compiler.js";
+import { getInstructionSize, 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 other N-sized instructions cannot be specialized
+// Runs after selfModifying but before resolveLabels (operands stay plain numbers).
+export function specializedOpcodes(bc, compiler) {
+  const disallowedOps = new Set([compiler.OP.MAKE_CLOSURE, compiler.OP.BUILD_ARRAY, compiler.OP.BUILD_OBJECT, compiler.OP.CALL, compiler.OP.CALL_METHOD, compiler.OP.NEW]);
+
+  // ── 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 || disallowedOps.has(op)) continue;
+
+    // Only supports between 1-6 operands
+    const operandCount = getInstructionSize(instr) - 1;
+    if (operandCount < 1 || operandCount > 6) continue;
+    const operands = instr.slice(1);
+    const operandsKey = JSON.stringify(operands);
+    const key = `${op},${operandsKey}`;
+    const entry = freqMap.get(key);
+    if (entry) {
+      entry.occurences++;
+    } else {
+      freqMap.set(key, {
+        op,
+        operands,
+        operandsKey,
+        occurences: 1
+      });
+    }
+  }
+
+  // ── Step 2: keep combinations that appear >= 2 times, sort by frequency ───
+  const candidates = Array.from(freqMap.values()).filter(e => e.occurences >= 1).sort((a, b) => b.occurences - a.occurences);
+  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,
+      operands,
+      operandsKey
+    } = candidates[i];
+    const key = `${originalOp},${operandsKey}`;
+    sigToSpecial.set(key, specialOp);
+    specializedOps[specialOp] = {
+      originalOp,
+      operands
+    };
+
+    // Register a human-readable name for disassembly / debugging
+    const originalName = compiler.OP_NAME[originalOp] ?? `OP_${originalOp}`;
+    compiler.OP_NAME[specialOp] = `${originalName}_${JSON.stringify(operandsKey)}`;
+  }
+
+  // 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 one or more operands
+    if (op === null || instr.length <= 1 || op === compiler.OP.MAKE_CLOSURE) {
+      result.push(instr);
+      continue;
+    }
+    const operands = instr.slice(1);
+    const operandsKey = JSON.stringify(operands);
+    const key = `${op},${operandsKey}`;
+    const specialOpCode = sigToSpecial.get(key);
+    if (!specialOpCode) {
+      result.push(instr);
+      continue;
+    }
+    const newOperands = operands.map(operand => {
+      const operandAsObject = typeof operand === "object" && operand ? operand : {
+        type: "number",
+        value: operand,
+        resolvedValue: operand
+      };
+      const newOperand = {
+        ...operandAsObject,
+        placeholder: true
+      };
+      return newOperand;
+    });
+    const newInstr = [specialOpCode, ...newOperands];
+
+    // Preserve source-node information for error reporting
+    newInstr[SOURCE_NODE_SYM] = instr[SOURCE_NODE_SYM];
+    result.push(newInstr);
+  }
+  return {
+    bytecode: result
+  };
+}

package/dist/transforms/runtime/aliasedOpcodes.js

@@ -0,0 +1,134 @@
+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.
+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));
+}
+
+// Replace every `this._operand()` call in bodyStmts with `_operands[i]`
+// where i is the call's sequential index (0-based).
+// Returns the number of replacements performed.
+function replaceOperandCalls(bodyStmts) {
+  let replaced = 0;
+  traverse(t.blockStatement(bodyStmts), {
+    noScope: true,
+    CallExpression(path) {
+      const callee = path.node.callee;
+      const isMethodCall = methodName => {
+        return t.isMemberExpression(callee) && t.isThisExpression(callee.object) && t.isIdentifier(callee.property, {
+          name: methodName
+        }) && path.node.arguments.length === 0;
+      };
+
+      // Replace with _operands[i]
+      const createOperandAccess = () => {
+        return t.memberExpression(t.identifier("_operands"), t.numericLiteral(replaced++), true // computed
+        );
+      };
+      if (isMethodCall("_operand")) {
+        path.replaceWith(createOperandAccess());
+      }
+      if (isMethodCall("_constant")) {
+        path.node.arguments = [createOperandAccess(), createOperandAccess()];
+      }
+    }
+  });
+  return replaced;
+}
+
+// Appends a generated switch case for every entry in compiler.ALIASED_OPS.
+// Each alias case:
+//   1. Reads all operands eagerly into `_unsortedOperands` (in the shuffled
+//      bytecode order) via sequential this._operand() calls.
+//   2. Restores the original operand order into `_operands` using the INVERSE
+//      of the stored `order` permutation:
+//        inverseOrder[order[i]] = i
+//        _operands[j] = _unsortedOperands[inverseOrder[j]]
+//      This is necessary because the bytecode stored originalOperands[order[i]]
+//      at slot i, so recovering originalOperands[j] requires the inverse lookup.
+//   3. Executes a clone of the original handler body where every
+//      this._operand() has been replaced by the corresponding `_operands[i]`.
+//
+// Must run AFTER applyMacroOpcodes / applySpecializedOpcodes (so original
+// cases already exist) but BEFORE applyShuffleOpcodes (so the new alias
+// cases are also shuffled into the handler order).
+export function applyAliasedOpcodes(ast, compiler) {
+  if (!compiler.ALIASED_OPS || Object.keys(compiler.ALIASED_OPS).length === 0) return;
+  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 aliased opcodes");
+
+  // Build opName → SwitchCase map from 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 [aliasOpStr, info] of Object.entries(compiler.ALIASED_OPS)) {
+    const aliasOpCode = Number(aliasOpStr);
+    const {
+      originalOp,
+      order
+    } = info;
+    const arity = order.length;
+    const originalName = compiler.OP_NAME[originalOp];
+    if (!originalName) continue;
+    const originalCase = nameToCaseMap.get(originalName);
+    if (!originalCase) continue;
+
+    // Clone the original handler body (deep clone so we don't mutate the source)
+    const bodyStmts = extractCaseBody(originalCase).map(s => t.cloneNode(s, true));
+
+    // Replace this._operand() calls with _operands[i]
+    const replaced = replaceOperandCalls(bodyStmts);
+
+    // If the handler has a different number of _operand() calls than our
+    // recorded arity, skip this alias (variable-operand handler guard).
+    if (replaced !== arity) continue;
+
+    // Build: var _unsortedOperands = [this._operand(), this._operand(), ...]
+    // Reads operands in the NEW (shuffled) bytecode order.
+    const unsortedInit = t.variableDeclaration("let", [t.variableDeclarator(t.identifier("_unsortedOperands"), t.arrayExpression(Array.from({
+      length: arity
+    }, () => t.callExpression(t.memberExpression(t.thisExpression(), t.identifier("_operand")), []))))]);
+
+    // The inverse permutation maps original position j → unsorted index i,
+    // because the bytecode stored originalOperands[order[i]] at slot i.
+    // inverseOrder[j] = i  means: original operand j lives at _unsortedOperands[i]
+    const inverseOrder = new Array(arity);
+    for (let i = 0; i < arity; i++) {
+      inverseOrder[order[i]] = i;
+    }
+
+    // Build: var _operands = [_unsortedOperands[inverseOrder[0]], ...]
+    // Restores the original operand order expected by the handler body.
+    const operandsInit = t.variableDeclaration("let", [t.variableDeclarator(t.identifier("_operands"), t.arrayExpression(inverseOrder.map(idx => t.memberExpression(t.identifier("_unsortedOperands"), t.numericLiteral(idx), true // computed
+    ))))]);
+    const allStmts = [unsortedInit, operandsInit, ...bodyStmts];
+
+    // Add a leading comment for readability in non-minified output
+    t.addComment(allStmts[0], "leading", ` ${compiler.OP_NAME[aliasOpCode]} (order: [${order.join(",")}])`, true);
+    allStmts.push(t.breakStatement());
+    switchStatement.cases.push(t.switchCase(t.numericLiteral(aliasOpCode), [t.blockStatement(allStmts)]));
+  }
+}

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,107 @@
+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 inlineFixedOperands(bodyStmts, resolvedValues) {
+  // Wrap the statements in a temporary BlockStatement so traverse has a root.
+  // The replacement mutates the original statement objects in place.
+  var replaced = 0;
+  traverse(t.blockStatement(bodyStmts), {
+    noScope: true,
+    CallExpression(path) {
+      const callee = path.node.callee;
+      const isMethodCall = methodName => {
+        return t.isMemberExpression(callee) && t.isThisExpression(callee.object) && t.isIdentifier(callee.property, {
+          name: methodName
+        }) && path.node.arguments.length === 0;
+      };
+      if (isMethodCall("_operand")) {
+        path.replaceWith(t.numericLiteral(resolvedValues[replaced++]));
+      }
+      if (isMethodCall("_constant")) {
+        path.node.arguments = [t.numericLiteral(resolvedValues[replaced++]), t.numericLiteral(resolvedValues[replaced++])];
+      }
+    }
+  });
+  ok(replaced === resolvedValues.length, `Expected to replace ${resolvedValues.length} operands, but replaced ${replaced}`);
+}
+
+// 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,
+      operands
+    } = 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 placedOperands = info.resolvedOperands;
+    ok(placedOperands, `Could not find operand for original opcode ${newName}`);
+    const resolvedValues = placedOperands.map(placedOperand => {
+      return placedOperand?.resolvedValue ?? placedOperand;
+    });
+    ok(!resolvedValues.find(v => typeof v !== "number"), "Expected a numeric operand value");
+
+    // Replace this._operand() with the baked-in constant
+    inlineFixedOperands(bodyStmts, resolvedValues);
+
+    // 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/{src/transforms/utils/op-utils.ts → dist/transforms/utils/op-utils.js}

@@ -1,26 +1,25 @@
-import { getRandomInt } from "./random-utils.ts";
-
-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: Set<number>): number {
-  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;
-}
+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/transforms/utils/random-utils.js

@@ -0,0 +1,27 @@
+import { ok } from "assert";
+export function getPlaceholder() {
+  return Math.random().toString(36).substring(2, 15);
+}
+export function choice(elements) {
+  ok(elements.length > 0, "choice() called on empty sequence");
+  return elements[Math.floor(Math.random() * elements.length)];
+}
+export function getRandom() {
+  return Math.random();
+}
+export function getRandomInt(min, max) {
+  ok(min <= max, "min must be <= 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)
+ */
+export function shuffle(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+}

package/dist/types.js

@@ -0,0 +1,15 @@
+// Bytecode supports both real instructions and IR pseudo-instructions
+// 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.
+// 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 {
+    type: "constant",
+    value: value
+  };
+}

package/dist/utils/op-utils.js

@@ -0,0 +1,29 @@
+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;
+}
+export function getInstructionSize(instr) {
+  const size = instr.filter(op => op?.placeholder !== true).length;
+  return size;
+}

package/dist/utils/random-utils.js

@@ -0,0 +1,27 @@
+import { ok } from "assert";
+export function getPlaceholder() {
+  return Math.random().toString(36).substring(2, 15);
+}
+export function choice(elements) {
+  ok(elements.length > 0, "choice() called on empty sequence");
+  return elements[Math.floor(Math.random() * elements.length)];
+}
+export function getRandom() {
+  return Math.random();
+}
+export function getRandomInt(min, max) {
+  ok(min <= max, "min must be <= 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)
+ */
+export function shuffle(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+}

package/dist/utilts.js

@@ -0,0 +1,3 @@
+export function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/index.ts

@@ -9,14 +9,16 @@ async function main() {
 
   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? (
+    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?
+    aliasedOpcodes: true, // create duplicate opcodes for commonly used opcodes?
+    timingChecks: true, // add timing checks to detect debuggers?
+    minify: true, // pass final output through Google Closure Compiler? (Renames VM class properties)
+    concealConstants: true,
   });
 
   writeFileSync("output.original.js", orginalOutput, "utf-8");