@isopodlabs/binary_libs 0.1.4 → 0.2.0

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

@@ -0,0 +1,95 @@
+import * as binary from '@isopodlabs/binary';
+declare class FAT {
+    shift: number;
+    sectors: Uint8Array;
+    fat: Int32Array;
+    freed: number[];
+    dirty_fat: Set<number>;
+    dirty_sec: Set<number>;
+    constructor(size: number, shift: number, sectors: Uint8Array);
+    private free;
+    private alloc;
+    get_chain(id: number): number[];
+    resize_chain(chain: number[], data_size: number): void;
+    clear_dirty(): void;
+    read_chain(chain: number[], dest: Uint8Array): void;
+    read_chain_alloc(chain: number[]): Uint8Array;
+    read(id: number, dest: Uint8Array): void;
+    write_chain(chain: number[], source: Uint8Array): void;
+    dirty_chain_part(chain: number[], offset: number): Uint8Array;
+}
+declare const Header_base: (new (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;
+} & {
+    write(w: binary._stream): void;
+}) & {
+    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 {
+    sector_size(): number;
+    use_mini(size: number): boolean;
+    valid(): boolean;
+}
+declare const DirEntry_base: (new (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;
+} & {
+    write(w: binary._stream): void;
+}) & {
+    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 {
+    index: number;
+    constructor(index: number, r: binary.stream);
+    load(fat: FAT): Uint8Array;
+}
+declare class Master {
+    header: Header;
+    difat: Int32Array;
+    fat: FAT;
+    mini_fat: FAT;
+    mini_chain: number[];
+    constructor(sectors: Uint8Array, header: Header);
+    get_fat(mini: boolean): FAT;
+    flush(filename: string): Promise<void>;
+}
+export declare class Reader extends Master {
+    entries: DirEntry[];
+    private entry_chain;
+    constructor(sectors: Uint8Array, header: Header);
+    find(name: string, i?: number): DirEntry | undefined;
+    read(e: DirEntry): Uint8Array;
+    write(e: DirEntry, data: Uint8Array): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import * as binary from '@isopodlabs/binary';
+declare const _HEADER: {
+    name: binary.TypeT<string>;
+    date: binary.TypeT<number>;
+    uid: binary.TypeT<number>;
+    gid: binary.TypeT<number>;
+    mode: binary.TypeT<number>;
+    size: binary.TypeT<number>;
+    fmag: binary.TypeT<string>;
+    contents: binary.TypeT<any>;
+};
+export type HEADER = binary.ReadType<typeof _HEADER>;
+export declare class ArchFile {
+    members: HEADER[];
+    static check(data: Uint8Array): boolean;
+    constructor(data: Uint8Array);
+}
+export {};

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));