js-confuser-vm 0.1.0 → 0.1.2

package/src/types.ts

@@ -1,93 +0,0 @@
-// 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.
-// A virtual register reference emitted by the compiler.
-// fnId identifies which function's register file this belongs to.
-// resolveRegisters() replaces these with concrete slot indices (type:"number").
-export type RegisterOperand = Op<{
-  type: "register";
-  id: number;
-  fnId: number;
-  kind?: string;
-  scopeId?: string | number;
-}>;
-
-// A placeholder for a function's concrete regCount, emitted in MAKE_CLOSURE.
-// resolveRegisters() fills resolvedValue once it knows the concrete slot count.
-export type FnRegCountOperand = Op<{ type: "fnRegCount"; fnId: number }>;
-
-// IR pseudo-instruction that marks the end of a register's live range.
-// Emitted as [null, FreeRegOperand] so it is dropped before final assembly.
-//
-// NOTE: resolveRegisters() already computes correct lastUse from the last real
-// operand appearance, so freeReg is EXTRANEOUS for any programmatically generated
-// IR — the scanner will find the tightest possible range without it.
-// It is only useful when a register has a late syntactic appearance that does
-// NOT reflect its true logical end-of-life (e.g. a read emitted purely for
-// side-effects long after the value is logically dead). No current pass in this
-// codebase emits freeReg; it is kept as an extension point only.
-export type FreeRegOperand = Op<{
-  type: "freeReg";
-  fnId: number;
-  id: number;
-  kind?: string;
-  scopeId?: string | number;
-}>;
-
-export type InstrOperand =
-  | number
-  | Op<{ type: "number"; value?: number }>
-  | Op<{
-      type: "label";
-      label: string;
-      offset?: number;
-      transform?: (resolvedPC: number) => number;
-    }>
-  | Op<{ type: "defineLabel"; label: string }>
-  | Op<{ type: "constant"; value: any }>
-  | RegisterOperand
-  | FnRegCountOperand
-  | FreeRegOperand;
-
-export interface Operand {
-  type: string;
-  placeholder?: boolean; // This operand will not be emitted in the final bytecode, but used as a reference
-  resolvedValue?: number; // This operand knows its resolved value, but kept as a object to keep metadata info available
-}
-
-type Op<T extends object> = Operand & T;
-
-export type Instruction = [number | null, ...InstrOperand[]];
-
-export type Bytecode = Instruction[];
-
-export function constantOperand(value: any): Instruction[1] {
-  return {
-    type: "constant",
-    value: value,
-  };
-}
-
-export function registerOperand(
-  id: number,
-  fnId: number,
-  metadata: Partial<Pick<RegisterOperand, "kind" | "scopeId">> = {},
-): RegisterOperand {
-  return { type: "register", id, fnId, ...metadata };
-}
-
-export function fnRegCountOperand(fnId: number): FnRegCountOperand {
-  return { type: "fnRegCount", fnId };
-}
-
-export function freeRegOperand(reg: RegisterOperand): FreeRegOperand {
-  const op: FreeRegOperand = { type: "freeReg", fnId: reg.fnId, id: reg.id };
-  if (reg.kind !== undefined) op.kind = reg.kind;
-  if (reg.scopeId !== undefined) op.scopeId = reg.scopeId;
-  return op;
-}

package/src/utils/op-utils.ts

@@ -1,48 +0,0 @@
-import { getRandomInt } from "./random-utils.ts";
-import * as b from "../types.ts";
-import { Compiler } from "../compiler.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(compiler: Compiler): number {
-  // ── Collect used opcodes exactly as specified ─────────────────────────────
-  const usedOpcodes = new Set<number>(
-    Object.keys(compiler.OP_NAME)
-      .map((k) => parseInt(k, 10))
-      .filter((v) => !isNaN(v)) as number[],
-  );
-
-  if (usedOpcodes.size > U16_MAX) return -1;
-
-  // Random opcode
-  if (compiler.options.randomizeOpcodes) {
-    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 = Object.keys(compiler.OP_NAME).length;
-  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: b.Instruction): number {
-  if (instr[0] === null) return 0;
-
-  const size = instr.filter((op) => (op as any)?.placeholder !== true).length;
-
-  return size;
-}

package/src/utils/random-utils.ts

@@ -1,31 +0,0 @@
-import { ok } from "assert";
-
-export function getPlaceholder() {
-  return Math.random().toString(36).substring(2, 15);
-}
-
-export function choice<T>(elements: T[]): T {
-  ok(elements.length > 0, "choice() called on empty sequence");
-  return elements[Math.floor(Math.random() * elements.length)];
-}
-
-export function getRandom(): number {
-  return Math.random();
-}
-
-export function getRandomInt(min: number, max: number): number {
-  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<T>(array: T[]): T[] {
-  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/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "nodenext",
-    "outDir": "./dist",
-    "rootDir": "./",
-    "strict": false,
-    "noEmit": true,
-    "types": ["node"],
-    "allowImportingTsExtensions": true
-  }
-}