iris-decompiler 1.0.0

package/dist/types.d.ts

@@ -0,0 +1,174 @@
+export declare enum Op {
+    NOP = 0,
+    BREAK = 1,
+    LOADNIL = 2,
+    LOADB = 3,
+    LOADN = 4,
+    LOADK = 5,
+    MOVE = 6,
+    GETGLOBAL = 7,
+    SETGLOBAL = 8,
+    GETUPVAL = 9,
+    SETUPVAL = 10,
+    CLOSEUPVALS = 11,
+    GETIMPORT = 12,
+    GETTABLE = 13,
+    SETTABLE = 14,
+    GETTABLEKS = 15,
+    SETTABLEKS = 16,
+    GETTABLEN = 17,
+    SETTABLEN = 18,
+    NEWCLOSURE = 19,
+    NAMECALL = 20,
+    CALL = 21,
+    RETURN = 22,
+    JUMP = 23,
+    JUMPBACK = 24,
+    JUMPIF = 25,
+    JUMPIFNOT = 26,
+    JUMPIFEQ = 27,
+    JUMPIFLE = 28,
+    JUMPIFLT = 29,
+    JUMPIFNOTEQ = 30,
+    JUMPIFNOTLE = 31,
+    JUMPIFNOTLT = 32,
+    ADD = 33,
+    SUB = 34,
+    MUL = 35,
+    DIV = 36,
+    MOD = 37,
+    POW = 38,
+    ADDK = 39,
+    SUBK = 40,
+    MULK = 41,
+    DIVK = 42,
+    MODK = 43,
+    POWK = 44,
+    AND = 45,
+    OR = 46,
+    ANDK = 47,
+    ORK = 48,
+    CONCAT = 49,
+    NOT = 50,
+    MINUS = 51,
+    LENGTH = 52,
+    NEWTABLE = 53,
+    DUPTABLE = 54,
+    SETLIST = 55,
+    FORNPREP = 56,
+    FORNLOOP = 57,
+    FORGLOOP = 58,
+    FORGPREP_INEXT = 59,
+    FASTCALL3 = 60,
+    FORGPREP_NEXT = 61,
+    NATIVECALL = 62,
+    GETVARARGS = 63,
+    DUPCLOSURE = 64,
+    PREPVARARGS = 65,
+    LOADKX = 66,
+    JUMPX = 67,
+    FASTCALL = 68,
+    COVERAGE = 69,
+    CAPTURE = 70,
+    SUBRK = 71,
+    DIVRK = 72,
+    FASTCALL1 = 73,
+    FASTCALL2 = 74,
+    FASTCALL2K = 75,
+    FORGPREP = 76,
+    JUMPXEQKNIL = 77,
+    JUMPXEQKB = 78,
+    JUMPXEQKN = 79,
+    JUMPXEQKS = 80,
+    IDIV = 81,
+    IDIVK = 82,
+    GETUDATAKS = 83,
+    SETUDATAKS = 84,
+    NAMECALLUDATA = 85,
+    NEWCLASSMEMBER = 86,
+    CALLFB = 87,
+    CMPPROTO = 88,
+    NEWCLASS = 89
+}
+export declare enum ConstKind {
+    Nil = 0,
+    Boolean = 1,
+    Number = 2,
+    String = 3,
+    Import = 4,
+    Table = 5,
+    Closure = 6,
+    Vector = 7,
+    TableWithConstants = 8,
+    Sentinel = 9,
+    Integer = 10,
+    ClassShape = 11,
+    VectorD = 12
+}
+export interface TableEntry {
+    key: number;
+    value: number;
+}
+export interface Constant {
+    kind: ConstKind;
+    boolean: boolean;
+    number: number;
+    importId: number;
+    str: string;
+    closureProto: number;
+    vec: number[];
+    table: TableEntry[];
+    integer: number;
+}
+export declare function makeConstant(): Constant;
+export interface LocVar {
+    name: string;
+    startpc: number;
+    endpc: number;
+    reg: number;
+}
+export interface Proto {
+    id: number;
+    maxstack: number;
+    numparams: number;
+    nups: number;
+    is_vararg: number;
+    flags: number;
+    code: number[];
+    k: Constant[];
+    children: number[];
+    lineinfo: number[];
+    linedefined: number;
+    debugname: string;
+    source: string;
+    locvars: LocVar[];
+    upnames: string[];
+}
+export declare function makeProto(): Proto;
+export interface Program {
+    strings: string[];
+    protos: Proto[];
+    main: number;
+    encodingKey: number;
+}
+export declare function makeProgram(): Program;
+export declare function iA(insn: number): number;
+export declare function iB(insn: number): number;
+export declare function iC(insn: number): number;
+export declare function iD(insn: number): number;
+export declare function iE(insn: number): number;
+export declare function iOp(insn: number): Op;
+export declare function auxA(aux: number): number;
+export declare function auxB(aux: number): number;
+export declare function auxKV(aux: number): number;
+export declare function auxKB(aux: number): number;
+export declare function auxNOT(aux: number): boolean;
+export declare const OP_NAMES: string[];
+export declare function opName(op: Op): string;
+export declare function opHasAux(op: Op): boolean;
+export declare function opLength(op: Op): number;
+export declare function opIsJumpD(op: Op): boolean;
+export declare function opIsLoopJump(op: Op): boolean;
+export declare function opIsFallthrough(op: Op): boolean;
+export declare function opIsFastCall(op: Op): boolean;
+export declare function jumpTarget(code: number[], pc: number): number;

package/dist/types.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OP_NAMES = exports.ConstKind = exports.Op = void 0;
+exports.makeConstant = makeConstant;
+exports.makeProto = makeProto;
+exports.makeProgram = makeProgram;
+exports.iA = iA;
+exports.iB = iB;
+exports.iC = iC;
+exports.iD = iD;
+exports.iE = iE;
+exports.iOp = iOp;
+exports.auxA = auxA;
+exports.auxB = auxB;
+exports.auxKV = auxKV;
+exports.auxKB = auxKB;
+exports.auxNOT = auxNOT;
+exports.opName = opName;
+exports.opHasAux = opHasAux;
+exports.opLength = opLength;
+exports.opIsJumpD = opIsJumpD;
+exports.opIsLoopJump = opIsLoopJump;
+exports.opIsFallthrough = opIsFallthrough;
+exports.opIsFastCall = opIsFastCall;
+exports.jumpTarget = jumpTarget;
+var Op;
+(function (Op) {
+    Op[Op["NOP"] = 0] = "NOP";
+    Op[Op["BREAK"] = 1] = "BREAK";
+    Op[Op["LOADNIL"] = 2] = "LOADNIL";
+    Op[Op["LOADB"] = 3] = "LOADB";
+    Op[Op["LOADN"] = 4] = "LOADN";
+    Op[Op["LOADK"] = 5] = "LOADK";
+    Op[Op["MOVE"] = 6] = "MOVE";
+    Op[Op["GETGLOBAL"] = 7] = "GETGLOBAL";
+    Op[Op["SETGLOBAL"] = 8] = "SETGLOBAL";
+    Op[Op["GETUPVAL"] = 9] = "GETUPVAL";
+    Op[Op["SETUPVAL"] = 10] = "SETUPVAL";
+    Op[Op["CLOSEUPVALS"] = 11] = "CLOSEUPVALS";
+    Op[Op["GETIMPORT"] = 12] = "GETIMPORT";
+    Op[Op["GETTABLE"] = 13] = "GETTABLE";
+    Op[Op["SETTABLE"] = 14] = "SETTABLE";
+    Op[Op["GETTABLEKS"] = 15] = "GETTABLEKS";
+    Op[Op["SETTABLEKS"] = 16] = "SETTABLEKS";
+    Op[Op["GETTABLEN"] = 17] = "GETTABLEN";
+    Op[Op["SETTABLEN"] = 18] = "SETTABLEN";
+    Op[Op["NEWCLOSURE"] = 19] = "NEWCLOSURE";
+    Op[Op["NAMECALL"] = 20] = "NAMECALL";
+    Op[Op["CALL"] = 21] = "CALL";
+    Op[Op["RETURN"] = 22] = "RETURN";
+    Op[Op["JUMP"] = 23] = "JUMP";
+    Op[Op["JUMPBACK"] = 24] = "JUMPBACK";
+    Op[Op["JUMPIF"] = 25] = "JUMPIF";
+    Op[Op["JUMPIFNOT"] = 26] = "JUMPIFNOT";
+    Op[Op["JUMPIFEQ"] = 27] = "JUMPIFEQ";
+    Op[Op["JUMPIFLE"] = 28] = "JUMPIFLE";
+    Op[Op["JUMPIFLT"] = 29] = "JUMPIFLT";
+    Op[Op["JUMPIFNOTEQ"] = 30] = "JUMPIFNOTEQ";
+    Op[Op["JUMPIFNOTLE"] = 31] = "JUMPIFNOTLE";
+    Op[Op["JUMPIFNOTLT"] = 32] = "JUMPIFNOTLT";
+    Op[Op["ADD"] = 33] = "ADD";
+    Op[Op["SUB"] = 34] = "SUB";
+    Op[Op["MUL"] = 35] = "MUL";
+    Op[Op["DIV"] = 36] = "DIV";
+    Op[Op["MOD"] = 37] = "MOD";
+    Op[Op["POW"] = 38] = "POW";
+    Op[Op["ADDK"] = 39] = "ADDK";
+    Op[Op["SUBK"] = 40] = "SUBK";
+    Op[Op["MULK"] = 41] = "MULK";
+    Op[Op["DIVK"] = 42] = "DIVK";
+    Op[Op["MODK"] = 43] = "MODK";
+    Op[Op["POWK"] = 44] = "POWK";
+    Op[Op["AND"] = 45] = "AND";
+    Op[Op["OR"] = 46] = "OR";
+    Op[Op["ANDK"] = 47] = "ANDK";
+    Op[Op["ORK"] = 48] = "ORK";
+    Op[Op["CONCAT"] = 49] = "CONCAT";
+    Op[Op["NOT"] = 50] = "NOT";
+    Op[Op["MINUS"] = 51] = "MINUS";
+    Op[Op["LENGTH"] = 52] = "LENGTH";
+    Op[Op["NEWTABLE"] = 53] = "NEWTABLE";
+    Op[Op["DUPTABLE"] = 54] = "DUPTABLE";
+    Op[Op["SETLIST"] = 55] = "SETLIST";
+    Op[Op["FORNPREP"] = 56] = "FORNPREP";
+    Op[Op["FORNLOOP"] = 57] = "FORNLOOP";
+    Op[Op["FORGLOOP"] = 58] = "FORGLOOP";
+    Op[Op["FORGPREP_INEXT"] = 59] = "FORGPREP_INEXT";
+    Op[Op["FASTCALL3"] = 60] = "FASTCALL3";
+    Op[Op["FORGPREP_NEXT"] = 61] = "FORGPREP_NEXT";
+    Op[Op["NATIVECALL"] = 62] = "NATIVECALL";
+    Op[Op["GETVARARGS"] = 63] = "GETVARARGS";
+    Op[Op["DUPCLOSURE"] = 64] = "DUPCLOSURE";
+    Op[Op["PREPVARARGS"] = 65] = "PREPVARARGS";
+    Op[Op["LOADKX"] = 66] = "LOADKX";
+    Op[Op["JUMPX"] = 67] = "JUMPX";
+    Op[Op["FASTCALL"] = 68] = "FASTCALL";
+    Op[Op["COVERAGE"] = 69] = "COVERAGE";
+    Op[Op["CAPTURE"] = 70] = "CAPTURE";
+    Op[Op["SUBRK"] = 71] = "SUBRK";
+    Op[Op["DIVRK"] = 72] = "DIVRK";
+    Op[Op["FASTCALL1"] = 73] = "FASTCALL1";
+    Op[Op["FASTCALL2"] = 74] = "FASTCALL2";
+    Op[Op["FASTCALL2K"] = 75] = "FASTCALL2K";
+    Op[Op["FORGPREP"] = 76] = "FORGPREP";
+    Op[Op["JUMPXEQKNIL"] = 77] = "JUMPXEQKNIL";
+    Op[Op["JUMPXEQKB"] = 78] = "JUMPXEQKB";
+    Op[Op["JUMPXEQKN"] = 79] = "JUMPXEQKN";
+    Op[Op["JUMPXEQKS"] = 80] = "JUMPXEQKS";
+    Op[Op["IDIV"] = 81] = "IDIV";
+    Op[Op["IDIVK"] = 82] = "IDIVK";
+    Op[Op["GETUDATAKS"] = 83] = "GETUDATAKS";
+    Op[Op["SETUDATAKS"] = 84] = "SETUDATAKS";
+    Op[Op["NAMECALLUDATA"] = 85] = "NAMECALLUDATA";
+    Op[Op["NEWCLASSMEMBER"] = 86] = "NEWCLASSMEMBER";
+    Op[Op["CALLFB"] = 87] = "CALLFB";
+    Op[Op["CMPPROTO"] = 88] = "CMPPROTO";
+    Op[Op["NEWCLASS"] = 89] = "NEWCLASS";
+})(Op || (exports.Op = Op = {}));
+var ConstKind;
+(function (ConstKind) {
+    ConstKind[ConstKind["Nil"] = 0] = "Nil";
+    ConstKind[ConstKind["Boolean"] = 1] = "Boolean";
+    ConstKind[ConstKind["Number"] = 2] = "Number";
+    ConstKind[ConstKind["String"] = 3] = "String";
+    ConstKind[ConstKind["Import"] = 4] = "Import";
+    ConstKind[ConstKind["Table"] = 5] = "Table";
+    ConstKind[ConstKind["Closure"] = 6] = "Closure";
+    ConstKind[ConstKind["Vector"] = 7] = "Vector";
+    ConstKind[ConstKind["TableWithConstants"] = 8] = "TableWithConstants";
+    ConstKind[ConstKind["Sentinel"] = 9] = "Sentinel";
+    ConstKind[ConstKind["Integer"] = 10] = "Integer";
+    ConstKind[ConstKind["ClassShape"] = 11] = "ClassShape";
+    ConstKind[ConstKind["VectorD"] = 12] = "VectorD";
+})(ConstKind || (exports.ConstKind = ConstKind = {}));
+function makeConstant() {
+    return {
+        kind: ConstKind.Nil,
+        boolean: false,
+        number: 0,
+        importId: 0,
+        str: "",
+        closureProto: -1,
+        vec: [],
+        table: [],
+        integer: 0,
+    };
+}
+function makeProto() {
+    return {
+        id: 0,
+        maxstack: 0,
+        numparams: 0,
+        nups: 0,
+        is_vararg: 0,
+        flags: 0,
+        code: [],
+        k: [],
+        children: [],
+        lineinfo: [],
+        linedefined: 0,
+        debugname: "",
+        source: "",
+        locvars: [],
+        upnames: [],
+    };
+}
+function makeProgram() {
+    return { strings: [], protos: [], main: 0, encodingKey: 1 };
+}
+// ---- Instruction field accessors ----
+function iA(insn) { return (insn >> 8) & 0xff; }
+function iB(insn) { return (insn >> 16) & 0xff; }
+function iC(insn) { return (insn >> 24) & 0xff; }
+function iD(insn) { return (insn | 0) >> 16; } // int32 sign-extend of bits 16..31 (Luau D field)
+function iE(insn) { return (insn | 0) >> 8; } // int32 sign-extend of bits 8..31 (Luau E field)
+function iOp(insn) { return (insn & 0xff); }
+function auxA(aux) { return aux & 0xff; }
+function auxB(aux) { return (aux >> 8) & 0xff; }
+function auxKV(aux) { return aux & 0xffffff; }
+function auxKB(aux) { return aux & 0x1; }
+function auxNOT(aux) { return (aux >>> 31) !== 0; }
+// ---- Opcode metadata ----
+exports.OP_NAMES = [
+    "NOP", "BREAK", "LOADNIL", "LOADB", "LOADN", "LOADK", "MOVE", "GETGLOBAL", "SETGLOBAL",
+    "GETUPVAL", "SETUPVAL", "CLOSEUPVALS", "GETIMPORT", "GETTABLE", "SETTABLE", "GETTABLEKS",
+    "SETTABLEKS", "GETTABLEN", "SETTABLEN", "NEWCLOSURE", "NAMECALL", "CALL", "RETURN", "JUMP",
+    "JUMPBACK", "JUMPIF", "JUMPIFNOT", "JUMPIFEQ", "JUMPIFLE", "JUMPIFLT", "JUMPIFNOTEQ",
+    "JUMPIFNOTLE", "JUMPIFNOTLT", "ADD", "SUB", "MUL", "DIV", "MOD", "POW", "ADDK", "SUBK",
+    "MULK", "DIVK", "MODK", "POWK", "AND", "OR", "ANDK", "ORK", "CONCAT", "NOT", "MINUS",
+    "LENGTH", "NEWTABLE", "DUPTABLE", "SETLIST", "FORNPREP", "FORNLOOP", "FORGLOOP",
+    "FORGPREP_INEXT", "FASTCALL3", "FORGPREP_NEXT", "NATIVECALL", "GETVARARGS", "DUPCLOSURE",
+    "PREPVARARGS", "LOADKX", "JUMPX", "FASTCALL", "COVERAGE", "CAPTURE", "SUBRK", "DIVRK",
+    "FASTCALL1", "FASTCALL2", "FASTCALL2K", "FORGPREP", "JUMPXEQKNIL", "JUMPXEQKB", "JUMPXEQKN",
+    "JUMPXEQKS", "IDIV", "IDIVK", "GETUDATAKS", "SETUDATAKS", "NAMECALLUDATA", "NEWCLASSMEMBER",
+    "CALLFB", "CMPPROTO", "NEWCLASS",
+];
+function opName(op) {
+    const i = Number(op);
+    return i >= 0 && i < exports.OP_NAMES.length ? exports.OP_NAMES[i] : "???";
+}
+function opHasAux(op) {
+    switch (op) {
+        case Op.GETGLOBAL:
+        case Op.SETGLOBAL:
+        case Op.GETIMPORT:
+        case Op.GETTABLEKS:
+        case Op.SETTABLEKS:
+        case Op.NAMECALL:
+        case Op.JUMPIFEQ:
+        case Op.JUMPIFLE:
+        case Op.JUMPIFLT:
+        case Op.JUMPIFNOTEQ:
+        case Op.JUMPIFNOTLE:
+        case Op.JUMPIFNOTLT:
+        case Op.NEWTABLE:
+        case Op.SETLIST:
+        case Op.FORGLOOP:
+        case Op.LOADKX:
+        case Op.FASTCALL2:
+        case Op.FASTCALL2K:
+        case Op.FASTCALL3:
+        case Op.JUMPXEQKNIL:
+        case Op.JUMPXEQKB:
+        case Op.JUMPXEQKN:
+        case Op.JUMPXEQKS:
+        case Op.GETUDATAKS:
+        case Op.SETUDATAKS:
+        case Op.NAMECALLUDATA:
+        case Op.NEWCLASSMEMBER:
+        case Op.CALLFB:
+        case Op.CMPPROTO:
+        case Op.NEWCLASS:
+            return true;
+        default:
+            return false;
+    }
+}
+function opLength(op) {
+    return opHasAux(op) ? 2 : 1;
+}
+function opIsJumpD(op) {
+    switch (op) {
+        case Op.JUMP:
+        case Op.JUMPIF:
+        case Op.JUMPIFNOT:
+        case Op.JUMPIFEQ:
+        case Op.JUMPIFLE:
+        case Op.JUMPIFLT:
+        case Op.JUMPIFNOTEQ:
+        case Op.JUMPIFNOTLE:
+        case Op.JUMPIFNOTLT:
+        case Op.FORNPREP:
+        case Op.FORNLOOP:
+        case Op.FORGPREP:
+        case Op.FORGLOOP:
+        case Op.FORGPREP_INEXT:
+        case Op.FORGPREP_NEXT:
+        case Op.JUMPBACK:
+        case Op.JUMPXEQKNIL:
+        case Op.JUMPXEQKB:
+        case Op.JUMPXEQKN:
+        case Op.JUMPXEQKS:
+        case Op.CMPPROTO:
+            return true;
+        default:
+            return false;
+    }
+}
+function opIsLoopJump(op) {
+    return op === Op.JUMPBACK || op === Op.FORGLOOP || op === Op.FORNLOOP;
+}
+function opIsFallthrough(op) {
+    switch (op) {
+        case Op.RETURN:
+        case Op.JUMP:
+        case Op.JUMPBACK:
+        case Op.JUMPX:
+            return false;
+        default:
+            return true;
+    }
+}
+function opIsFastCall(op) {
+    return op === Op.FASTCALL || op === Op.FASTCALL1 || op === Op.FASTCALL2 ||
+        op === Op.FASTCALL2K || op === Op.FASTCALL3;
+}
+function jumpTarget(code, pc) {
+    const insn = code[pc];
+    const op = iOp(insn);
+    if (opIsJumpD(op))
+        return pc + iD(insn) + 1;
+    if (opIsFastCall(op))
+        return pc + iC(insn) + 2;
+    if (op === Op.JUMPX)
+        return pc + iE(insn) + 1;
+    if (op === Op.LOADB && iC(insn))
+        return pc + iC(insn) + 1;
+    return -1;
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "iris-decompiler",
+  "version": "1.0.0",
+  "description": "decompiles bytecode into readable luau",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "iris-decompiler": "bin/cli.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "cli": "node bin/cli.js"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.4.0"
+  }
+}