@isopodlabs/binary_libs 0.1.5 → 0.2.0

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 copy.ts

@@ -0,0 +1,152 @@
+import * as binary from '@isopodlabs/binary';
+declare const PT: {
+    readonly NULL: 0;
+    readonly LOAD: 1;
+    readonly DYNAMIC: 2;
+    readonly INTERP: 3;
+    readonly NOTE: 4;
+    readonly SHLIB: 5;
+    readonly PHDR: 6;
+    readonly TLS: 7;
+    readonly LOOS: 1610612736;
+    readonly UNWIND: 1684333904;
+    readonly EH_FRAME: 1685382480;
+    readonly GNU_STACK: 1685382481;
+    readonly GNU_RELRO: 1685382482;
+    readonly OS_SCE: 1879047936;
+    readonly HIOS: 1879048191;
+    readonly LOPROC: 1879048192;
+    readonly HIPROC: 2147483647;
+};
+declare const SHT: {
+    readonly NULL: 0;
+    readonly PROGBITS: 1;
+    readonly SYMTAB: 2;
+    readonly STRTAB: 3;
+    readonly RELA: 4;
+    readonly HASH: 5;
+    readonly DYNAMIC: 6;
+    readonly NOTE: 7;
+    readonly NOBITS: 8;
+    readonly REL: 9;
+    readonly SHLIB: 10;
+    readonly DYNSYM: 11;
+    readonly LOOS: 1610612736;
+    readonly HIOS: 1879048191;
+    readonly LOPROC: 1879048192;
+    readonly HIPROC: 2147483647;
+    readonly LOUSER: 2147483648;
+    readonly HIUSER: 4294967295;
+    readonly PS3_RELA: number;
+};
+export declare class ELFFile {
+    static check(data: Uint8Array): boolean;
+    segments: [string, {
+        data: binary.MappedMemory;
+        p_type: string;
+        p_flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+        p_offset: number | bigint;
+        p_vaddr: binary.hex<number | bigint>;
+        p_paddr: binary.hex<number | bigint>;
+        p_filesz: number | bigint;
+        p_memsz: number | bigint;
+        p_align: number | bigint;
+    }][];
+    sections: [string, {
+        data: binary.MappedMemory;
+        sh_name: number;
+        sh_type: string;
+        sh_flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+        sh_addr: binary.hex<number | bigint>;
+        sh_offset: number | bigint;
+        sh_size: number | bigint;
+        sh_link: number;
+        sh_info: number;
+        sh_addralign: number | bigint;
+        sh_entsize: number | bigint;
+    }][];
+    header: {
+        e_type: string;
+        e_machine: string;
+        e_version: string;
+        e_entry: binary.hex<number | bigint>;
+        e_phoff: number | bigint;
+        e_shoff: number | bigint;
+        e_flags: number;
+        e_ehsize: number;
+        e_phentsize: number;
+        e_phnum: number;
+        e_shentsize: number;
+        e_shnum: number;
+        e_shstrndx: number;
+    };
+    getDynamic: () => {
+        d_tag: string;
+        d_val: number | bigint;
+    }[] | undefined;
+    getRel: () => {
+        r_offset: binary.hex<number | bigint>;
+        r_info: never;
+    }[] | undefined;
+    getRelA: () => {
+        r_addend: number | bigint;
+        r_offset: binary.hex<number | bigint>;
+        r_info: never;
+    }[] | undefined;
+    getSymbols: () => [string, {
+        st_info: {
+            type: string;
+            binding: string;
+        };
+        st_other: {
+            visibility: string;
+            other: number | bigint;
+        };
+        st_shndx: string;
+        st_value: binary.hex<number | bigint>;
+        st_size: number | bigint;
+        data: binary.MappedMemory | undefined;
+        st_name: number;
+    }][] | undefined;
+    getDynamicSymbols: () => [string, {
+        st_info: {
+            type: string;
+            binding: string;
+        };
+        st_other: {
+            visibility: string;
+            other: number | bigint;
+        };
+        st_shndx: string;
+        st_value: binary.hex<number | bigint>;
+        st_size: number | bigint;
+        data: binary.MappedMemory | undefined;
+        st_name: number;
+    }][] | undefined;
+    constructor(data: Uint8Array);
+    getSegmentByType(type: keyof typeof PT): {
+        data: binary.MappedMemory;
+        p_type: string;
+        p_flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+        p_offset: number | bigint;
+        p_vaddr: binary.hex<number | bigint>;
+        p_paddr: binary.hex<number | bigint>;
+        p_filesz: number | bigint;
+        p_memsz: number | bigint;
+        p_align: number | bigint;
+    } | undefined;
+    getSectionByType(type: keyof typeof SHT): {
+        data: binary.MappedMemory;
+        sh_name: number;
+        sh_type: string;
+        sh_flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+        sh_addr: binary.hex<number | bigint>;
+        sh_offset: number | bigint;
+        sh_size: number | bigint;
+        sh_link: number;
+        sh_info: number;
+        sh_addralign: number | bigint;
+        sh_entsize: number | bigint;
+    } | undefined;
+}
+export {};

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;