@isopodlabs/binary_libs 0.1.5 → 0.2.1

package/README.md

@@ -9,16 +9,15 @@ This package provides readers for various library formats, using the @isopodlabs
 ELF
 ```typescript
 class ELFFile {
-    segments: [string, any][];
-    sections: [string, any][];
-    symbols?: [string, any][];
-    dynamic_symbols?: [string, any][];
-    header: any;
     static check(data: Uint8Array): boolean;
-    constructor(data: Uint8Array);
-    getSymbols(type: binary.Type, data: Uint8Array, names: Uint8Array): [string, any][];
+    segments: [string, Segment][];
+    sections: [string, Section][];
+    header: Header;
+    getSymbols(): [string, Symbol][];
+    getDynamicSymbols(): [string, Symbol][];
+    getSegmentByType(type: string): Segment | undefined;
+    getSectionByType(type: string): Section | undefined;
 }
-
 ```
 
 ### pe
@@ -26,7 +25,9 @@ Portable Executable
 ```typescript
 class PE {
     static check(data: Uint8Array): boolean;
-    constructor(data: Uint8Array);
+    header: Header;
+    opt?:   OptHeader;
+    sections: Section[];
     get directories(): {
         [k: string]: any;
     } | undefined;
@@ -43,87 +44,51 @@ class PE {
 Common Language Runtime (embedded in pe files)
 ```typescript
 class CLR {
-    header: any;
-    table_info: any;
+    header: Header;
+    table_info: TableInfo;
     heaps: Uint8Array[];
     tables: Record<TABLE, Table>;
-    raw?: Uint8Array;
     Resources?: Uint8Array;
-    constructor(pe: pe.PE, clr_data: Uint8Array);
     getEntry(t: TABLE, i: number): any;
-    getTable(t: TABLE.Module): ({ generation: number; name: string; mvid: string; encid: string; encbaseid: string; } & {})[];
-    getTable(t: TABLE.TypeRef): ({ scope: number; name: string; namespce: string; } & {})[];
-    getTable(t: TABLE.TypeDef): ({ flags: number; name: string; namespce: string; extends: number; fields: number; methods: number; } & {})[];
-    getTable(t: TABLE.Field): ({ flags: number; name: string; signature: Uint8Array; } & {})[];
-    getTable(t: TABLE.MethodDef): ({ code: number; implflags: number; flags: number; name: string; signature: Uint8Array; paramlist: number; } & {})[];
-    getTable(t: TABLE.Param): ({ flags: number; sequence: number; name: string; } & {})[];
-    getTable(t: TABLE.InterfaceImpl): ({ clss: number; interfce: number; } & {})[];
-    getTable(t: TABLE.MemberRef): ({ clss: number; name: string; signature: Uint8Array; } & {})[];
-    getTable(t: TABLE.Constant): ({ type: number; parent: number; value: Uint8Array; } & {})[];
-    getTable(t: TABLE.CustomAttribute): ({ parent: number; type: number; value: Uint8Array; } & {})[];
-    getTable(t: TABLE.FieldMarshal): ({ parent: number; native_type: Uint8Array; } & {})[];
-    getTable(t: TABLE.DeclSecurity): ({ action: number; parent: number; permission_set: Uint8Array; } & {})[];
-    getTable(t: TABLE.ClassLayout): ({ packing_size: number; class_size: number; parent: number; } & {})[];
-    getTable(t: TABLE.FieldLayout): ({ offset: number; field: number; } & {})[];
-    getTable(t: TABLE.StandAloneSig): ({ signature: Uint8Array; } & {})[];
-    getTable(t: TABLE.EventMap): ({ parent: number; event_list: number; } & {})[];
-    getTable(t: TABLE.Event): ({ flags: number; name: string; event_type: number; } & {})[];
-    getTable(t: TABLE.PropertyMap): ({ parent: number; property_list: number; } & {})[];
-    getTable(t: TABLE.Property): ({ flags: number; name: string; type: Uint8Array; } & {})[];
-    getTable(t: TABLE.MethodSemantics): ({ flags: number; method: number; association: number; } & {})[];
-    getTable(t: TABLE.MethodImpl): ({ clss: number; method_body: number; method_declaration: number; } & {})[];
-    getTable(t: TABLE.ModuleRef): ({ name: string; } & {})[];
-    getTable(t: TABLE.TypeSpec): ({ signature: Uint8Array; } & {})[];
-    getTable(t: TABLE.ImplMap): ({ flags: number; member_forwarded: number; name: string; scope: number; } & {})[];
-    getTable(t: TABLE.FieldRVA): ({ rva: number; field: number; } & {})[];
-    getTable(t: TABLE.Assembly): ({ hashalg: number; major: number; minor: number; build: number; rev: number; flags: number; publickey: Uint8Array; name: string; culture: string; } & {})[];
-    getTable(t: TABLE.AssemblyProcessor): ({ processor: number; } & {})[];
-    getTable(t: TABLE.AssemblyOS): ({ platform: number; minor: number; major: number; } & {})[];
-    getTable(t: TABLE.AssemblyRef): ({ major: number; minor: number; build: number; rev: number; flags: number; publickey: Uint8Array; name: string; culture: string; hashvalue: Uint8Array; } & {})[];
-    getTable(t: TABLE.AssemblyRefProcessor): ({ processor: number; assembly: number; } & {})[];
-    getTable(t: TABLE.AssemblyRefOS): ({ platform: number; major: number; minor: number; assembly: number; } & {})[];
-    getTable(t: TABLE.File): ({ flags: number; name: string; hash: Uint8Array; } & {})[];
-    getTable(t: TABLE.ExportedType): ({ flags: number; typedef_id: number; name: string; namespce: string; implementation: number; } & {})[];
-    getTable(t: TABLE.ManifestResource): ({ data: number; flags: number; name: string; implementation: number; } & {})[];
-    getTable(t: TABLE.NestedClass): ({ nested_class: number; enclosing_class: number; } & {})[];
-    getTable(t: TABLE.GenericParam): ({ number: number; flags: number; owner: number; name: string; } & {})[];
-    getTable(t: TABLE.MethodSpec): ({ method: number; instantiation: Uint8Array; } & {})[];
-    getTable(t: TABLE.GenericParamConstraint): ({ owner: number; constraint: number; } & {})[];
+    getTable(t: TABLE): any;
     getResources(block: string): Record<string, any> | undefined;
     getResource(block: string, name: string): any;
-    allResources(): {} | undefined;
+    allResources(): any;
 }
 ```
 ### mach
 Apple libraries
 ```typescript
-declare function segment(bits: 32 | 64): {
-    get(s: mach_stream): Promise<{
-        data: binary.utils.MappedMemory | undefined;
-        segname: string;
-        vmaddr: number | bigint;
-        vmsize: number | bigint;
-        fileoff: number | bigint;
-        filesize: number | bigint;
-        maxprot: number;
-        initprot: number;
-        nsects: number;
-        flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
-        sections: Record<string, any> | undefined;
-    } & {}>;
+interface Segment {
+    data: binary.utils.MappedMemory | undefined;
+    segname: string;
+    vmaddr: number | bigint;
+    vmsize: number | bigint;
+    fileoff: number | bigint;
+    filesize: number | bigint;
+    maxprot: number;
+    initprot: number;
+    nsects: number;
+    flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+    sections: Record<string, any> | undefined;
 };
-export declare class MachFile {
-    header: any;
-    commands: { cmd: CMD; data: any; }[];
-    ready: Promise<void>;
+class MachFile {
     static check(data: Uint8Array): boolean;
+    header: Header;
+    commands: { cmd: CMD; data: any; }[];
     constructor(data: Uint8Array, mem?: binary.utils.memory);
-    load(data: Uint8Array, be: boolean, bits: 32 | 64, mem?: binary.utils.memory): Promise<void>;
-    getCommand(cmd: number): any;
-    getSegment(name: string): Promise<{ data: binary.utils.MappedMemory | undefined; segname: string; vmaddr: number | bigint; vmsize: number | bigint; fileoff: number | bigint; filesize: number | bigint; maxprot: number; initprot: number; nsects: number; flags: Record<string, bigint | boolean> | Record<string, number | boolean>; sections: Record<string, any> | undefined; } & {}> | undefined;
+    getCommand(cmd: CMD): any;
+    getSegment(name: string): Segment;
 }
 class FATMachFile {
-    archs: ({ cputype: string; cpusubtype: string | number; offset: number; size: number; align: number; contents: MachFile | undefined; } & {})[];
+    archs:  {
+        cputype: string;
+        cpusubtype: string | number;
+        offset: number;
+        size: number;
+        align: number;
+        contents: MachFile | undefined;
+    }[];
     static check(data: Uint8Array): boolean;
     constructor(data: Uint8Array, mem?: binary.utils.memory);
     load(file: binary.stream_endian, mem?: binary.utils.memory): void;
@@ -134,19 +99,18 @@ class FATMachFile {
 Archive files for static linking
 
 ```typescript
-type HEADER = {
-    name: string;
-    date: number;
-    uid: number;
-    gid: number;
-    mode: number;
-    size: number;
-    fmag: string;
-    contents: any;
-};
 declare class ArchFile {
-    members: HEADER[];
     static check(data: Uint8Array): boolean;
+    members: {
+        name: string;
+        date: number;
+        uid: number;
+        gid: number;
+        mode: number;
+        size: number;
+        fmag: string;
+        contents: any;
+    }[];
     constructor(data: Uint8Array);
 }
 ```

package/dist/CompoundDocument.d.ts

@@ -40,26 +40,7 @@ declare const Header_base: (new (s: binary._stream) => {
 } & {
     write(w: binary._stream): void;
 }) & {
-    get: (s: binary._stream) => {
-        magic: bigint;
-        id: Uint8Array;
-        revision: number;
-        version: number;
-        byteorder: number;
-        sector_shift: number;
-        mini_shift: number;
-        unused1: void;
-        num_directory: number;
-        num_fat: number;
-        first_directory: number;
-        transaction: void;
-        mini_cutoff: number;
-        first_mini: number;
-        num_mini: number;
-        first_difat: number;
-        num_difat: number;
-        difat: Uint8Array;
-    };
+    get: <X extends abstract new (...args: any) => any>(this: X, s: binary._stream) => InstanceType<X>;
     put: (s: binary._stream, v: any) => void;
 };
 export declare class Header extends Header_base {
@@ -85,22 +66,7 @@ declare const DirEntry_base: (new (s: binary._stream) => {
 } & {
     write(w: binary._stream): void;
 }) & {
-    get: (s: binary._stream) => {
-        name: string;
-        name_size: number;
-        type: number;
-        colour: number;
-        left: number;
-        right: number;
-        root: number;
-        guid: Uint8Array;
-        flags: number;
-        creation: bigint;
-        modification: bigint;
-        sec_id: number;
-        size: number;
-        unused: number;
-    };
+    get: <X extends abstract new (...args: any) => any>(this: X, s: binary._stream) => InstanceType<X>;
     put: (s: binary._stream, v: any) => void;
 };
 declare class DirEntry extends DirEntry_base {

package/dist/arch.d.ts

@@ -10,6 +10,7 @@ export type HEADER = {
     contents: any;
 };
 export declare class ArchFile {
+    static check(data: Uint8Array): boolean;
     members: {
         name: string;
         date: number;
@@ -20,7 +21,6 @@ export declare class ArchFile {
         fmag: string;
         contents: any;
     }[];
-    static check(data: Uint8Array): boolean;
     constructor(data: Uint8Array);
 }
 export {};

package/dist/arch.js

@@ -43,10 +43,10 @@ const SYM64 = {
     offset: binary.asInt(binary.StringType(4))
 };
 class ArchFile {
-    members = [];
     static check(data) {
         return binary.utils.decodeText(data.subarray(0, 8), 'utf8') == '!<arch>\n';
     }
+    members = [];
     constructor(data) {
         const s = new binary.stream(data);
         const header = binary.read(s, binary.StringType(8));

package/dist/clr.d.ts

@@ -53,33 +53,237 @@ declare class clr_stream extends binary.stream {
     getGUID(): string;
     getBlob(): Uint8Array;
 }
-declare class Indexed {
-    table: number;
-    constructor(table: number);
-    get(s: clr_stream): number;
-}
-declare class IndexedList extends Indexed {
-    get(s: clr_stream): number;
-}
-declare class CodedIndex {
-    trans: number[];
-    B: number;
-    constructor(trans: number[], B: number);
-    get(s: clr_stream): number;
-}
 interface Table {
     count: number;
     size: number;
     offset: number;
 }
 export declare class CLR {
-    header: any;
-    table_info: any;
+    private raw?;
+    header: {
+        cb: number;
+        MajorRuntimeVersion: number;
+        MinorRuntimeVersion: number;
+        MetaData: never;
+        Flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+        EntryPoint: number;
+        Resources: never;
+        StrongNameSignature: never;
+        CodeManagerTable: never;
+        VTableFixups: never;
+        ExportAddressTableJumps: never;
+    };
+    table_info: {
+        Reserved: number;
+        MajorVersion: number;
+        MinorVersion: number;
+        HeapSizes: number;
+        Reserved2: number;
+        Valid: bigint;
+        Sorted: bigint;
+    } | undefined;
     heaps: Uint8Array[];
     tables: Record<TABLE, Table>;
-    raw?: Uint8Array;
     Resources?: Uint8Array;
     constructor(pe: pe.PE, clr_data: Uint8Array);
+    getEntry(t: TABLE.Module, i: number): {
+        generation: number;
+        name: string;
+        mvid: string;
+        encid: string;
+        encbaseid: string;
+    };
+    getEntry(t: TABLE.TypeRef, i: number): {
+        scope: number;
+        name: string;
+        namespce: string;
+    };
+    getEntry(t: TABLE.TypeDef, i: number): {
+        flags: number;
+        name: string;
+        namespce: string;
+        extends: number;
+        fields: number;
+        methods: number;
+    };
+    getEntry(t: TABLE.Field, i: number): {
+        flags: number;
+        name: string;
+        signature: Uint8Array;
+    };
+    getEntry(t: TABLE.MethodDef, i: number): {
+        code: number;
+        implflags: number;
+        flags: number;
+        name: string;
+        signature: Uint8Array;
+        paramlist: number;
+    };
+    getEntry(t: TABLE.Param, i: number): {
+        flags: number;
+        sequence: number;
+        name: string;
+    };
+    getEntry(t: TABLE.InterfaceImpl, i: number): {
+        clss: number;
+        interfce: number;
+    };
+    getEntry(t: TABLE.MemberRef, i: number): {
+        clss: number;
+        name: string;
+        signature: Uint8Array;
+    };
+    getEntry(t: TABLE.Constant, i: number): {
+        type: number;
+        parent: number;
+        value: Uint8Array;
+    };
+    getEntry(t: TABLE.CustomAttribute, i: number): {
+        parent: number;
+        type: number;
+        value: Uint8Array;
+    };
+    getEntry(t: TABLE.FieldMarshal, i: number): {
+        parent: number;
+        native_type: Uint8Array;
+    };
+    getEntry(t: TABLE.DeclSecurity, i: number): {
+        action: number;
+        parent: number;
+        permission_set: Uint8Array;
+    };
+    getEntry(t: TABLE.ClassLayout, i: number): {
+        packing_size: number;
+        class_size: number;
+        parent: number;
+    };
+    getEntry(t: TABLE.FieldLayout, i: number): {
+        offset: number;
+        field: number;
+    };
+    getEntry(t: TABLE.StandAloneSig, i: number): {
+        signature: Uint8Array;
+    };
+    getEntry(t: TABLE.EventMap, i: number): {
+        parent: number;
+        event_list: number;
+    };
+    getEntry(t: TABLE.Event, i: number): {
+        flags: number;
+        name: string;
+        event_type: number;
+    };
+    getEntry(t: TABLE.PropertyMap, i: number): {
+        parent: number;
+        property_list: number;
+    };
+    getEntry(t: TABLE.Property, i: number): {
+        flags: number;
+        name: string;
+        type: Uint8Array;
+    };
+    getEntry(t: TABLE.MethodSemantics, i: number): {
+        flags: number;
+        method: number;
+        association: number;
+    };
+    getEntry(t: TABLE.MethodImpl, i: number): {
+        clss: number;
+        method_body: number;
+        method_declaration: number;
+    };
+    getEntry(t: TABLE.ModuleRef, i: number): {
+        name: string;
+    };
+    getEntry(t: TABLE.TypeSpec, i: number): {
+        signature: Uint8Array;
+    };
+    getEntry(t: TABLE.ImplMap, i: number): {
+        flags: number;
+        member_forwarded: number;
+        name: string;
+        scope: number;
+    };
+    getEntry(t: TABLE.FieldRVA, i: number): {
+        rva: number;
+        field: number;
+    };
+    getEntry(t: TABLE.Assembly, i: number): {
+        hashalg: number;
+        major: number;
+        minor: number;
+        build: number;
+        rev: number;
+        flags: number;
+        publickey: Uint8Array;
+        name: string;
+        culture: string;
+    };
+    getEntry(t: TABLE.AssemblyProcessor, i: number): {
+        processor: number;
+    };
+    getEntry(t: TABLE.AssemblyOS, i: number): {
+        platform: number;
+        minor: number;
+        major: number;
+    };
+    getEntry(t: TABLE.AssemblyRef, i: number): {
+        major: number;
+        minor: number;
+        build: number;
+        rev: number;
+        flags: number;
+        publickey: Uint8Array;
+        name: string;
+        culture: string;
+        hashvalue: Uint8Array;
+    };
+    getEntry(t: TABLE.AssemblyRefProcessor, i: number): {
+        processor: number;
+        assembly: number;
+    };
+    getEntry(t: TABLE.AssemblyRefOS, i: number): {
+        platform: number;
+        major: number;
+        minor: number;
+        assembly: number;
+    };
+    getEntry(t: TABLE.File, i: number): {
+        flags: number;
+        name: string;
+        hash: Uint8Array;
+    };
+    getEntry(t: TABLE.ExportedType, i: number): {
+        flags: number;
+        typedef_id: number;
+        name: string;
+        namespce: string;
+        implementation: number;
+    };
+    getEntry(t: TABLE.ManifestResource, i: number): {
+        data: number;
+        flags: number;
+        name: string;
+        implementation: number;
+    };
+    getEntry(t: TABLE.NestedClass, i: number): {
+        nested_class: number;
+        enclosing_class: number;
+    };
+    getEntry(t: TABLE.GenericParam, i: number): {
+        number: number;
+        flags: number;
+        owner: number;
+        name: string;
+    };
+    getEntry(t: TABLE.MethodSpec, i: number): {
+        method: number;
+        instantiation: Uint8Array;
+    };
+    getEntry(t: TABLE.GenericParamConstraint, i: number): {
+        owner: number;
+        constraint: number;
+    };
     getEntry(t: TABLE, i: number): any;
     getTable(t: TABLE.Module): {
         generation: number;
@@ -279,8 +483,9 @@ export declare class CLR {
         owner: number;
         constraint: number;
     }[];
+    getTable(t: TABLE): any;
     getResources(block: string): Record<string, any> | undefined;
     getResource(block: string, name: string): any;
-    allResources(): {} | undefined;
+    allResources(): any;
 }
 export {};

package/dist/clr.js

@@ -222,278 +222,236 @@ const clr_Blob = {
 const Signature = clr_Blob;
 const CustomAttributeValue = clr_Blob;
 const clr_Code = binary.UINT32_LE;
-class Indexed {
-    table;
-    constructor(table) {
-        this.table = table;
-    }
-    get(s) { return s.getIndex(this.table); }
+function Indexed(table) {
+    return {
+        get(s) { return s.getIndex(table); }
+    };
 }
-class IndexedList extends Indexed {
-    get(s) { return s.getIndex(this.table); }
+function IndexedList(table) {
+    return {
+        get(s) { return s.getIndex(table); }
+    };
 }
-class CodedIndex {
-    trans;
-    B;
-    constructor(trans, B) {
-        this.trans = trans;
-        this.B = B;
-    }
-    get(s) { return s.getCodedIndex(this.B, this.trans); }
+function CodedIndex(trans, B) {
+    return {
+        get(s) { return s.getCodedIndex(B, trans); }
+    };
 }
-const TypeDefOrRef = new CodedIndex([TABLE.TypeDef, TABLE.TypeRef, TABLE.TypeSpec], 2);
-const HasConstant = new CodedIndex([TABLE.Field, TABLE.Param, TABLE.Property], 2);
-const HasCustomAttribute = new CodedIndex([
+const TypeDefOrRef = CodedIndex([TABLE.TypeDef, TABLE.TypeRef, TABLE.TypeSpec], 2);
+const HasConstant = CodedIndex([TABLE.Field, TABLE.Param, TABLE.Property], 2);
+const HasCustomAttribute = CodedIndex([
     TABLE.MethodDef, TABLE.Field, TABLE.TypeRef, TABLE.TypeDef, TABLE.Param, TABLE.InterfaceImpl, TABLE.MemberRef, TABLE.Module, TABLE.DeclSecurity, TABLE.Property, TABLE.Event, TABLE.StandAloneSig,
     TABLE.ModuleRef, TABLE.TypeSpec, TABLE.Assembly, TABLE.AssemblyRef, TABLE.File, TABLE.ExportedType, TABLE.ManifestResource, TABLE.GenericParam, TABLE.GenericParamConstraint, TABLE.MethodSpec,
 ], 5);
-const HasFieldMarshall = new CodedIndex([TABLE.Field, TABLE.Param], 1);
-const HasDeclSecurity = new CodedIndex([TABLE.TypeDef, TABLE.MethodDef, TABLE.Assembly], 2);
-const MemberRefParent = new CodedIndex([TABLE.TypeDef, TABLE.TypeRef, TABLE.ModuleRef, TABLE.MethodDef, TABLE.TypeSpec], 1);
-const HasSemantics = new CodedIndex([TABLE.Event, TABLE.Property], 1);
-const MethodDefOrRef = new CodedIndex([TABLE.MethodDef, TABLE.MemberRef], 1);
-const MemberForwarded = new CodedIndex([TABLE.Field, TABLE.MethodDef], 1);
-const Implementation = new CodedIndex([TABLE.File, TABLE.AssemblyRef, TABLE.ExportedType], 2);
-const CustomAttributeType = new CodedIndex([0, 0, TABLE.MethodDef, TABLE.MemberRef], 3);
-const TypeOrMethodDef = new CodedIndex([TABLE.TypeDef, TABLE.MethodDef], 1);
-const ResolutionScope = new CodedIndex([TABLE.Module, TABLE.ModuleRef, TABLE.AssemblyRef, TABLE.TypeRef], 2);
-const ENTRY_Module = {
-    generation: binary.UINT16_LE,
-    name: clr_String,
-    mvid: clr_GUID,
-    encid: clr_GUID,
-    encbaseid: clr_GUID,
-};
-const ENTRY_TypeRef = {
-    scope: ResolutionScope,
-    name: clr_String,
-    namespce: clr_String,
-};
-const ENTRY_TypeDef = {
-    flags: binary.UINT32_LE,
-    name: clr_String,
-    namespce: clr_String,
-    extends: TypeDefOrRef,
-    fields: new IndexedList(TABLE.Field),
-    methods: new IndexedList(TABLE.MethodDef),
-};
-const ENTRY_Field = {
-    flags: binary.UINT16_LE,
-    name: clr_String,
-    signature: Signature,
-};
-const ENTRY_MethodDef = {
-    code: clr_Code,
-    implflags: binary.UINT16_LE,
-    flags: binary.UINT16_LE,
-    name: clr_String,
-    signature: Signature,
-    paramlist: new IndexedList(TABLE.Param),
-};
-const ENTRY_Param = {
-    flags: binary.UINT16_LE,
-    sequence: binary.UINT16_LE,
-    name: clr_String,
-};
-const ENTRY_InterfaceImpl = {
-    clss: new Indexed(TABLE.TypeDef),
-    interfce: TypeDefOrRef,
-};
-const ENTRY_MemberRef = {
-    clss: MemberRefParent,
-    name: clr_String,
-    signature: Signature,
-};
-const ENTRY_Constant = {
-    type: binary.UINT16_LE,
-    parent: HasConstant,
-    value: clr_Blob,
-};
-const ENTRY_CustomAttribute = {
-    parent: HasCustomAttribute,
-    type: CustomAttributeType,
-    value: CustomAttributeValue,
-};
-const ENTRY_FieldMarshal = {
-    parent: HasFieldMarshall,
-    native_type: clr_Blob,
-};
-const ENTRY_DeclSecurity = {
-    action: binary.UINT16_LE,
-    parent: HasDeclSecurity,
-    permission_set: clr_Blob,
-};
-const ENTRY_ClassLayout = {
-    packing_size: binary.UINT16_LE,
-    class_size: binary.UINT32_LE,
-    parent: new Indexed(TABLE.TypeDef),
-};
-const ENTRY_FieldLayout = {
-    offset: binary.UINT32_LE,
-    field: new Indexed(TABLE.Field),
-};
-const ENTRY_StandAloneSig = {
-    signature: Signature,
-};
-const ENTRY_EventMap = {
-    parent: new Indexed(TABLE.TypeDef),
-    event_list: new IndexedList(TABLE.Event),
-};
-const ENTRY_Event = {
-    flags: binary.UINT16_LE,
-    name: clr_String,
-    event_type: TypeDefOrRef,
-};
-const ENTRY_PropertyMap = {
-    parent: new Indexed(TABLE.TypeDef),
-    property_list: new IndexedList(TABLE.Property),
-};
-const ENTRY_Property = {
-    flags: binary.UINT16_LE,
-    name: clr_String,
-    type: Signature,
-};
-const ENTRY_MethodSemantics = {
-    flags: binary.UINT16_LE,
-    method: new Indexed(TABLE.MethodDef),
-    association: HasSemantics,
-};
-const ENTRY_MethodImpl = {
-    clss: new Indexed(TABLE.TypeDef),
-    method_body: MethodDefOrRef,
-    method_declaration: MethodDefOrRef,
-};
-const ENTRY_ModuleRef = {
-    name: clr_String,
-};
-const ENTRY_TypeSpec = {
-    signature: clr_Blob,
-};
-const ENTRY_ImplMap = {
-    flags: binary.UINT16_LE,
-    member_forwarded: MemberForwarded,
-    name: clr_String,
-    scope: new Indexed(TABLE.ModuleRef),
-};
-const ENTRY_FieldRVA = {
-    rva: binary.UINT32_LE,
-    field: new Indexed(TABLE.Field),
-};
-const ENTRY_Assembly = {
-    hashalg: binary.UINT32_LE,
-    major: binary.UINT16_LE,
-    minor: binary.UINT16_LE,
-    build: binary.UINT16_LE,
-    rev: binary.UINT16_LE,
-    flags: binary.UINT32_LE,
-    publickey: clr_Blob,
-    name: clr_String,
-    culture: clr_String,
-};
-const ENTRY_AssemblyProcessor = {
-    processor: binary.UINT32_LE,
-};
-const ENTRY_AssemblyOS = {
-    platform: binary.UINT32_LE,
-    minor: binary.UINT32_LE,
-    major: binary.UINT32_LE,
-};
-const ENTRY_AssemblyRef = {
-    major: binary.UINT16_LE,
-    minor: binary.UINT16_LE,
-    build: binary.UINT16_LE,
-    rev: binary.UINT16_LE,
-    flags: binary.UINT32_LE,
-    publickey: clr_Blob,
-    name: clr_String,
-    culture: clr_String,
-    hashvalue: clr_Blob,
-};
-const ENTRY_AssemblyRefProcessor = {
-    processor: binary.UINT32_LE,
-    assembly: new Indexed(TABLE.AssemblyRef),
-};
-const ENTRY_AssemblyRefOS = {
-    platform: binary.UINT32_LE,
-    major: binary.UINT32_LE,
-    minor: binary.UINT32_LE,
-    assembly: new Indexed(TABLE.AssemblyRef),
-};
-const ENTRY_File = {
-    flags: binary.UINT32_LE,
-    name: clr_String,
-    hash: clr_Blob,
-};
-const ENTRY_ExportedType = {
-    flags: binary.UINT32_LE,
-    typedef_id: binary.UINT32_LE, //(a 4-byte index into a TypeDef table of another module in this Assembly).
-    name: clr_String,
-    namespce: clr_String,
-    implementation: Implementation,
-};
-const ENTRY_ManifestResource = {
-    data: binary.UINT32_LE,
-    flags: binary.UINT32_LE,
-    name: clr_String,
-    implementation: Implementation,
-};
-const ENTRY_NestedClass = {
-    nested_class: new Indexed(TABLE.TypeDef),
-    enclosing_class: new Indexed(TABLE.TypeDef),
-};
-const ENTRY_GenericParam = {
-    number: binary.UINT16_LE,
-    flags: binary.UINT16_LE,
-    owner: TypeOrMethodDef,
-    name: clr_String,
-};
-const ENTRY_MethodSpec = {
-    method: MethodDefOrRef,
-    instantiation: Signature,
-};
-const ENTRY_GenericParamConstraint = {
-    owner: new Indexed(TABLE.GenericParam),
-    constraint: TypeDefOrRef,
-};
+const HasFieldMarshall = CodedIndex([TABLE.Field, TABLE.Param], 1);
+const HasDeclSecurity = CodedIndex([TABLE.TypeDef, TABLE.MethodDef, TABLE.Assembly], 2);
+const MemberRefParent = CodedIndex([TABLE.TypeDef, TABLE.TypeRef, TABLE.ModuleRef, TABLE.MethodDef, TABLE.TypeSpec], 1);
+const HasSemantics = CodedIndex([TABLE.Event, TABLE.Property], 1);
+const MethodDefOrRef = CodedIndex([TABLE.MethodDef, TABLE.MemberRef], 1);
+const MemberForwarded = CodedIndex([TABLE.Field, TABLE.MethodDef], 1);
+const Implementation = CodedIndex([TABLE.File, TABLE.AssemblyRef, TABLE.ExportedType], 2);
+const CustomAttributeType = CodedIndex([0, 0, TABLE.MethodDef, TABLE.MemberRef], 3);
+const TypeOrMethodDef = CodedIndex([TABLE.TypeDef, TABLE.MethodDef], 1);
+const ResolutionScope = CodedIndex([TABLE.Module, TABLE.ModuleRef, TABLE.AssemblyRef, TABLE.TypeRef], 2);
 const TableReaders = {
-    [TABLE.Module]: ENTRY_Module,
-    [TABLE.TypeRef]: ENTRY_TypeRef,
-    [TABLE.TypeDef]: ENTRY_TypeDef,
-    [TABLE.Field]: ENTRY_Field,
-    [TABLE.MethodDef]: ENTRY_MethodDef,
-    [TABLE.Param]: ENTRY_Param,
-    [TABLE.InterfaceImpl]: ENTRY_InterfaceImpl,
-    [TABLE.MemberRef]: ENTRY_MemberRef,
-    [TABLE.Constant]: ENTRY_Constant,
-    [TABLE.CustomAttribute]: ENTRY_CustomAttribute,
-    [TABLE.FieldMarshal]: ENTRY_FieldMarshal,
-    [TABLE.DeclSecurity]: ENTRY_DeclSecurity,
-    [TABLE.ClassLayout]: ENTRY_ClassLayout,
-    [TABLE.FieldLayout]: ENTRY_FieldLayout,
-    [TABLE.StandAloneSig]: ENTRY_StandAloneSig,
-    [TABLE.EventMap]: ENTRY_EventMap,
-    [TABLE.Event]: ENTRY_Event,
-    [TABLE.PropertyMap]: ENTRY_PropertyMap,
-    [TABLE.Property]: ENTRY_Property,
-    [TABLE.MethodSemantics]: ENTRY_MethodSemantics,
-    [TABLE.MethodImpl]: ENTRY_MethodImpl,
-    [TABLE.ModuleRef]: ENTRY_ModuleRef,
-    [TABLE.TypeSpec]: ENTRY_TypeSpec,
-    [TABLE.ImplMap]: ENTRY_ImplMap,
-    [TABLE.FieldRVA]: ENTRY_FieldRVA,
-    [TABLE.Assembly]: ENTRY_Assembly,
-    [TABLE.AssemblyProcessor]: ENTRY_AssemblyProcessor,
-    [TABLE.AssemblyOS]: ENTRY_AssemblyOS,
-    [TABLE.AssemblyRef]: ENTRY_AssemblyRef,
-    [TABLE.AssemblyRefProcessor]: ENTRY_AssemblyRefProcessor,
-    [TABLE.AssemblyRefOS]: ENTRY_AssemblyRefOS,
-    [TABLE.File]: ENTRY_File,
-    [TABLE.ExportedType]: ENTRY_ExportedType,
-    [TABLE.ManifestResource]: ENTRY_ManifestResource,
-    [TABLE.NestedClass]: ENTRY_NestedClass,
-    [TABLE.GenericParam]: ENTRY_GenericParam,
-    [TABLE.MethodSpec]: ENTRY_MethodSpec,
-    [TABLE.GenericParamConstraint]: ENTRY_GenericParamConstraint,
+    [TABLE.Module]: {
+        generation: binary.UINT16_LE,
+        name: clr_String,
+        mvid: clr_GUID,
+        encid: clr_GUID,
+        encbaseid: clr_GUID,
+    },
+    [TABLE.TypeRef]: {
+        scope: ResolutionScope,
+        name: clr_String,
+        namespce: clr_String,
+    },
+    [TABLE.TypeDef]: {
+        flags: binary.UINT32_LE,
+        name: clr_String,
+        namespce: clr_String,
+        extends: TypeDefOrRef,
+        fields: IndexedList(TABLE.Field),
+        methods: IndexedList(TABLE.MethodDef),
+    },
+    [TABLE.Field]: {
+        flags: binary.UINT16_LE,
+        name: clr_String,
+        signature: Signature,
+    },
+    [TABLE.MethodDef]: {
+        code: clr_Code,
+        implflags: binary.UINT16_LE,
+        flags: binary.UINT16_LE,
+        name: clr_String,
+        signature: Signature,
+        paramlist: IndexedList(TABLE.Param),
+    },
+    [TABLE.Param]: {
+        flags: binary.UINT16_LE,
+        sequence: binary.UINT16_LE,
+        name: clr_String,
+    },
+    [TABLE.InterfaceImpl]: {
+        clss: Indexed(TABLE.TypeDef),
+        interfce: TypeDefOrRef,
+    },
+    [TABLE.MemberRef]: {
+        clss: MemberRefParent,
+        name: clr_String,
+        signature: Signature,
+    },
+    [TABLE.Constant]: {
+        type: binary.UINT16_LE,
+        parent: HasConstant,
+        value: clr_Blob,
+    },
+    [TABLE.CustomAttribute]: {
+        parent: HasCustomAttribute,
+        type: CustomAttributeType,
+        value: CustomAttributeValue,
+    },
+    [TABLE.FieldMarshal]: {
+        parent: HasFieldMarshall,
+        native_type: clr_Blob,
+    },
+    [TABLE.DeclSecurity]: {
+        action: binary.UINT16_LE,
+        parent: HasDeclSecurity,
+        permission_set: clr_Blob,
+    },
+    [TABLE.ClassLayout]: {
+        packing_size: binary.UINT16_LE,
+        class_size: binary.UINT32_LE,
+        parent: Indexed(TABLE.TypeDef),
+    },
+    [TABLE.FieldLayout]: {
+        offset: binary.UINT32_LE,
+        field: Indexed(TABLE.Field),
+    },
+    [TABLE.StandAloneSig]: {
+        signature: Signature,
+    },
+    [TABLE.EventMap]: {
+        parent: Indexed(TABLE.TypeDef),
+        event_list: IndexedList(TABLE.Event),
+    },
+    [TABLE.Event]: {
+        flags: binary.UINT16_LE,
+        name: clr_String,
+        event_type: TypeDefOrRef,
+    },
+    [TABLE.PropertyMap]: {
+        parent: Indexed(TABLE.TypeDef),
+        property_list: IndexedList(TABLE.Property),
+    },
+    [TABLE.Property]: {
+        flags: binary.UINT16_LE,
+        name: clr_String,
+        type: Signature,
+    },
+    [TABLE.MethodSemantics]: {
+        flags: binary.UINT16_LE,
+        method: Indexed(TABLE.MethodDef),
+        association: HasSemantics,
+    },
+    [TABLE.MethodImpl]: {
+        clss: Indexed(TABLE.TypeDef),
+        method_body: MethodDefOrRef,
+        method_declaration: MethodDefOrRef,
+    },
+    [TABLE.ModuleRef]: {
+        name: clr_String,
+    },
+    [TABLE.TypeSpec]: {
+        signature: clr_Blob,
+    },
+    [TABLE.ImplMap]: {
+        flags: binary.UINT16_LE,
+        member_forwarded: MemberForwarded,
+        name: clr_String,
+        scope: Indexed(TABLE.ModuleRef),
+    },
+    [TABLE.FieldRVA]: {
+        rva: binary.UINT32_LE,
+        field: Indexed(TABLE.Field),
+    },
+    [TABLE.Assembly]: {
+        hashalg: binary.UINT32_LE,
+        major: binary.UINT16_LE,
+        minor: binary.UINT16_LE,
+        build: binary.UINT16_LE,
+        rev: binary.UINT16_LE,
+        flags: binary.UINT32_LE,
+        publickey: clr_Blob,
+        name: clr_String,
+        culture: clr_String,
+    },
+    [TABLE.AssemblyProcessor]: {
+        processor: binary.UINT32_LE,
+    },
+    [TABLE.AssemblyOS]: {
+        platform: binary.UINT32_LE,
+        minor: binary.UINT32_LE,
+        major: binary.UINT32_LE,
+    },
+    [TABLE.AssemblyRef]: {
+        major: binary.UINT16_LE,
+        minor: binary.UINT16_LE,
+        build: binary.UINT16_LE,
+        rev: binary.UINT16_LE,
+        flags: binary.UINT32_LE,
+        publickey: clr_Blob,
+        name: clr_String,
+        culture: clr_String,
+        hashvalue: clr_Blob,
+    },
+    [TABLE.AssemblyRefProcessor]: {
+        processor: binary.UINT32_LE,
+        assembly: Indexed(TABLE.AssemblyRef),
+    },
+    [TABLE.AssemblyRefOS]: {
+        platform: binary.UINT32_LE,
+        major: binary.UINT32_LE,
+        minor: binary.UINT32_LE,
+        assembly: Indexed(TABLE.AssemblyRef),
+    },
+    [TABLE.File]: {
+        flags: binary.UINT32_LE,
+        name: clr_String,
+        hash: clr_Blob,
+    },
+    [TABLE.ExportedType]: {
+        flags: binary.UINT32_LE,
+        typedef_id: binary.UINT32_LE, //(a 4-byte index into a TypeDef table of another module in this Assembly).
+        name: clr_String,
+        namespce: clr_String,
+        implementation: Implementation,
+    },
+    [TABLE.ManifestResource]: {
+        data: binary.UINT32_LE,
+        flags: binary.UINT32_LE,
+        name: clr_String,
+        implementation: Implementation,
+    },
+    [TABLE.NestedClass]: {
+        nested_class: Indexed(TABLE.TypeDef),
+        enclosing_class: Indexed(TABLE.TypeDef),
+    },
+    [TABLE.GenericParam]: {
+        number: binary.UINT16_LE,
+        flags: binary.UINT16_LE,
+        owner: TypeOrMethodDef,
+        name: clr_String,
+    },
+    [TABLE.MethodSpec]: {
+        method: MethodDefOrRef,
+        instantiation: Signature,
+    },
+    [TABLE.GenericParamConstraint]: {
+        owner: Indexed(TABLE.GenericParam),
+        constraint: TypeDefOrRef,
+    },
 };
 const ResourceManagerHeader = {
     magic: binary.UINT32_LE,
@@ -512,22 +470,12 @@ const ResourceEntry = {
     offset: binary.UINT32_LE,
 };
 class CLR {
+    raw;
     header;
     table_info;
     heaps = [];
     tables;
-    raw;
     Resources;
-    /*
-        static async load(dll: string) {
-            const p = await pe.PE.load(dll);
-            if (p) {
-                const clr_data = p.GetDataDir(p.opt.DataDirectory.CLR_DESCRIPTOR);
-                if (clr_data)
-                    return new CLR(p, clr_data);
-            }
-        }
-    */
     constructor(pe, clr_data) {
         this.header = binary.read(new binary.stream(clr_data), CLR_HEADER);
         const meta_data = pe.GetDataDir(this.header.MetaData);

package/dist/elf.d.ts

@@ -1,5 +1,6 @@
 import * as binary from '@isopodlabs/binary';
 export declare class ELFFile {
+    static check(data: Uint8Array): boolean;
     segments: [string, {
         data: binary.MappedMemory;
         p_type: string;
@@ -39,7 +40,6 @@ export declare class ELFFile {
         e_shnum: number;
         e_shstrndx: number;
     };
-    static check(data: Uint8Array): boolean;
     getDynamic: () => {
         d_tag: string;
         d_val: number | bigint;

package/dist/elf.js

@@ -47,7 +47,7 @@ const Ident = {
     file_class: binary.asEnum(binary.UINT8, CLASS),
     encoding: binary.asEnum(binary.UINT8, DATA),
     version: binary.UINT8,
-    _: binary.If(obj => obj.file_class === 'CLASS64', {
+    _: binary.If(s => s.obj.file_class === 'CLASS64', {
         //64 bit only
         osabi: binary.asEnum(binary.UINT8, OSABI),
         abiversion: binary.UINT8,
@@ -616,12 +616,12 @@ function readDataAs(data, type) {
         return binary.RemainingArrayType(type).get(new binary.stream(data.data));
 }
 class ELFFile {
-    segments;
-    sections;
-    header;
     static check(data) {
         return binary.utils.decodeText(data.subarray(0, 4), 'utf8') === '\x7fELF';
     }
+    segments;
+    sections;
+    header;
     getDynamic;
     getRel;
     getRelA;

package/dist/mach.d.ts

@@ -61,15 +61,19 @@ export declare enum CMD {
     DYLD_CHAINED_FIXUPS = 2147483700
 }
 export declare class MachFile {
-    header: any;
-    commands: {
-        cmd: CMD;
-        data: any;
-    }[];
-    ready: Promise<void>;
     static check(data: Uint8Array): boolean;
+    header: {
+        magic: number;
+        cputype: string;
+        cpusubtype: string | number;
+        filetype: string;
+        ncmds: number;
+        sizeofcmds: number;
+        flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+    };
+    private commands;
     constructor(data: Uint8Array, mem?: binary.memory);
-    load(data: Uint8Array, be: boolean, bits: 32 | 64, mem?: binary.memory): Promise<void>;
+    load(data: Uint8Array, be: boolean, bits: 64 | 32, mem?: binary.memory): void;
     getCommand(cmd: CMD.SEGMENT): {
         data: binary.MappedMemory | undefined;
         segname: string;

package/dist/mach.js

@@ -966,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:
@@ -980,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];
@@ -1008,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(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]));

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.5"
+  "version": "0.2.1"
 }