@isopodlabs/binary_libs 0.0.1

package/dist/pe.js

@@ -0,0 +1,489 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadResourceDirectory = exports.ReadImports = exports.DLLImports = exports.ReadExports = exports.PE = exports.DATA_DIRECTORY = exports.DIRECTORIES = exports.pe_stream = void 0;
+const binary = __importStar(require("@isopodlabs/binary"));
+class MyDate extends Date {
+    constructor(x) { super(x * 1000); }
+    valueOf() { return this.getTime() / 1000; }
+    toString() { return super.toString(); }
+}
+const TIMEDATE = binary.as(binary.UINT32_LE, MyDate);
+//-----------------------------------------------------------------------------
+//	COFF
+//-----------------------------------------------------------------------------
+const DOS_HEADER = {
+    magic: binary.UINT16_LE,
+    cblp: binary.UINT16_LE,
+    cp: binary.UINT16_LE,
+    crlc: binary.UINT16_LE,
+    cparhdr: binary.UINT16_LE,
+    minalloc: binary.UINT16_LE,
+    maxalloc: binary.XINT16_LE,
+    ss: binary.UINT16_LE,
+    sp: binary.UINT16_LE,
+    csum: binary.UINT16_LE,
+    ip: binary.UINT16_LE,
+    cs: binary.UINT16_LE,
+    lfarlc: binary.UINT16_LE,
+    ovno: binary.UINT16_LE,
+};
+const EXE_HEADER = {
+    res: binary.ArrayType(4, binary.UINT16_LE),
+    oemid: binary.UINT16_LE,
+    oeminfo: binary.UINT16_LE,
+    res2: binary.ArrayType(10, binary.UINT16_LE),
+    lfanew: binary.INT32_LE,
+};
+//-----------------------------------------------------------------------------
+//	PE
+//-----------------------------------------------------------------------------
+class pe_stream extends binary.stream {
+    pe;
+    constructor(pe, data) {
+        super(data);
+        this.pe = pe;
+    }
+    get_rva() { return this.pe.GetDataRVA(binary.UINT32_LE.get(this))?.data; }
+}
+exports.pe_stream = pe_stream;
+const RVA_STRING = {
+    get(s) { return binary.utils.decodeTextTo0(s.get_rva(), 'utf8'); },
+    put(s) { }
+};
+const RVA_ARRAY16 = {
+    get(s) { return binary.utils.to16(s.get_rva()); },
+    put(s) { }
+};
+const RVA_ARRAY32 = {
+    get(s) { return binary.utils.to32(s.get_rva()); },
+    put(s) { }
+};
+const RVA_ARRAY64 = {
+    get(s) { return binary.utils.to64(s.get_rva()); },
+    put(s) { }
+};
+const FILE_HEADER = {
+    Machine: binary.UINT16_LE,
+    NumberOfSections: binary.UINT16_LE,
+    TimeDateStamp: binary.UINT32_LE,
+    PointerToSymbolTable: binary.UINT32_LE,
+    NumberOfSymbols: binary.UINT32_LE,
+    SizeOfOptionalHeader: binary.UINT16_LE,
+    Characteristics: binary.UINT16_LE,
+};
+var SECTION_CHARACTERISTICS;
+(function (SECTION_CHARACTERISTICS) {
+    //							= 0x00000000,
+    //							= 0x00000001,
+    //							= 0x00000002,
+    //							= 0x00000004,
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["TYPE_NO_PAD"] = 8] = "TYPE_NO_PAD";
+    //							= 0x00000010,
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["CNT_CODE"] = 32] = "CNT_CODE";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["CNT_INITIALIZED_DATA"] = 64] = "CNT_INITIALIZED_DATA";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["CNT_UNINITIALIZED_DATA"] = 128] = "CNT_UNINITIALIZED_DATA";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["LNK_OTHER"] = 256] = "LNK_OTHER";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["LNK_INFO"] = 512] = "LNK_INFO";
+    //							= 0x00000400,
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["LNK_REMOVE"] = 2048] = "LNK_REMOVE";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["LNK_COMDAT"] = 4096] = "LNK_COMDAT";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["GPREL"] = 32768] = "GPREL";
+    //	MEM_PURGEABLE			= 0x00020000,
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["MEM_16BIT"] = 131072] = "MEM_16BIT";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["MEM_LOCKED"] = 262144] = "MEM_LOCKED";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["MEM_PRELOAD"] = 524288] = "MEM_PRELOAD";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["ALIGN"] = 15728640] = "ALIGN";
+    //ALIGN_1BYTES			= 0x00100000,
+    //ALIGN_2BYTES			= 0x00200000,
+    //ALIGN_4BYTES			= 0x00300000,
+    //ALIGN_8BYTES			= 0x00400000,
+    //ALIGN_16BYTES			= 0x00500000,
+    //ALIGN_32BYTES			= 0x00600000,
+    //ALIGN_64BYTES			= 0x00700000,
+    //ALIGN_128BYTES			= 0x00800000,
+    //ALIGN_256BYTES			= 0x00900000,
+    //ALIGN_512BYTES			= 0x00A00000,
+    //ALIGN_1024BYTES			= 0x00B00000,
+    //ALIGN_2048BYTES			= 0x00C00000,
+    //ALIGN_4096BYTES			= 0x00D00000,
+    //ALIGN_8192BYTES			= 0x00E00000,
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["LNK_NRELOC_OVFL"] = 16777216] = "LNK_NRELOC_OVFL";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["MEM_DISCARDABLE"] = 33554432] = "MEM_DISCARDABLE";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["MEM_NOT_CACHED"] = 67108864] = "MEM_NOT_CACHED";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["MEM_NOT_PAGED"] = 134217728] = "MEM_NOT_PAGED";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["MEM_SHARED"] = 268435456] = "MEM_SHARED";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["MEM_EXECUTE"] = 536870912] = "MEM_EXECUTE";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["MEM_READ"] = 1073741824] = "MEM_READ";
+    SECTION_CHARACTERISTICS[SECTION_CHARACTERISTICS["MEM_WRITE"] = 2147483648] = "MEM_WRITE";
+})(SECTION_CHARACTERISTICS || (SECTION_CHARACTERISTICS = {}));
+class Section extends binary.ReadStruct({
+    Name: binary.StringType(8),
+    VirtualSize: binary.UINT32_LE,
+    VirtualAddress: binary.XINT32_LE,
+    SizeOfRawData: binary.UINT32_LE,
+    PointerToRawData: binary.XINT32_LE,
+    PointerToRelocations: binary.XINT32_LE,
+    PointerToLinenumbers: binary.XINT32_LE,
+    NumberOfRelocations: binary.INT16_LE,
+    NumberOfLinenumbers: binary.INT16_LE,
+    Characteristics: binary.asFlags(binary.UINT32_LE, SECTION_CHARACTERISTICS)
+}) {
+    data;
+    constructor(r) {
+        super(r);
+        try {
+            this.data = new binary.utils.MappedMemory(r.buffer_at(+this.PointerToRawData, this.SizeOfRawData), +this.VirtualAddress, this.flags);
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    get flags() {
+        return 8 /* binary.utils.MEM.RELATIVE */
+            | (this.Characteristics.MEM_READ ? 1 /* binary.utils.MEM.READ */ : 0)
+            | (this.Characteristics.MEM_WRITE ? 2 /* binary.utils.MEM.WRITE */ : 0)
+            | (this.Characteristics.MEM_EXECUTE ? 4 /* binary.utils.MEM.EXECUTE */ : 0);
+    }
+}
+exports.DIRECTORIES = {
+    EXPORT: { read: (pe, data) => ReadExports(new pe_stream(pe, data.data)) },
+    IMPORT: { read: (pe, data) => ReadImports(new pe_stream(pe, data.data)) },
+    RESOURCE: { read: (pe, data) => ReadResourceDirectory(new binary.stream(data.data), data) },
+    EXCEPTION: {},
+    SECURITY: {},
+    BASERELOC: {},
+    DEBUG_DIR: {},
+    ARCHITECTURE: {},
+    GLOBALPTR: {},
+    TLS: {},
+    LOAD_CONFIG: {},
+    BOUND_IMPORT: {},
+    IAT: {},
+    DELAY_IMPORT: {},
+    CLR_DESCRIPTOR: {},
+};
+exports.DATA_DIRECTORY = {
+    VirtualAddress: binary.UINT32_LE,
+    Size: binary.UINT32_LE,
+};
+const MAGIC = {
+    NT32: 0x10b,
+    NT64: 0x20b,
+    ROM: 0x107,
+    OBJ: 0x104,
+    //	DEMAND:		0x10b,	// demand load format, eg normal ld output
+    TARGET: 0x101,
+    HOST: 0x123, // host   shlib
+};
+const DLLCHARACTERISTICS = {
+    DYNAMIC_BASE: 0x0040,
+    FORCE_INTEGRITY: 0x0080,
+    NX_COMPAT: 0x0100,
+    NO_ISOLATION: 0x0200,
+    NO_SEH: 0x0400,
+    NO_BIND: 0x0800,
+    WDM_DRIVER: 0x2000,
+    TERMINAL_SERVER_AWARE: 0x8000, // Terminal Server aware
+};
+const OPTIONAL_HEADER = {
+    Magic: binary.asEnum(binary.UINT16_LE, MAGIC),
+    MajorLinkerVersion: binary.UINT8,
+    MinorLinkerVersion: binary.UINT8,
+    SizeOfCode: binary.UINT32_LE,
+    SizeOfInitializedData: binary.UINT32_LE,
+    SizeOfUninitializedData: binary.UINT32_LE,
+    AddressOfEntryPoint: binary.XINT32_LE,
+    BaseOfCode: binary.XINT32_LE,
+};
+const OPTIONAL_HEADER32 = {
+    BaseOfData: binary.XINT32_LE,
+    ImageBase: binary.XINT32_LE,
+    SectionAlignment: binary.UINT32_LE,
+    FileAlignment: binary.UINT32_LE,
+    MajorOperatingSystemVersion: binary.UINT16_LE,
+    MinorOperatingSystemVersion: binary.UINT16_LE,
+    MajorImageVersion: binary.UINT16_LE,
+    MinorImageVersion: binary.UINT16_LE,
+    MajorSubsystemVersion: binary.UINT16_LE,
+    MinorSubsystemVersion: binary.UINT16_LE,
+    Win32VersionValue: binary.UINT32_LE,
+    SizeOfImage: binary.UINT32_LE,
+    SizeOfHeaders: binary.UINT32_LE,
+    CheckSum: binary.UINT32_LE,
+    Subsystem: binary.UINT16_LE,
+    DllCharacteristics: binary.asFlags(binary.UINT16_LE, DLLCHARACTERISTICS),
+    SizeOfStackReserve: binary.UINT32_LE,
+    SizeOfStackCommit: binary.UINT32_LE,
+    SizeOfHeapReserve: binary.UINT32_LE,
+    SizeOfHeapCommit: binary.UINT32_LE,
+    LoaderFlags: binary.UINT32_LE,
+    DataDirectory: binary.objectWithNames(binary.ArrayType(binary.UINT32_LE, exports.DATA_DIRECTORY), binary.names(Object.keys(exports.DIRECTORIES))),
+};
+const OPTIONAL_HEADER64 = {
+    ImageBase: binary.XINT64_LE,
+    SectionAlignment: binary.UINT32_LE,
+    FileAlignment: binary.UINT32_LE,
+    MajorOperatingSystemVersion: binary.UINT16_LE,
+    MinorOperatingSystemVersion: binary.UINT16_LE,
+    MajorImageVersion: binary.UINT16_LE,
+    MinorImageVersion: binary.UINT16_LE,
+    MajorSubsystemVersion: binary.UINT16_LE,
+    MinorSubsystemVersion: binary.UINT16_LE,
+    Win32VersionValue: binary.UINT32_LE,
+    SizeOfImage: binary.UINT32_LE,
+    SizeOfHeaders: binary.UINT32_LE,
+    CheckSum: binary.UINT32_LE,
+    Subsystem: binary.UINT16_LE,
+    DllCharacteristics: binary.asFlags(binary.UINT16_LE, DLLCHARACTERISTICS),
+    SizeOfStackReserve: binary.UINT64_LE,
+    SizeOfStackCommit: binary.UINT64_LE,
+    SizeOfHeapReserve: binary.UINT64_LE,
+    SizeOfHeapCommit: binary.UINT64_LE,
+    LoaderFlags: binary.UINT32_LE,
+    DataDirectory: binary.objectWithNames(binary.ArrayType(binary.UINT32_LE, exports.DATA_DIRECTORY), binary.names(Object.keys(exports.DIRECTORIES))),
+};
+class PE {
+    data;
+    header;
+    sections;
+    opt;
+    static check(data) {
+        return binary.UINT16_LE.get(new binary.stream(data)) === binary.utils.stringCode("MZ");
+    }
+    constructor(data) {
+        this.data = data;
+        const file = new binary.stream(data);
+        this.header = binary.read(file, { ...DOS_HEADER, ...EXE_HEADER });
+        file.seek(this.header.lfanew);
+        if (binary.UINT32_LE.get(file) == binary.utils.stringCode("PE\0\0")) {
+            const h = binary.read(file, FILE_HEADER);
+            if (h.SizeOfOptionalHeader) {
+                const opt = new binary.stream(file.read_buffer(h.SizeOfOptionalHeader));
+                const opt1 = binary.read(opt, OPTIONAL_HEADER);
+                if (opt1.Magic == 'NT32')
+                    this.opt = binary.read_more(opt, OPTIONAL_HEADER32, opt1);
+                else if (opt1.Magic == 'NT64')
+                    this.opt = binary.read_more(opt, OPTIONAL_HEADER64, opt1);
+            }
+            this.sections = Array.from({ length: h.NumberOfSections }, () => new Section(file));
+        }
+        else {
+            this.sections = [];
+        }
+    }
+    get directories() {
+        return this.opt?.DataDirectory;
+    }
+    FindSectionRVA(rva) {
+        for (const i of this.sections) {
+            if (rva >= +i.VirtualAddress && rva < +i.VirtualAddress + i.SizeOfRawData)
+                return i;
+        }
+    }
+    FindSectionRaw(addr) {
+        for (const i of this.sections) {
+            if (addr >= +i.PointerToRawData && addr < +i.PointerToRawData + i.SizeOfRawData)
+                return i;
+        }
+    }
+    GetDataRVA(rva, size) {
+        const sect = this.FindSectionRVA(rva);
+        if (sect && sect.data)
+            return sect.data.at(rva, size);
+    }
+    GetDataRaw(addr, size) {
+        const sect = this.FindSectionRaw(addr);
+        if (sect && sect.data) {
+            const offset = addr - +sect.PointerToRawData;
+            return sect.data.data.subarray(offset, offset + size);
+        }
+    }
+    GetDataDir(dir) {
+        if (dir.Size)
+            return this.GetDataRVA(dir.VirtualAddress, dir.Size);
+    }
+    ReadDirectory(name) {
+        const dir = this.opt?.DataDirectory[name];
+        if (dir?.Size) {
+            const data = this.GetDataDir(dir);
+            const info = exports.DIRECTORIES[name];
+            if (data && info?.read)
+                return info.read(this, data);
+            return data;
+        }
+    }
+}
+exports.PE = PE;
+//-----------------------------------------------------------------------------
+//	exports
+//-----------------------------------------------------------------------------
+const EXPORT_DIRECTORY = {
+    ExportFlags: binary.UINT32_LE,
+    TimeDateStamp: TIMEDATE,
+    MajorVersion: binary.XINT16_LE,
+    MinorVersion: binary.XINT16_LE,
+    DLLName: RVA_STRING,
+    OrdinalBase: binary.UINT32_LE,
+    NumberEntries: binary.UINT32_LE,
+    NumberNames: binary.UINT32_LE,
+    FunctionTable: RVA_ARRAY32,
+    NameTable: RVA_ARRAY32,
+    OrdinalTable: RVA_ARRAY16, // RVA from base of image
+};
+function ReadExports(file) {
+    const dir = binary.read(file, EXPORT_DIRECTORY);
+    const addresses = dir.FunctionTable;
+    const names = dir.NameTable;
+    const ordinals = dir.OrdinalTable;
+    const result = [];
+    for (let i = 0; i < dir.NumberEntries; i++) {
+        const sect = file.pe.FindSectionRVA(addresses[i]);
+        if (sect) {
+            const ordinal = (ordinals && i < dir.NumberNames ? ordinals[i] : i) + dir.OrdinalBase;
+            const name = names && i < dir.NumberNames ? binary.utils.decodeTextTo0(file.pe.GetDataRVA(names[i])?.data, 'utf8') : '';
+            result.push({ ordinal, name, address: addresses[i] });
+        }
+    }
+    const sorted = result.sort((a, b) => a.address - b.address);
+    return sorted.map((v, i) => {
+        let j = i;
+        while (++j < sorted.length && sorted[j].address == v.address)
+            ;
+        return [v.ordinal, v.name, file.pe.GetDataRVA(v.address, j < sorted.length ? sorted[j].address - v.address : undefined)];
+    });
+}
+exports.ReadExports = ReadExports;
+//-----------------------------------------------------------------------------
+//	imports
+//-----------------------------------------------------------------------------
+class DLLImports extends Array {
+}
+exports.DLLImports = DLLImports;
+const RVA_ITA64 = {
+    get(s) {
+        const r = binary.utils.to64(s.get_rva());
+        if (r) {
+            const result = Array.from(r.subarray(0, r.indexOf(0n)), i => i >> 63n
+                ? `ordinal_${i - (1n << 63n)}`
+                : binary.utils.decodeTextTo0(s.pe.GetDataRVA(Number(i))?.data.subarray(2), 'utf8'));
+            Object.setPrototypeOf(result, DLLImports.prototype);
+            return result;
+        }
+    },
+    put(s) { }
+};
+const IMPORT_DESCRIPTOR = {
+    Characteristics: binary.UINT32_LE,
+    TimeDateStamp: TIMEDATE,
+    ForwarderChain: binary.UINT32_LE,
+    DllName: RVA_STRING,
+    FirstThunk: RVA_ITA64, //binary.UINT32_LE,	// RVA to IAT (if bound this IAT has actual addresses)
+};
+function ReadImports(file) {
+    const result = [];
+    while (file.remaining()) {
+        const r = binary.read(file, IMPORT_DESCRIPTOR);
+        if (!r.Characteristics)
+            break;
+        result.push([r.DllName, r.FirstThunk]);
+    }
+    return result;
+}
+exports.ReadImports = ReadImports;
+//-----------------------------------------------------------------------------
+//	resources
+//-----------------------------------------------------------------------------
+const RESOURCE_DIRECTORY_ENTRY = {
+    get(s) {
+        const u0 = binary.UINT32_LE.get(s);
+        const u1 = binary.UINT32_LE.get(s);
+        return [u0, u1];
+    },
+    put(s) { }
+};
+class RESOURCE_DATA_ENTRY extends binary.ReadStruct({
+    OffsetToData: binary.UINT32_LE,
+    Size: binary.UINT32_LE,
+    CodePage: binary.UINT32_LE,
+    Reserved: binary.UINT32_LE,
+}) {
+    data;
+    constructor(file, data) {
+        super(file);
+        this.data = data.slice(this.OffsetToData, this.OffsetToData + this.Size).data;
+    }
+}
+const RESOURCE_DIRECTORY = {
+    Characteristics: binary.UINT32_LE,
+    TimeDateStamp: binary.UINT32_LE,
+    MajorVersion: binary.UINT16_LE,
+    MinorVersion: binary.UINT16_LE,
+    NumberOfNamedEntries: binary.UINT16_LE,
+    NumberOfIdEntries: binary.UINT16_LE,
+};
+var IRT;
+(function (IRT) {
+    IRT[IRT["NONE"] = 0] = "NONE";
+    IRT[IRT["CURSOR"] = 1] = "CURSOR";
+    IRT[IRT["BITMAP"] = 2] = "BITMAP";
+    IRT[IRT["ICON"] = 3] = "ICON";
+    IRT[IRT["MENU"] = 4] = "MENU";
+    IRT[IRT["DIALOG"] = 5] = "DIALOG";
+    IRT[IRT["STRING"] = 6] = "STRING";
+    IRT[IRT["FONTDIR"] = 7] = "FONTDIR";
+    IRT[IRT["FONT"] = 8] = "FONT";
+    IRT[IRT["ACCELERATOR"] = 9] = "ACCELERATOR";
+    IRT[IRT["RCDATA"] = 10] = "RCDATA";
+    IRT[IRT["MESSAGETABLE"] = 11] = "MESSAGETABLE";
+    IRT[IRT["GROUP_CURSOR"] = 12] = "GROUP_CURSOR";
+    IRT[IRT["GROUP_ICON"] = 14] = "GROUP_ICON";
+    IRT[IRT["VERSION"] = 16] = "VERSION";
+    IRT[IRT["DLGINCLUDE"] = 17] = "DLGINCLUDE";
+    IRT[IRT["PLUGPLAY"] = 19] = "PLUGPLAY";
+    IRT[IRT["VXD"] = 20] = "VXD";
+    IRT[IRT["ANICURSOR"] = 21] = "ANICURSOR";
+    IRT[IRT["ANIICON"] = 22] = "ANIICON";
+    IRT[IRT["HTML"] = 23] = "HTML";
+    IRT[IRT["MANIFEST"] = 24] = "MANIFEST";
+    IRT[IRT["TOOLBAR"] = 241] = "TOOLBAR";
+})(IRT || (IRT = {}));
+function ReadResourceDirectory(file, data, type = IRT.NONE) {
+    const dir = binary.read(file, RESOURCE_DIRECTORY);
+    const n = dir.NumberOfNamedEntries + dir.NumberOfIdEntries;
+    const entries = binary.readn(file, RESOURCE_DIRECTORY_ENTRY, n);
+    const id_type = binary.StringType(binary.UINT16_LE, 'utf16le');
+    const topbit = 0x80000000;
+    const result = {};
+    for (const i of entries) {
+        const id = i[0] & topbit ? id_type.get(file.seek(i[0] & ~topbit)) : !type ? IRT[i[0]] : i[0];
+        file.seek(i[1] & ~topbit);
+        result[id] = i[1] & topbit
+            ? ReadResourceDirectory(file, data, type || i[0])
+            : new RESOURCE_DATA_ENTRY(file, data);
+    }
+    return result;
+}
+exports.ReadResourceDirectory = ReadResourceDirectory;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@isopodlabs/binary_libs",
+  "description": "A package for reading various library file format with TypeScript.",
+  "exports": {
+    "./arch": "./dist/arch.js",
+    "./clr": "./dist/clr.js",
+    "./CompoundDocument": "./dist/CompoundDocument.js",
+    "./elf": "./dist/elf.js",
+    "./mach": "./dist/mach.js",
+    "./pe": "./dist/pe.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"No tests specified\" && exit 0"
+  },
+  "keywords": [
+    "binary",
+    "typescript",
+    "data",
+    "read",
+    "write"
+  ],
+  "author": "Adrian Stephens",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.13.8",
+    "typescript": "^4.0.0"
+  },
+  "dependencies": {
+    "@isopodlabs/binary": "^1.0.3"
+  },
+  "version": "0.0.1"
+}