@isopodlabs/binary_libs 0.0.1 → 0.1.0

package/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "node_modules/@isopodlabs/binary"]
+	path = node_modules/@isopodlabs/binary
+	url = https://github.com/adrianstephens/binary.git

package/.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        
+        {
+            "type": "node-terminal",
+            "name": "Run Script: build",
+            "request": "launch",
+            "command": "npm run build",
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "eslint.lintTask.enable": false
+}

package/README.md

@@ -1,60 +1,168 @@
-# my-binary-package/my-binary-package/README.md
+# Binary Libs
 
-# My Binary Package
+This package provides readers for various library formats, using the @isopodlabs/binary binary file loading library
 
-This package provides a set of utilities for reading and writing binary data in TypeScript. It includes various interfaces, types, and functions to facilitate binary data manipulation.
 
-## Installation
+## Supported File Types
 
-To install the package, use npm:
+### elf
+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][];
+}
 
 ```
-npm install my-binary-package
-```
-
-## Usage
-
-Here is a basic example of how to use the package:
 
+### pe
+Portable Executable
 ```typescript
-import { stream, ReadStruct, WriteStruct } from 'my-binary-package';
-
-// Create a new stream from a Uint8Array
-const data = new Uint8Array([/* binary data */]);
-const binaryStream = new stream(data);
-
-// Define a structure to read from the stream
-const MyStruct = ReadStruct({
-    // Define your structure here
-});
-
-// Read data from the stream
-const myData = new MyStruct(binaryStream);
-
-// Write data back to the stream
-const writeStream = new stream(new Uint8Array(1024));
-const myWriteStruct = WriteStruct({
-    // Define your structure here
-});
-myWriteStruct.put(writeStream, myData);
+class PE {
+    static check(data: Uint8Array): boolean;
+    constructor(data: Uint8Array);
+    get directories(): {
+        [k: string]: any;
+    } | undefined;
+    FindSectionRVA(rva: number): Section | undefined;
+    FindSectionRaw(addr: number): Section | undefined;
+    GetDataRVA(rva: number, size?: number): binary.utils.MappedMemory | undefined;
+    GetDataRaw(addr: number, size: number): Uint8Array | undefined;
+    GetDataDir(dir: { VirtualAddress: number; Size: number; } & {}): binary.utils.MappedMemory | undefined;
+    ReadDirectory(name: string): any;
+}
 ```
 
-## Key Features
-
-- **Interfaces**: 
-  - `_stream`: Base interface for stream handling.
-  - `TypeReaderT`, `TypeWriterT`, `TypeT`: Types for reading and writing binary data.
-  - `ReadType`: Type for reading structured data.
-
-- **Functions**:
-  - `ReadStruct`: Create a reader for a specific structure.
-  - `WriteStruct`: Create a writer for a specific structure.
-  - `read`, `write`: Functions for reading and writing binary data.
+### clr
+Common Language Runtime (embedded in pe files)
+```typescript
+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: 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; } & {})[];
+    getResources(block: string): Record<string, any> | undefined;
+    getResource(block: string, name: string): any;
+    allResources(): {} | undefined;
+}
+```
+### 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;
+    } & {}>;
+};
+export declare class MachFile {
+    header: any;
+    commands: { cmd: CMD; data: any; }[];
+    ready: Promise<void>;
+    static check(data: Uint8Array): boolean;
+    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;
+}
+class FATMachFile {
+    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;
+}
+```
 
-## Contributing
+### arch
+Archive files for static linking
 
-Contributions are welcome! Please open an issue or submit a pull request for any enhancements or bug fixes.
+```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;
+    constructor(data: Uint8Array);
+}
+```
 
+### CompoundDocument
+Not a library format at all, but useful for loading some related files
+```typescript
+class Reader {
+    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;
+}
+```
 ## License
 
 This project is licensed under the MIT License. See the LICENSE file for more details.

package/eslint.config.mjs

@@ -0,0 +1,32 @@
+// @ts-check
+import eslint from "@eslint/js";
+import tslint from "typescript-eslint";
+
+export default tslint.config(
+    eslint.configs.recommended,
+    ...tslint.configs.recommended,
+    ...tslint.configs.stylistic,
+    {
+        rules: {
+            "semi": ["error", "always"], // Add this line to enforce semicolon use
+            "no-empty": "off",
+            //"@typescript-eslint/no-misleading-character-class": "off",
+            //"@typescript-eslint/no-this-alias": "off",
+            "@typescript-eslint/no-unused-vars":  [
+                "warn", {
+                    argsIgnorePattern: "^(_+$|_[^_])",
+                    varsIgnorePattern: "^(_+$|_[^_])",
+                },
+            ],
+            "@typescript-eslint/no-explicit-any": "off",
+            //"@typescript-eslint/explicit-module-boundary-types": "off",
+            //"@typescript-eslint/no-non-null-assertion": "off"
+	        "@typescript-eslint/no-empty-function": "off",
+            "@typescript-eslint/consistent-indexed-object-style": "off",
+            "@typescript-eslint/consistent-type-definitions": "off"
+        },
+    },
+    {
+        files: ["src/*.ts"],
+    }
+);

package/package.json

@@ -11,7 +11,9 @@
   },
   "scripts": {
     "build": "tsc",
-    "test": "echo \"No tests specified\" && exit 0"
+    "lint": "eslint \"src/**/*.ts\"",
+    "test": "echo \"No tests specified\" && exit 0",
+    "postinstall": "ts-patch install"
   },
   "keywords": [
     "binary",
@@ -24,10 +26,16 @@
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^22.13.8",
-    "typescript": "^4.0.0"
+    "@typescript-eslint/eslint-plugin": "^8.26.0",
+    "@typescript-eslint/parser": "^8.26.0",
+    "eslint": "^9.21.0",
+    "ts-node": "^10.9.2",
+    "ts-patch": "^3.3.0",
+    "typescript": "~5.5.0",
+    "typescript-eslint": "^8.26.0"
   },
   "dependencies": {
     "@isopodlabs/binary": "^1.0.3"
   },
-  "version": "0.0.1"
+  "version": "0.1.0"
 }

package/src/CompoundDocument.ts

@@ -14,7 +14,7 @@ class FAT {
 	dirty_fat	= new Set<number>();
 	dirty_sec	= new Set<number>();
 
-	constructor(size: number, public shift:number, public sectors: Uint8Array) {
+	constructor(size: number, public shift: number, public sectors: Uint8Array) {
 		this.fat = new Int32Array(size);
 	}
 
@@ -99,7 +99,7 @@ class FAT {
 
 }
 
-export class Header extends binary.ReadWriteStruct({
+export class Header extends binary.Class({
 	magic:			binary.UINT64_BE,
 	id:				binary.Buffer(16),
 	revision:		binary.UINT16_LE,
@@ -137,7 +137,7 @@ const COLOUR = {
 	RED: 0, BLACK: 1
 } as const;
 
-class DirEntry  extends binary.ReadWriteStruct({
+class DirEntry  extends binary.Class({
 	name:			binary.StringType(64, 'utf16le'),
 	name_size:		binary.UINT16_LE,
 	type:			binary.UINT8,
@@ -164,7 +164,7 @@ class DirEntry  extends binary.ReadWriteStruct({
 	}
 }
 
-export class Master {
+class Master {
 	difat: 			Int32Array;
 	fat: 			FAT;
 	mini_fat: 		FAT;
@@ -259,7 +259,7 @@ export class Reader extends Master {
 			this.entries[i] = new DirEntry(i, r2.seek(i * 128));
 	}
 
-	find(name: string, i: number = 0): DirEntry|undefined {
+	find(name: string, i = 0): DirEntry|undefined {
 		const stack: number[] = [];
 		let		sp = 0;
 

package/src/arch.ts

@@ -1,7 +1,10 @@
 import * as binary from '@isopodlabs/binary';
 
-const AR_MEMBER_HEADER = {
-	name:     	binary.as(binary.StringType(16),	x => { x = x.trim(); return  x.endsWith('/') ?  x.slice(0, -1) : x; }),
+const _HEADER = {
+	name:     	binary.as(binary.StringType(16),	x => {
+		x = x.trim();
+		return x.endsWith('/') ?  x.slice(0, -1) : x;
+	}),
 	date:     	binary.asInt(binary.StringType(12)),
 	uid:      	binary.asInt(binary.StringType(6)),
 	gid:      	binary.asInt(binary.StringType(6)),
@@ -11,17 +14,18 @@ const AR_MEMBER_HEADER = {
 	contents: 	binary.DontRead<any>()
 };
 
-const AR_SYM64 = {
+export type HEADER = binary.ReadType<typeof _HEADER>;
+
+const SYM64 = {
 	name:     	binary.StringType(12),
 	offset:   	binary.asInt(binary.StringType(4))
 };
 
 export class ArchFile {
-	members: binary.ReadType<typeof AR_MEMBER_HEADER>[] = [];
+	members: HEADER[] = [];
 
 	static check(data: Uint8Array): boolean {
-		const x = binary.utils.decodeText(data.subarray(0, 8), 'utf8');
-		return x == '!<arch>\n';
+		return binary.utils.decodeText(data.subarray(0, 8), 'utf8') == '!<arch>\n';
 	}
 	constructor(data: Uint8Array) {
 		const s = new binary.stream(data);
@@ -32,7 +36,7 @@ export class ArchFile {
 
 		let long_names;
 		while (s.remaining() > 0) {
-			const member = binary.read(s, AR_MEMBER_HEADER);
+			const member = binary.read(s, _HEADER);
 			const data = s.read_buffer(member.size);
 			s.align(2);
 
@@ -46,8 +50,8 @@ export class ArchFile {
 			}
 
 			if (member.name == '') {
-				const s2 = new binary.stream(data);
-				const offsets = binary.ArrayType(binary.INT32_BE, binary.INT32_BE).get(s2);
+				const s2		= new binary.stream(data);
+				const offsets	= binary.ArrayType(binary.INT32_BE, binary.INT32_BE).get(s2);
 				member.name = 'Symbols';
 				member.contents = offsets.map(offset => [
 					binary.NullTerminatedStringType.get(s2),
@@ -55,9 +59,8 @@ export class ArchFile {
 				]);
 
 			} else if (member.name == '/SYM') {
-				const s2 = new binary.stream(data);
-				const syms = binary.ArrayType(binary.INT32_BE, binary.NullTerminatedStringType).get(s2);
-
+				const s2	= new binary.stream(data);
+				const syms	= binary.ArrayType(binary.INT32_BE, binary.NullTerminatedStringType).get(s2);
 				member.contents = syms.map(name => ({
 					name,
 					offset: binary.INT32_BE.get(s2)
@@ -65,7 +68,7 @@ export class ArchFile {
 
 			} else if (member.name == '/SYM64') {
 				const s2 = new binary.stream(data);
-				member.contents = binary.RemainingArrayType(AR_SYM64).get(s2);
+				member.contents = binary.RemainingArrayType(SYM64).get(s2);
 	
 			} else {
 				member.contents = data;

package/src/clr.ts

@@ -26,7 +26,7 @@ const CLR_HEADER = {
 	MajorRuntimeVersion:		binary.UINT16_LE,
 	MinorRuntimeVersion:		binary.UINT16_LE,
 	MetaData:					pe.DATA_DIRECTORY,
-	Flags:						binary.UINT32_LE,
+	Flags:						binary.asFlags(binary.UINT32_LE, CLR_FLAGS),
 	EntryPoint:					binary.UINT32_LE,
 	Resources:					pe.DATA_DIRECTORY,
 	StrongNameSignature:		pe.DATA_DIRECTORY,
@@ -185,16 +185,16 @@ class clr_dummy extends binary.dummy {
 }
 
 const clr_String = {
-	get(s: clr_stream) 				{ return s.getString(); },
-	put(s: clr_stream, v : number)	{}
+	get(s: clr_stream) 					{ return s.getString(); },
+	put(_s: clr_stream, _v : number)	{}
 };
 const clr_GUID = {
-	get(s: clr_stream) 				{ return s.getGUID(); },
-	put(s: clr_stream, v : number)	{}
+	get(s: clr_stream) 					{ return s.getGUID(); },
+	put(_s: clr_stream, _v : number)	{}
 };
 const clr_Blob = {
-	get(s: clr_stream) 				{ return s.getBlob(); },
-	put(s: clr_stream, v : number)	{}
+	get(s: clr_stream) 					{ return s.getBlob(); },
+	put(_s: clr_stream, _v : number)	{}
 };
 const Signature 			= clr_Blob;
 const CustomAttributeValue	= clr_Blob;
@@ -429,7 +429,7 @@ const ENTRY_GenericParamConstraint = {
 	constraint:		TypeDefOrRef,
 };
 
-const TableReaders : Record<TABLE, any> = {
+const TableReaders = {
 	[TABLE.Module]:					ENTRY_Module,
 	[TABLE.TypeRef]:				ENTRY_TypeRef,
 	[TABLE.TypeDef]:				ENTRY_TypeDef,
@@ -476,14 +476,12 @@ const ResourceManagerHeader = {
 	skip:		binary.UINT32_LE,
 };
 
-const pascal_string = binary.StringType(binary.UINT8);
-
 const ResourceManager = {
-	reader: 		pascal_string,// Class name of IResourceReader to parse this file
-	set:			pascal_string,// Class name of ResourceSet to parse this file
+	reader: 		binary.StringType(binary.UINT8),// Class name of IResourceReader to parse this file
+	set:			binary.StringType(binary.UINT8),// Class name of ResourceSet to parse this file
 	version:		binary.UINT32_LE,
 	num_resources:	binary.UINT32_LE,
-	types: 			binary.ArrayType(binary.UINT32_LE, pascal_string),
+	types: 			binary.ArrayType(binary.UINT32_LE, binary.StringType(binary.UINT8)),
 };
 
 const ResourceEntry = {
@@ -497,7 +495,7 @@ export class CLR {
 	header:		any;
 	table_info:	any;
 	heaps:		Uint8Array[] = [];
-	tables:		{[K in TABLE]?: Table} = {};
+	tables!:	Record<TABLE, Table>;
 	raw?:		Uint8Array;
 	Resources?:	Uint8Array;
 /*
@@ -511,56 +509,50 @@ export class CLR {
 	}
 */
 	constructor(pe: pe.PE, clr_data: Uint8Array) {
-		try {
-			this.header	= binary.read(new binary.stream(clr_data), CLR_HEADER);
-			const	meta_data	= pe.GetDataDir(this.header.MetaData);
-			const	meta_root	= meta_data && binary.read(new binary.stream(meta_data.data), METADATA_ROOT);
-
-			if (meta_root?.Signature != binary.utils.stringCode('BSJB'))
-				console.log("oops");
-
-			let 	table_data;
-	
-			for (const h of meta_root!.Streams) {
-				const	mem = meta_data!.data.subarray(h.Offset, h.Offset + h.Size);
-				switch (h.Name) {
-					case "#~":			table_data					= mem; break;
-					case "#Strings":	this.heaps[HEAP.String]		= mem; break;
-					case "#US":			this.heaps[HEAP.UserString]	= mem; break;
-					case "#GUID":		this.heaps[HEAP.GUID]		= mem; break;
-					case "#Blob":		this.heaps[HEAP.Blob]		= mem; break;
-				}
+		this.header		= binary.read(new binary.stream(clr_data), CLR_HEADER);
+		const meta_data	= pe.GetDataDir(this.header.MetaData);
+		const meta_root	= meta_data && binary.read(new binary.stream(meta_data.data), METADATA_ROOT);
+
+		if (meta_root?.Signature != binary.utils.stringCode('BSJB'))
+			throw new Error("Invalid CLR");
+
+		let 	table_data;
+
+		for (const h of meta_root!.Streams) {
+			const	mem = meta_data!.data.subarray(h.Offset, h.Offset + h.Size);
+			switch (h.Name) {
+				case "#~":			table_data					= mem; break;
+				case "#Strings":	this.heaps[HEAP.String]		= mem; break;
+				case "#US":			this.heaps[HEAP.UserString]	= mem; break;
+				case "#GUID":		this.heaps[HEAP.GUID]		= mem; break;
+				case "#Blob":		this.heaps[HEAP.Blob]		= mem; break;
 			}
+		}
 
-			if (table_data) {
-				const stream	= new binary.stream(table_data);
-				this.table_info	= binary.read(stream, CLR_TABLES);
-				const table_counts: number[] = [];
+		if (table_data) {
+			const stream	= new binary.stream(table_data);
+			this.table_info	= binary.read(stream, CLR_TABLES);
+			const table_counts: number[] = [];
 
-				//read counts
-				for (let b = this.table_info.Valid; b; b = binary.utils.clearLowest(b)) {
-					const i = binary.utils.lowestSetIndex(b);
-					table_counts[i] = binary.UINT32_LE.get(stream);
-				}
+			//read counts
+			for (let b = this.table_info.Valid; b; b = binary.utils.clearLowest(b)) {
+				const i = binary.utils.lowestSetIndex(b);
+				table_counts[i] = binary.UINT32_LE.get(stream);
+			}
 
-				this.raw 		= stream.remainder();
-				//const stream2 = new clr_stream(stream.remainder(), this.heaps, table_info.HeapSizes, this.tables.map(i => i.count));
-				const stream1 	= new clr_dummy(this.table_info.HeapSizes, table_counts);
-				let offset 		= 0;
-
-				for (let b = this.table_info.Valid; b; b = binary.utils.clearLowest(b)) {
-					const i = binary.utils.lowestSetIndex(b) as TABLE;
-					stream1.seek(0);
-					binary.read(stream1, TableReaders[i]);
-					this.tables[i] = {offset, count: table_counts[i], size: stream1.tell()};
-					offset	+= this.tables[i]!.size * this.tables[i]!.count;
-				}
+			this.raw 		= stream.remainder();
+			const stream1 	= new clr_dummy(this.table_info.HeapSizes, table_counts);
+			let offset 		= 0;
 
-				this.Resources = pe.GetDataDir(this.header.Resources)?.data;
+			for (let b = this.table_info.Valid; b; b = binary.utils.clearLowest(b)) {
+				const i = binary.utils.lowestSetIndex(b) as TABLE;
+				stream1.seek(0);
+				binary.read(stream1, TableReaders[i]);
+				this.tables[i] = {offset, count: table_counts[i], size: stream1.tell()};
+				offset	+= this.tables[i]!.size * this.tables[i]!.count;
 			}
 
-		} catch (e) {
-			console.log(e);
+			this.Resources = pe.GetDataDir(this.header.Resources)?.data;
 		}
 	}
 
@@ -573,6 +565,7 @@ export class CLR {
 		}
 	}
 
+	getTable<T extends TABLE> (t: T): binary.ReadType<typeof TableReaders[T]>[];
 	getTable(t: TABLE) {
 		const table = this.tables[t];
 		if (table) {
@@ -639,7 +632,9 @@ function getResources(data: Uint8Array) {
 	}
 }
 
-pe.DIRECTORIES.CLR_DESCRIPTOR.read = (pe: pe.PE, data: binary.utils.MappedMemory) => {
+// hook into PE reader
+
+pe.DIRECTORIES.CLR_DESCRIPTOR.read = (pe: pe.PE, data: binary.MappedMemory) => {
 	function fix_names(table: any[]) {
 		if ('name' in table[0])
 			return Object.fromEntries(table.map(i => [i.name, i]));