@isopodlabs/binary_libs 0.1.4 → 0.2.0

package/dist/mach.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FATMachFile = exports.MachFile = void 0;
+exports.FATMachFile = exports.MachFile = exports.CMD = void 0;
 const binary = __importStar(require("@isopodlabs/binary"));
 class mach_stream extends binary.endianStream {
     base;
@@ -255,6 +255,62 @@ const fat_header = {
     archs: binary.ArrayType(uint32, fat_arch)
 };
 const REQ_DYLD = 0x80000000;
+var CMD;
+(function (CMD) {
+    CMD[CMD["SEGMENT"] = 1] = "SEGMENT";
+    CMD[CMD["SYMTAB"] = 2] = "SYMTAB";
+    CMD[CMD["SYMSEG"] = 3] = "SYMSEG";
+    CMD[CMD["THREAD"] = 4] = "THREAD";
+    CMD[CMD["UNIXTHREAD"] = 5] = "UNIXTHREAD";
+    CMD[CMD["LOADFVMLIB"] = 6] = "LOADFVMLIB";
+    CMD[CMD["IDFVMLIB"] = 7] = "IDFVMLIB";
+    //	IDENT						= 0x08,				// object identification info (obsolete)
+    CMD[CMD["FVMFILE"] = 9] = "FVMFILE";
+    //	PREPAGE						= 0x0a,				// prepage command (internal use)
+    CMD[CMD["DYSYMTAB"] = 11] = "DYSYMTAB";
+    CMD[CMD["LOAD_DYLIB"] = 12] = "LOAD_DYLIB";
+    CMD[CMD["ID_DYLIB"] = 13] = "ID_DYLIB";
+    CMD[CMD["LOAD_DYLINKER"] = 14] = "LOAD_DYLINKER";
+    CMD[CMD["ID_DYLINKER"] = 15] = "ID_DYLINKER";
+    CMD[CMD["PREBOUND_DYLIB"] = 16] = "PREBOUND_DYLIB";
+    CMD[CMD["ROUTINES"] = 17] = "ROUTINES";
+    CMD[CMD["SUB_FRAMEWORK"] = 18] = "SUB_FRAMEWORK";
+    CMD[CMD["SUB_UMBRELLA"] = 19] = "SUB_UMBRELLA";
+    CMD[CMD["SUB_CLIENT"] = 20] = "SUB_CLIENT";
+    CMD[CMD["SUB_LIBRARY"] = 21] = "SUB_LIBRARY";
+    CMD[CMD["TWOLEVEL_HINTS"] = 22] = "TWOLEVEL_HINTS";
+    CMD[CMD["PREBIND_CKSUM"] = 23] = "PREBIND_CKSUM";
+    CMD[CMD["LOAD_WEAK_DYLIB"] = 2147483672] = "LOAD_WEAK_DYLIB";
+    CMD[CMD["SEGMENT_64"] = 25] = "SEGMENT_64";
+    CMD[CMD["ROUTINES_64"] = 26] = "ROUTINES_64";
+    CMD[CMD["UUID"] = 27] = "UUID";
+    CMD[CMD["RPATH"] = 2147483676] = "RPATH";
+    CMD[CMD["CODE_SIGNATURE"] = 29] = "CODE_SIGNATURE";
+    CMD[CMD["SEGMENT_SPLIT_INFO"] = 30] = "SEGMENT_SPLIT_INFO";
+    CMD[CMD["REEXPORT_DYLIB"] = 2147483679] = "REEXPORT_DYLIB";
+    CMD[CMD["LAZY_LOAD_DYLIB"] = 32] = "LAZY_LOAD_DYLIB";
+    CMD[CMD["ENCRYPTION_INFO"] = 33] = "ENCRYPTION_INFO";
+    CMD[CMD["DYLD_INFO"] = 34] = "DYLD_INFO";
+    CMD[CMD["DYLD_INFO_ONLY"] = 2147483682] = "DYLD_INFO_ONLY";
+    CMD[CMD["LOAD_UPWARD_DYLIB"] = 2147483683] = "LOAD_UPWARD_DYLIB";
+    CMD[CMD["VERSION_MIN_MACOSX"] = 36] = "VERSION_MIN_MACOSX";
+    CMD[CMD["VERSION_MIN_IPHONEOS"] = 37] = "VERSION_MIN_IPHONEOS";
+    CMD[CMD["FUNCTION_STARTS"] = 38] = "FUNCTION_STARTS";
+    CMD[CMD["DYLD_ENVIRONMENT"] = 39] = "DYLD_ENVIRONMENT";
+    CMD[CMD["MAIN"] = 2147483688] = "MAIN";
+    CMD[CMD["DATA_IN_CODE"] = 41] = "DATA_IN_CODE";
+    CMD[CMD["SOURCE_VERSION"] = 42] = "SOURCE_VERSION";
+    CMD[CMD["DYLIB_CODE_SIGN_DRS"] = 43] = "DYLIB_CODE_SIGN_DRS";
+    CMD[CMD["ENCRYPTION_INFO_64"] = 44] = "ENCRYPTION_INFO_64";
+    CMD[CMD["LINKER_OPTION"] = 45] = "LINKER_OPTION";
+    CMD[CMD["LINKER_OPTIMIZATION_HINT"] = 46] = "LINKER_OPTIMIZATION_HINT";
+    CMD[CMD["VERSION_MIN_TVOS"] = 47] = "VERSION_MIN_TVOS";
+    CMD[CMD["VERSION_MIN_WATCHOS"] = 48] = "VERSION_MIN_WATCHOS";
+    CMD[CMD["NOTE"] = 49] = "NOTE";
+    CMD[CMD["BUILD_VERSION"] = 50] = "BUILD_VERSION";
+    CMD[CMD["DYLD_EXPORTS_TRIE"] = 2147483699] = "DYLD_EXPORTS_TRIE";
+    CMD[CMD["DYLD_CHAINED_FIXUPS"] = 2147483700] = "DYLD_CHAINED_FIXUPS";
+})(CMD || (exports.CMD = CMD = {}));
 ;
 const str = {
     get(s) {
@@ -810,94 +866,94 @@ function routines(bits) {
 }
 //const cmd_table : {[K in CMD]?: binary.TypeReader2} = {
 const cmd_table = {
-    [1 /* CMD.SEGMENT */]: segment(32),
-    [25 /* CMD.SEGMENT_64 */]: segment(64),
-    [6 /* CMD.LOADFVMLIB */]: fvmlib,
-    [7 /* CMD.IDFVMLIB */]: fvmlib,
-    [12 /* CMD.LOAD_DYLIB */]: dylib,
-    [13 /* CMD.ID_DYLIB */]: dylib,
-    [2147483672 /* CMD.LOAD_WEAK_DYLIB */]: dylib,
-    [2147483679 /* CMD.REEXPORT_DYLIB */]: dylib,
-    [32 /* CMD.LAZY_LOAD_DYLIB */]: dylib,
-    [2147483683 /* CMD.LOAD_UPWARD_DYLIB */]: dylib,
-    [18 /* CMD.SUB_FRAMEWORK */]: str,
-    [19 /* CMD.SUB_UMBRELLA */]: str,
-    [20 /* CMD.SUB_CLIENT */]: str,
-    [21 /* CMD.SUB_LIBRARY */]: str,
-    [14 /* CMD.LOAD_DYLINKER */]: str,
-    [15 /* CMD.ID_DYLINKER */]: str,
-    [39 /* CMD.DYLD_ENVIRONMENT */]: str,
-    [2147483676 /* CMD.RPATH */]: str,
-    [16 /* CMD.PREBOUND_DYLIB */]: {
+    [CMD.SEGMENT]: segment(32),
+    [CMD.SEGMENT_64]: segment(64),
+    [CMD.LOADFVMLIB]: fvmlib,
+    [CMD.IDFVMLIB]: fvmlib,
+    [CMD.LOAD_DYLIB]: dylib,
+    [CMD.ID_DYLIB]: dylib,
+    [CMD.LOAD_WEAK_DYLIB]: dylib,
+    [CMD.REEXPORT_DYLIB]: dylib,
+    [CMD.LAZY_LOAD_DYLIB]: dylib,
+    [CMD.LOAD_UPWARD_DYLIB]: dylib,
+    [CMD.SUB_FRAMEWORK]: str,
+    [CMD.SUB_UMBRELLA]: str,
+    [CMD.SUB_CLIENT]: str,
+    [CMD.SUB_LIBRARY]: str,
+    [CMD.LOAD_DYLINKER]: str,
+    [CMD.ID_DYLINKER]: str,
+    [CMD.DYLD_ENVIRONMENT]: str,
+    [CMD.RPATH]: str,
+    [CMD.PREBOUND_DYLIB]: {
         name: str,
         nmodules: uint32,
         linked_modules: str,
     },
-    [4 /* CMD.THREAD */]: thread_command,
-    [5 /* CMD.UNIXTHREAD */]: thread_command,
-    [17 /* CMD.ROUTINES */]: routines(32),
-    [26 /* CMD.ROUTINES_64 */]: routines(64),
-    [2 /* CMD.SYMTAB */]: symtab,
-    [22 /* CMD.TWOLEVEL_HINTS */]: count_table(hint),
-    [23 /* CMD.PREBIND_CKSUM */]: {
+    [CMD.THREAD]: thread_command,
+    [CMD.UNIXTHREAD]: thread_command,
+    [CMD.ROUTINES]: routines(32),
+    [CMD.ROUTINES_64]: routines(64),
+    [CMD.SYMTAB]: symtab,
+    [CMD.TWOLEVEL_HINTS]: count_table(hint),
+    [CMD.PREBIND_CKSUM]: {
         cksum: uint32,
     },
-    [27 /* CMD.UUID */]: {
+    [CMD.UUID]: {
         uuid: binary.Buffer(16),
     },
-    [29 /* CMD.CODE_SIGNATURE */]: blob,
-    [30 /* CMD.SEGMENT_SPLIT_INFO */]: blob,
-    [38 /* CMD.FUNCTION_STARTS */]: blobArray(binary.ULEB128),
-    [41 /* CMD.DATA_IN_CODE */]: blobArray(data_in_code_entry),
-    [43 /* CMD.DYLIB_CODE_SIGN_DRS */]: blob,
-    [46 /* CMD.LINKER_OPTIMIZATION_HINT */]: blob,
-    [2147483699 /* CMD.DYLD_EXPORTS_TRIE */]: blob,
-    [2147483700 /* CMD.DYLD_CHAINED_FIXUPS */]: blob, //blobT(dyld_chained_fixups),
-    [33 /* CMD.ENCRYPTION_INFO */]: {
+    [CMD.CODE_SIGNATURE]: blob,
+    [CMD.SEGMENT_SPLIT_INFO]: blob,
+    [CMD.FUNCTION_STARTS]: blobArray(binary.ULEB128),
+    [CMD.DATA_IN_CODE]: blobArray(data_in_code_entry),
+    [CMD.DYLIB_CODE_SIGN_DRS]: blob,
+    [CMD.LINKER_OPTIMIZATION_HINT]: blob,
+    [CMD.DYLD_EXPORTS_TRIE]: blob,
+    [CMD.DYLD_CHAINED_FIXUPS]: blob, //blobT(dyld_chained_fixups),
+    [CMD.ENCRYPTION_INFO]: {
         cryptoff: uint32, // file offset of encrypted range
         cryptsize: uint32, // file size of encrypted range
         cryptid: uint32, // which enryption system, 0 means not-encrypted yet
     },
-    [44 /* CMD.ENCRYPTION_INFO_64 */]: {
+    [CMD.ENCRYPTION_INFO_64]: {
         cryptoff: uint32, // file offset of encrypted range
         cryptsize: uint32, // file size of encrypted range
         cryptid: uint32, // which enryption system, 0 means not-encrypted yet
         pad: uint32, // must be zero
     },
-    [36 /* CMD.VERSION_MIN_MACOSX */]: version_min,
-    [37 /* CMD.VERSION_MIN_IPHONEOS */]: version_min,
-    [47 /* CMD.VERSION_MIN_TVOS */]: version_min,
-    [48 /* CMD.VERSION_MIN_WATCHOS */]: version_min,
-    [34 /* CMD.DYLD_INFO */]: dyldinfo,
-    [2147483682 /* CMD.DYLD_INFO_ONLY */]: dyldinfo,
-    [3 /* CMD.SYMSEG */]: blob, //OBSOLETE
+    [CMD.VERSION_MIN_MACOSX]: version_min,
+    [CMD.VERSION_MIN_IPHONEOS]: version_min,
+    [CMD.VERSION_MIN_TVOS]: version_min,
+    [CMD.VERSION_MIN_WATCHOS]: version_min,
+    [CMD.DYLD_INFO]: dyldinfo,
+    [CMD.DYLD_INFO_ONLY]: dyldinfo,
+    [CMD.SYMSEG]: blob, //OBSOLETE
     //	[CMD.IDENT]:					{},//OBSOLETE
-    [9 /* CMD.FVMFILE */]: {
+    [CMD.FVMFILE]: {
         name: str,
         header_addr: uint32,
     },
-    [2147483688 /* CMD.MAIN */]: {
+    [CMD.MAIN]: {
         entryoff: uint32, // file (__TEXT) offset of entry point
         stacksize: uint32, // if not zero, initialize stack size
     },
-    [42 /* CMD.SOURCE_VERSION */]: {
+    [CMD.SOURCE_VERSION]: {
         version: binary.as(binary.UINT64_BE, binary.BitFields({ a: 24, b: 10, c: 10, d: 10, e: 10 })) // A.B.C.D.E packed as a24.b10.c10.d10.e10
     },
-    [50 /* CMD.BUILD_VERSION */]: {
+    [CMD.BUILD_VERSION]: {
         platform: binary.asEnum(uint32, PLATFORM),
         minos: version,
         sdk: version,
         tools: binary.objectWithNames(binary.ArrayType(uint32, { tool: binary.as(uint32, binary.Enum(TOOL)), version }), binary.field('tool')),
     },
-    [45 /* CMD.LINKER_OPTION */]: {
+    [CMD.LINKER_OPTION]: {
         count: uint32, // number of strings following
     },
-    [49 /* CMD.NOTE */]: {
+    [CMD.NOTE]: {
         data_owner: fixed_string16, // owner name for this LC_NOTE
         data: blob
     },
     //	[CMD.PREPAGE]:					{},
-    [11 /* CMD.DYSYMTAB */]: {
+    [CMD.DYSYMTAB]: {
         localsym: index_table, // local symbols
         extdefsym: index_table, // externally defined symbols
         undefsym: index_table, // undefined symbols
@@ -910,9 +966,6 @@ const cmd_table = {
     },
 };
 class MachFile {
-    header;
-    commands = [];
-    ready;
     static check(data) {
         switch (binary.UINT32_BE.get(new binary.stream(data))) {
             case 0xfeedface:
@@ -924,25 +977,27 @@ class MachFile {
                 return false;
         }
     }
+    header;
+    commands = [];
     constructor(data, mem) {
         const magic = binary.UINT32_LE.get(new binary.stream(data));
         switch (magic) {
             case 0xfeedface:
-                this.ready = this.load(data, false, 32, mem);
+                this.load(data, false, 32, mem);
                 break;
             case 0xcefaedfe:
-                this.ready = this.load(data, true, 32, mem);
+                this.load(data, true, 32, mem);
                 break;
             case 0xfeedfacf:
-                this.ready = this.load(data, false, 64, mem);
+                this.load(data, false, 64, mem);
                 break;
             case 0xcffaedfe:
-                this.ready = this.load(data, true, 64, mem);
+                this.load(data, true, 64, mem);
                 break;
             default: throw new Error('not a mach file');
         }
     }
-    async load(data, be, bits, mem) {
+    load(data, be, bits, mem) {
         const file = new binary.endianStream(data, be);
         const h = binary.read(file, header);
         const cpu = CPU_TYPE[h.cputype];
@@ -952,14 +1007,14 @@ class MachFile {
         for (let i = 0; i < h.ncmds; ++i) {
             const cmd = binary.read(file, command);
             const file2 = new mach_stream(data, file.read_buffer(cmd.cmdsize - 8), file.be, mem);
-            const result = await binary.read(file2, cmd_table[cmd.cmd] ?? {});
+            const result = binary.read(file2, cmd_table[cmd.cmd] ?? {});
             this.commands.push({ cmd: cmd.cmd, data: result });
         }
         this.header = h;
-        const funcs = this.getCommand(38 /* CMD.FUNCTION_STARTS */);
+        const funcs = this.getCommand(CMD.FUNCTION_STARTS);
         if (funcs) {
             const array = funcs.contents;
-            const text = await this.getSegment('__TEXT');
+            const text = this.getSegment('__TEXT');
             let acc = BigInt(text?.vmaddr ?? 0);
             for (const i in array)
                 array[i] = (acc += BigInt(array[i]));
@@ -973,9 +1028,9 @@ class MachFile {
     }
     getSegment(name) {
         for (const i of this.commands) {
-            if (i.cmd === 1 /* CMD.SEGMENT */ && i.data.segname === name)
+            if (i.cmd === CMD.SEGMENT && i.data.segname === name)
                 return i.data;
-            if (i.cmd === 25 /* CMD.SEGMENT_64 */ && i.data.segname === name)
+            if (i.cmd === CMD.SEGMENT_64 && i.data.segname === name)
                 return i.data;
             ;
         }

package/dist/pe.d copy.ts

@@ -0,0 +1,144 @@
+import * as binary from '@isopodlabs/binary';
+declare const DOS_HEADER: {
+    magic: binary.TypeT<number>;
+    cblp: binary.TypeT<number>;
+    cp: binary.TypeT<number>;
+    crlc: binary.TypeT<number>;
+    cparhdr: binary.TypeT<number>;
+    minalloc: binary.TypeT<number>;
+    maxalloc: binary.TypeT<binary.hex<number | bigint>>;
+    ss: binary.TypeT<number>;
+    sp: binary.TypeT<number>;
+    csum: binary.TypeT<number>;
+    ip: binary.TypeT<number>;
+    cs: binary.TypeT<number>;
+    lfarlc: binary.TypeT<number>;
+    ovno: binary.TypeT<number>;
+};
+declare const EXE_HEADER: {
+    res: binary.TypeT<number[]>;
+    oemid: binary.TypeT<number>;
+    oeminfo: binary.TypeT<number>;
+    res2: binary.TypeT<number[]>;
+    lfanew: binary.TypeT<number>;
+};
+export declare class pe_stream extends binary.stream {
+    pe: PE;
+    constructor(pe: PE, data: Uint8Array);
+    get_rva(): Uint8Array | undefined;
+}
+declare const Section_base: (new (s: binary._stream) => {
+    Name: string;
+    VirtualSize: number;
+    VirtualAddress: binary.hex<number | bigint>;
+    SizeOfRawData: number;
+    PointerToRawData: binary.hex<number | bigint>;
+    PointerToRelocations: binary.hex<number | bigint>;
+    PointerToLinenumbers: binary.hex<number | bigint>;
+    NumberOfRelocations: number;
+    NumberOfLinenumbers: number;
+    Characteristics: Record<string, bigint | boolean> | Record<string, number | boolean>;
+}) & {
+    get: <X extends abstract new (...args: any) => any>(this: X, s: binary._stream) => InstanceType<X>;
+};
+declare class Section extends Section_base {
+    data?: binary.MappedMemory;
+    constructor(r: binary.stream);
+    get flags(): number;
+}
+interface DirectoryInfo {
+    read?: (pe: PE, data: binary.MappedMemory) => any;
+}
+export declare const DIRECTORIES: Record<string, DirectoryInfo>;
+export declare const DATA_DIRECTORY: {
+    VirtualAddress: binary.TypeT<number>;
+    Size: binary.TypeT<number>;
+};
+type Directory = binary.ReadType<typeof DATA_DIRECTORY>;
+declare const OPTIONAL_HEADER: {
+    Magic: binary.TypeT<string>;
+    MajorLinkerVersion: binary.TypeT<number>;
+    MinorLinkerVersion: binary.TypeT<number>;
+    SizeOfCode: binary.TypeT<number>;
+    SizeOfInitializedData: binary.TypeT<number>;
+    SizeOfUninitializedData: binary.TypeT<number>;
+    AddressOfEntryPoint: binary.TypeT<binary.hex<number | bigint>>;
+    BaseOfCode: binary.TypeT<binary.hex<number | bigint>>;
+};
+declare const OPTIONAL_HEADER32: {
+    BaseOfData: binary.TypeT<binary.hex<number | bigint>>;
+    ImageBase: binary.TypeT<binary.hex<number | bigint>>;
+    SectionAlignment: binary.TypeT<number>;
+    FileAlignment: binary.TypeT<number>;
+    MajorOperatingSystemVersion: binary.TypeT<number>;
+    MinorOperatingSystemVersion: binary.TypeT<number>;
+    MajorImageVersion: binary.TypeT<number>;
+    MinorImageVersion: binary.TypeT<number>;
+    MajorSubsystemVersion: binary.TypeT<number>;
+    MinorSubsystemVersion: binary.TypeT<number>;
+    Win32VersionValue: binary.TypeT<number>;
+    SizeOfImage: binary.TypeT<number>;
+    SizeOfHeaders: binary.TypeT<number>;
+    CheckSum: binary.TypeT<number>;
+    Subsystem: binary.TypeT<number>;
+    DllCharacteristics: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+    SizeOfStackReserve: binary.TypeT<number>;
+    SizeOfStackCommit: binary.TypeT<number>;
+    SizeOfHeapReserve: binary.TypeT<number>;
+    SizeOfHeapCommit: binary.TypeT<number>;
+    LoaderFlags: binary.TypeT<number>;
+    DataDirectory: binary.TypeT<Record<string, {
+        VirtualAddress: number;
+        Size: number;
+    }>>;
+};
+declare const OPTIONAL_HEADER64: {
+    ImageBase: binary.TypeT<binary.hex<number | bigint>>;
+    SectionAlignment: binary.TypeT<number>;
+    FileAlignment: binary.TypeT<number>;
+    MajorOperatingSystemVersion: binary.TypeT<number>;
+    MinorOperatingSystemVersion: binary.TypeT<number>;
+    MajorImageVersion: binary.TypeT<number>;
+    MinorImageVersion: binary.TypeT<number>;
+    MajorSubsystemVersion: binary.TypeT<number>;
+    MinorSubsystemVersion: binary.TypeT<number>;
+    Win32VersionValue: binary.TypeT<number>;
+    SizeOfImage: binary.TypeT<number>;
+    SizeOfHeaders: binary.TypeT<number>;
+    CheckSum: binary.TypeT<number>;
+    Subsystem: binary.TypeT<number>;
+    DllCharacteristics: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+    SizeOfStackReserve: binary.TypeT<bigint>;
+    SizeOfStackCommit: binary.TypeT<bigint>;
+    SizeOfHeapReserve: binary.TypeT<bigint>;
+    SizeOfHeapCommit: binary.TypeT<bigint>;
+    LoaderFlags: binary.TypeT<number>;
+    DataDirectory: binary.TypeT<Record<string, {
+        VirtualAddress: number;
+        Size: number;
+    }>>;
+};
+export declare class PE {
+    private data;
+    header: binary.ReadType<typeof DOS_HEADER> & binary.ReadType<typeof EXE_HEADER>;
+    opt?: binary.ReadType<typeof OPTIONAL_HEADER> & (binary.ReadType<typeof OPTIONAL_HEADER32> | binary.ReadType<typeof OPTIONAL_HEADER64>);
+    sections: Section[];
+    static check(data: Uint8Array): boolean;
+    constructor(data: Uint8Array);
+    get directories(): Record<string, {
+        VirtualAddress: number;
+        Size: number;
+    }> | undefined;
+    FindSectionRVA(rva: number): Section | undefined;
+    FindSectionRaw(addr: number): Section | undefined;
+    GetDataRVA(rva: number, size?: number): binary.MappedMemory | undefined;
+    GetDataRaw(addr: number, size: number): Uint8Array | undefined;
+    GetDataDir(dir: Directory): binary.MappedMemory | undefined;
+    ReadDirectory(name: string): any;
+}
+export declare function ReadExports(file: pe_stream): (string | number | binary.MappedMemory | undefined)[][];
+export declare class DLLImports extends Array {
+}
+export declare function ReadImports(file: pe_stream): [string, any][];
+export declare function ReadResourceDirectory(file: binary.stream, data: binary.MappedMemory, type?: number): Record<string, any>;
+export {};

package/dist/pe.d.ts

@@ -16,18 +16,7 @@ declare const Section_base: (new (s: binary._stream) => {
     NumberOfLinenumbers: number;
     Characteristics: Record<string, bigint | boolean> | Record<string, number | boolean>;
 }) & {
-    get: (s: binary._stream) => {
-        Name: string;
-        VirtualSize: number;
-        VirtualAddress: binary.hex<number | bigint>;
-        SizeOfRawData: number;
-        PointerToRawData: binary.hex<number | bigint>;
-        PointerToRelocations: binary.hex<number | bigint>;
-        PointerToLinenumbers: binary.hex<number | bigint>;
-        NumberOfRelocations: number;
-        NumberOfLinenumbers: number;
-        Characteristics: Record<string, bigint | boolean> | Record<string, number | boolean>;
-    };
+    get: <X extends abstract new (...args: any) => any>(this: X, s: binary._stream) => InstanceType<X>;
 };
 declare class Section extends Section_base {
     data?: binary.MappedMemory;
@@ -47,7 +36,7 @@ type Directory = {
     Size: number;
 };
 export declare class PE {
-    private data;
+    static check(data: Uint8Array): boolean;
     header: {
         magic: number;
         cblp: number;
@@ -132,20 +121,16 @@ export declare class PE {
         }>;
     });
     sections: Section[];
-    static check(data: Uint8Array): boolean;
     constructor(data: Uint8Array);
     get directories(): Record<string, {
         VirtualAddress: number;
         Size: number;
-    } & {}> | undefined;
+    }> | undefined;
     FindSectionRVA(rva: number): Section | undefined;
     FindSectionRaw(addr: number): Section | undefined;
     GetDataRVA(rva: number, size?: number): binary.MappedMemory | undefined;
     GetDataRaw(addr: number, size: number): Uint8Array | undefined;
-    GetDataDir(dir: {
-        VirtualAddress: number;
-        Size: number;
-    }): binary.MappedMemory | undefined;
+    GetDataDir(dir: Directory): binary.MappedMemory | undefined;
     ReadDirectory(name: string): any;
 }
 export declare function ReadExports(file: pe_stream): (string | number | binary.MappedMemory | undefined)[][];

package/dist/pe.js

@@ -271,15 +271,13 @@ const OPTIONAL_HEADER64 = {
     DataDirectory: binary.objectWithNames(binary.ArrayType(uint32, exports.DATA_DIRECTORY), binary.names(Object.keys(exports.DIRECTORIES))),
 };
 class PE {
-    data;
-    header;
-    opt;
-    sections;
     static check(data) {
         return uint16.get(new binary.stream(data)) === binary.utils.stringCode("MZ");
     }
+    header;
+    opt;
+    sections;
     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);
@@ -438,7 +436,7 @@ const RESOURCE_DIRECTORY = {
     MinorVersion: uint16,
     NumberOfNamedEntries: uint16,
     NumberOfIdEntries: uint16,
-    entries: binary.ArrayType(obj => obj.NumberOfNamedEntries + obj.NumberOfIdEntries, {
+    entries: binary.ArrayType(s => s.obj.NumberOfNamedEntries + s.obj.NumberOfIdEntries, {
         u0: uint32,
         u1: uint32,
     })

package/package.json

@@ -16,7 +16,8 @@
   "scripts": {
     "build": "tsc",
     "lint": "eslint \"src/**/*.ts\"",
-    "test": "echo \"No tests specified\" && exit 0"
+    "test": "echo \"No tests specified\" && exit 0",
+    "patch": "ts-patch install"
   },
   "keywords": [
     "binary",
@@ -40,5 +41,5 @@
   "dependencies": {
     "@isopodlabs/binary": "^1.0.3"
   },
-  "version": "0.1.4"
+  "version": "0.2.0"
 }