@isopodlabs/binary_libs 0.1.5 → 0.2.0

package/dist/clr.d copy.ts

@@ -0,0 +1,409 @@
+import * as binary from '@isopodlabs/binary';
+import * as pe from './pe';
+declare enum TABLE {
+    Module = 0,
+    TypeRef = 1,
+    TypeDef = 2,
+    Field = 4,
+    MethodDef = 6,
+    Param = 8,
+    InterfaceImpl = 9,
+    MemberRef = 10,
+    Constant = 11,
+    CustomAttribute = 12,
+    FieldMarshal = 13,
+    DeclSecurity = 14,
+    ClassLayout = 15,
+    FieldLayout = 16,
+    StandAloneSig = 17,
+    EventMap = 18,
+    Event = 20,
+    PropertyMap = 21,
+    Property = 23,
+    MethodSemantics = 24,
+    MethodImpl = 25,
+    ModuleRef = 26,
+    TypeSpec = 27,
+    ImplMap = 28,
+    FieldRVA = 29,
+    Assembly = 32,
+    AssemblyProcessor = 33,
+    AssemblyOS = 34,
+    AssemblyRef = 35,
+    AssemblyRefProcessor = 36,
+    AssemblyRefOS = 37,
+    File = 38,
+    ExportedType = 39,
+    ManifestResource = 40,
+    NestedClass = 41,
+    GenericParam = 42,
+    MethodSpec = 43,
+    GenericParamConstraint = 44
+}
+declare class clr_stream extends binary.stream {
+    heaps: Uint8Array[];
+    heap_sizes: number;
+    table_counts: number[];
+    constructor(buffer: Uint8Array, heaps: Uint8Array[], heap_sizes: number, table_counts: number[]);
+    getOffset(big: boolean): number;
+    getHeap(heap: number): Uint8Array;
+    getIndex(table: number): number;
+    getCodedIndex(B: number, trans: number[]): number;
+    getString(): string;
+    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;
+}
+declare const TableReaders: {
+    0: {
+        generation: binary.TypeT<number>;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        mvid: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        encid: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        encbaseid: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    1: {
+        scope: CodedIndex;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        namespce: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    2: {
+        flags: binary.TypeT<number>;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        namespce: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        extends: CodedIndex;
+        fields: IndexedList;
+        methods: IndexedList;
+    };
+    4: {
+        flags: binary.TypeT<number>;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        signature: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    6: {
+        code: binary.TypeT<number>;
+        implflags: binary.TypeT<number>;
+        flags: binary.TypeT<number>;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        signature: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+        paramlist: IndexedList;
+    };
+    8: {
+        flags: binary.TypeT<number>;
+        sequence: binary.TypeT<number>;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    9: {
+        clss: Indexed;
+        interfce: CodedIndex;
+    };
+    10: {
+        clss: CodedIndex;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        signature: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    11: {
+        type: binary.TypeT<number>;
+        parent: CodedIndex;
+        value: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    12: {
+        parent: CodedIndex;
+        type: CodedIndex;
+        value: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    13: {
+        parent: CodedIndex;
+        native_type: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    14: {
+        action: binary.TypeT<number>;
+        parent: CodedIndex;
+        permission_set: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    15: {
+        packing_size: binary.TypeT<number>;
+        class_size: binary.TypeT<number>;
+        parent: Indexed;
+    };
+    16: {
+        offset: binary.TypeT<number>;
+        field: Indexed;
+    };
+    17: {
+        signature: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    18: {
+        parent: Indexed;
+        event_list: IndexedList;
+    };
+    20: {
+        flags: binary.TypeT<number>;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        event_type: CodedIndex;
+    };
+    21: {
+        parent: Indexed;
+        property_list: IndexedList;
+    };
+    23: {
+        flags: binary.TypeT<number>;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        type: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    24: {
+        flags: binary.TypeT<number>;
+        method: Indexed;
+        association: CodedIndex;
+    };
+    25: {
+        clss: Indexed;
+        method_body: CodedIndex;
+        method_declaration: CodedIndex;
+    };
+    26: {
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    27: {
+        signature: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    28: {
+        flags: binary.TypeT<number>;
+        member_forwarded: CodedIndex;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        scope: Indexed;
+    };
+    29: {
+        rva: binary.TypeT<number>;
+        field: Indexed;
+    };
+    32: {
+        hashalg: binary.TypeT<number>;
+        major: binary.TypeT<number>;
+        minor: binary.TypeT<number>;
+        build: binary.TypeT<number>;
+        rev: binary.TypeT<number>;
+        flags: binary.TypeT<number>;
+        publickey: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        culture: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    33: {
+        processor: binary.TypeT<number>;
+    };
+    34: {
+        platform: binary.TypeT<number>;
+        minor: binary.TypeT<number>;
+        major: binary.TypeT<number>;
+    };
+    35: {
+        major: binary.TypeT<number>;
+        minor: binary.TypeT<number>;
+        build: binary.TypeT<number>;
+        rev: binary.TypeT<number>;
+        flags: binary.TypeT<number>;
+        publickey: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        culture: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        hashvalue: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    36: {
+        processor: binary.TypeT<number>;
+        assembly: Indexed;
+    };
+    37: {
+        platform: binary.TypeT<number>;
+        major: binary.TypeT<number>;
+        minor: binary.TypeT<number>;
+        assembly: Indexed;
+    };
+    38: {
+        flags: binary.TypeT<number>;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        hash: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    39: {
+        flags: binary.TypeT<number>;
+        typedef_id: binary.TypeT<number>;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        namespce: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        implementation: CodedIndex;
+    };
+    40: {
+        data: binary.TypeT<number>;
+        flags: binary.TypeT<number>;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+        implementation: CodedIndex;
+    };
+    41: {
+        nested_class: Indexed;
+        enclosing_class: Indexed;
+    };
+    42: {
+        number: binary.TypeT<number>;
+        flags: binary.TypeT<number>;
+        owner: CodedIndex;
+        name: {
+            get(s: clr_stream): string;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    43: {
+        method: CodedIndex;
+        instantiation: {
+            get(s: clr_stream): Uint8Array;
+            put(_s: clr_stream, _v: number): void;
+        };
+    };
+    44: {
+        owner: Indexed;
+        constraint: CodedIndex;
+    };
+};
+interface Table {
+    count: number;
+    size: number;
+    offset: number;
+}
+export declare class CLR {
+    header: any;
+    table_info: any;
+    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 extends TABLE>(t: T): binary.ReadType<typeof TableReaders[T]>[];
+    getResources(block: string): Record<string, any> | undefined;
+    getResource(block: string, name: string): any;
+    allResources(): {} | undefined;
+}
+export {};

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 {};