@isopodlabs/binary_libs 0.0.1 → 0.1.1

package/src/pe.ts

@@ -1,4 +1,5 @@
 import * as binary from '@isopodlabs/binary';
+import * as path from 'path';
 
 class MyDate extends Date {
 	constructor(x: number) { super(x * 1000); }
@@ -6,35 +7,38 @@ class MyDate extends Date {
 	toString()	{ return super.toString(); }
 }
 
-const TIMEDATE = binary.as(binary.UINT32_LE, MyDate);
+const uint16	= binary.UINT16_LE;
+const uint32	= binary.UINT32_LE;
+const uint64	= binary.UINT64_LE;
 
+const TIMEDATE = binary.as(uint32, MyDate);
 
 //-----------------------------------------------------------------------------
 //	COFF
 //-----------------------------------------------------------------------------
 
 const DOS_HEADER = {
-	magic:		binary.UINT16_LE,
-	cblp:		binary.UINT16_LE,
-	cp:			binary.UINT16_LE,
-	crlc:		binary.UINT16_LE,
-	cparhdr:	binary.UINT16_LE,
-	minalloc:	binary.UINT16_LE,
-	maxalloc:	binary.XINT16_LE,
-	ss:			binary.UINT16_LE,
-	sp:			binary.UINT16_LE,
-	csum:		binary.UINT16_LE,
-	ip:			binary.UINT16_LE,
-	cs:			binary.UINT16_LE,
-	lfarlc:		binary.UINT16_LE,
-	ovno:		binary.UINT16_LE,
+	magic:		uint16,
+	cblp:		uint16,
+	cp:			uint16,
+	crlc:		uint16,
+	cparhdr:	uint16,
+	minalloc:	uint16,
+	maxalloc:	binary.asHex(uint16),
+	ss:			uint16,
+	sp:			uint16,
+	csum:		uint16,
+	ip:			uint16,
+	cs:			uint16,
+	lfarlc:		uint16,
+	ovno:		uint16,
 };
 
 const EXE_HEADER = {
-	res:		binary.ArrayType(4, binary.UINT16_LE),
-	oemid:		binary.UINT16_LE,
-	oeminfo:	binary.UINT16_LE,
-	res2:		binary.ArrayType(10, binary.UINT16_LE),
+	res:		binary.ArrayType(4, uint16),
+	oemid:		uint16,
+	oeminfo:	uint16,
+	res2:		binary.ArrayType(10, uint16),
 	lfanew:		binary.INT32_LE,
 };
 
@@ -46,112 +50,112 @@ export class pe_stream extends binary.stream {
 	constructor(public pe: PE, data: Uint8Array) {
 		super(data);
 	}
-	get_rva()	{ return this.pe.GetDataRVA(binary.UINT32_LE.get(this))?.data; }
+	get_rva()	{ return this.pe.GetDataRVA(uint32.get(this))?.data; }
 }
 
 const RVA_STRING = {
 	get(s: pe_stream)	{ return binary.utils.decodeTextTo0(s.get_rva(), 'utf8'); },
-	put(s: pe_stream)	{}
+	put(_s: pe_stream)	{}
 };
 const RVA_ARRAY16 = {
 	get(s: pe_stream)	{ return binary.utils.to16(s.get_rva()); },
-	put(s: pe_stream)	{}
+	put(_s: pe_stream)	{}
 };
 const RVA_ARRAY32 = {
 	get(s: pe_stream)	{ return binary.utils.to32(s.get_rva()); },
-	put(s: pe_stream)	{}
+	put(_s: pe_stream)	{}
 };
 const RVA_ARRAY64 = {
 	get(s: pe_stream)	{ return binary.utils.to64(s.get_rva()); },
-	put(s: pe_stream)	{}
+	put(_s: pe_stream)	{}
 };
 
 const FILE_HEADER = {
-	Machine:				binary.UINT16_LE,
-	NumberOfSections:		binary.UINT16_LE,
-	TimeDateStamp:			binary.UINT32_LE,
-	PointerToSymbolTable:	binary.UINT32_LE,
-	NumberOfSymbols:		binary.UINT32_LE,
-	SizeOfOptionalHeader:	binary.UINT16_LE,
-	Characteristics:		binary.UINT16_LE,
+	Machine:				uint16,
+	NumberOfSections:		uint16,
+	TimeDateStamp:			uint32,
+	PointerToSymbolTable:	uint32,
+	NumberOfSymbols:		uint32,
+	SizeOfOptionalHeader:	uint16,
+	Characteristics:		uint16,
 };
 
-enum SECTION_CHARACTERISTICS {
-//							= 0x00000000,
-//							= 0x00000001,
-//							= 0x00000002,
-//							= 0x00000004,
-	TYPE_NO_PAD				= 0x00000008,
-//							= 0x00000010,
-	CNT_CODE				= 0x00000020,
-	CNT_INITIALIZED_DATA	= 0x00000040,
-	CNT_UNINITIALIZED_DATA	= 0x00000080,
-	LNK_OTHER				= 0x00000100,
-	LNK_INFO				= 0x00000200,
-//							= 0x00000400,
-	LNK_REMOVE				= 0x00000800,
-	LNK_COMDAT				= 0x00001000,
-	GPREL					= 0x00008000,
-//	MEM_PURGEABLE			= 0x00020000,
-	MEM_16BIT				= 0x00020000,
-	MEM_LOCKED				= 0x00040000,
-	MEM_PRELOAD				= 0x00080000,
-	ALIGN					= 0x00f00000,
-	//ALIGN_1BYTES			= 0x00100000,
-	//ALIGN_2BYTES			= 0x00200000,
-	//ALIGN_4BYTES			= 0x00300000,
-	//ALIGN_8BYTES			= 0x00400000,
-	//ALIGN_16BYTES			= 0x00500000,
-	//ALIGN_32BYTES			= 0x00600000,
-	//ALIGN_64BYTES			= 0x00700000,
-	//ALIGN_128BYTES			= 0x00800000,
-	//ALIGN_256BYTES			= 0x00900000,
-	//ALIGN_512BYTES			= 0x00A00000,
-	//ALIGN_1024BYTES			= 0x00B00000,
-	//ALIGN_2048BYTES			= 0x00C00000,
-	//ALIGN_4096BYTES			= 0x00D00000,
-	//ALIGN_8192BYTES			= 0x00E00000,
-	LNK_NRELOC_OVFL			= 0x01000000,
-	MEM_DISCARDABLE			= 0x02000000,
-	MEM_NOT_CACHED			= 0x04000000,
-	MEM_NOT_PAGED			= 0x08000000,
-	MEM_SHARED				= 0x10000000,
-	MEM_EXECUTE				= 0x20000000,
-	MEM_READ				= 0x40000000,
-	MEM_WRITE				= 0x80000000,
-}
-
-class Section extends binary.ReadStruct({
+const SECTION_CHARACTERISTICS = {
+//							0x00000000,
+//							0x00000001,
+//							0x00000002,
+//							0x00000004,
+	TYPE_NO_PAD:			0x00000008,
+//							0x00000010,
+	CNT_CODE:				0x00000020,
+	CNT_INITIALIZED_DATA:	0x00000040,
+	CNT_UNINITIALIZED_DATA:	0x00000080,
+	LNK_OTHER:				0x00000100,
+	LNK_INFO:				0x00000200,
+//							0x00000400,
+	LNK_REMOVE:				0x00000800,
+	LNK_COMDAT:				0x00001000,
+	GPREL:					0x00008000,
+//	MEM_PURGEABLE			0x00020000,
+	MEM_16BIT:				0x00020000,
+	MEM_LOCKED:				0x00040000,
+	MEM_PRELOAD:			0x00080000,
+	ALIGN:					0x00f00000,
+	//ALIGN_1BYTES			0x00100000,
+	//ALIGN_2BYTES			0x00200000,
+	//ALIGN_4BYTES			0x00300000,
+	//ALIGN_8BYTES			0x00400000,
+	//ALIGN_16BYTES			0x00500000,
+	//ALIGN_32BYTES			0x00600000,
+	//ALIGN_64BYTES			0x00700000,
+	//ALIGN_128BYTES		0x00800000,
+	//ALIGN_256BYTES		0x00900000,
+	//ALIGN_512BYTES		0x00A00000,
+	//ALIGN_1024BYTES		0x00B00000,
+	//ALIGN_2048BYTES		0x00C00000,
+	//ALIGN_4096BYTES		0x00D00000,
+	//ALIGN_8192BYTES		0x00E00000,
+	LNK_NRELOC_OVFL:		0x01000000,
+	MEM_DISCARDABLE:		0x02000000,
+	MEM_NOT_CACHED:			0x04000000,
+	MEM_NOT_PAGED:			0x08000000,
+	MEM_SHARED:				0x10000000,
+	MEM_EXECUTE:			0x20000000,
+	MEM_READ:				0x40000000,
+	MEM_WRITE:				0x80000000,
+} as const;
+
+class Section extends binary.ReadClass({
 	Name:					binary.StringType(8),
-	VirtualSize:			binary.UINT32_LE,
-	VirtualAddress:			binary.XINT32_LE,
-	SizeOfRawData:			binary.UINT32_LE,
-	PointerToRawData:		binary.XINT32_LE,
-	PointerToRelocations:	binary.XINT32_LE,
-	PointerToLinenumbers:	binary.XINT32_LE,
+	VirtualSize:			uint32,
+	VirtualAddress:			binary.asHex(uint32),
+	SizeOfRawData:			uint32,
+	PointerToRawData:		binary.asHex(uint32),
+	PointerToRelocations:	binary.asHex(uint32),
+	PointerToLinenumbers:	binary.asHex(uint32),
 	NumberOfRelocations:	binary.INT16_LE,
 	NumberOfLinenumbers:	binary.INT16_LE,
-	Characteristics:		binary.asFlags(binary.UINT32_LE, SECTION_CHARACTERISTICS)
+	Characteristics:		binary.asFlags(uint32, SECTION_CHARACTERISTICS)
 }) {
-	data?: binary.utils.MappedMemory;
+	data?: binary.MappedMemory;
 	constructor(r: binary.stream) {
 		super(r);
 		try {
-			this.data = new binary.utils.MappedMemory(r.buffer_at(+this.PointerToRawData, this.SizeOfRawData), +this.VirtualAddress, this.flags);
+			this.data = new binary.MappedMemory(r.buffer_at(+this.PointerToRawData, this.SizeOfRawData), +this.VirtualAddress, this.flags);
 		} catch (e) {
 			console.log(e);
 		}
 	}
 	get flags() {
-		return binary.utils.MEM.RELATIVE
-			| (this.Characteristics.MEM_READ	? binary.utils.MEM.READ 	: 0)
-			| (this.Characteristics.MEM_WRITE	? binary.utils.MEM.WRITE 	: 0)
-			| (this.Characteristics.MEM_EXECUTE	? binary.utils.MEM.EXECUTE	: 0);
+		return binary.MEM.RELATIVE
+			| (this.Characteristics.MEM_READ	? binary.MEM.READ 	: 0)
+			| (this.Characteristics.MEM_WRITE	? binary.MEM.WRITE 	: 0)
+			| (this.Characteristics.MEM_EXECUTE	? binary.MEM.EXECUTE	: 0);
 	}
 }
 
 interface DirectoryInfo {
-	read?: (pe: PE, data: binary.utils.MappedMemory) => any;
+	read?: (pe: PE, data: binary.MappedMemory) => any;
 }
 
 export const DIRECTORIES : Record<string, DirectoryInfo> = {
@@ -173,8 +177,8 @@ export const DIRECTORIES : Record<string, DirectoryInfo> = {
 };
 
 export const DATA_DIRECTORY = {
-	VirtualAddress: 			binary.UINT32_LE,
-	Size: 						binary.UINT32_LE,
+	VirtualAddress: 			uint32,
+	Size: 						uint32,
 };
 
 type Directory = binary.ReadType<typeof DATA_DIRECTORY>;
@@ -201,72 +205,72 @@ const DLLCHARACTERISTICS = {
 };
 
 const OPTIONAL_HEADER = {
-	Magic:						binary.asEnum(binary.UINT16_LE, MAGIC),
+	Magic:						binary.asEnum(uint16, MAGIC),
 	MajorLinkerVersion:			binary.UINT8,
 	MinorLinkerVersion:			binary.UINT8,
-	SizeOfCode:					binary.UINT32_LE,
-	SizeOfInitializedData:		binary.UINT32_LE,
-	SizeOfUninitializedData:	binary.UINT32_LE,
-	AddressOfEntryPoint:		binary.XINT32_LE,
-	BaseOfCode:					binary.XINT32_LE,
+	SizeOfCode:					uint32,
+	SizeOfInitializedData:		uint32,
+	SizeOfUninitializedData:	uint32,
+	AddressOfEntryPoint:		binary.asHex(uint32),
+	BaseOfCode:					binary.asHex(uint32),
 };
 
 const OPTIONAL_HEADER32 = {
-	BaseOfData: 				binary.XINT32_LE,
-	ImageBase:  				binary.XINT32_LE,
-	SectionAlignment:   		binary.UINT32_LE,
-	FileAlignment:  			binary.UINT32_LE,
-	MajorOperatingSystemVersion:binary.UINT16_LE,
-	MinorOperatingSystemVersion:binary.UINT16_LE,
-	MajorImageVersion:  		binary.UINT16_LE,
-	MinorImageVersion:  		binary.UINT16_LE,
-	MajorSubsystemVersion:  	binary.UINT16_LE,
-	MinorSubsystemVersion:  	binary.UINT16_LE,
-	Win32VersionValue:  		binary.UINT32_LE,
-	SizeOfImage:				binary.UINT32_LE,
-	SizeOfHeaders:  			binary.UINT32_LE,
-	CheckSum:   				binary.UINT32_LE,
-	Subsystem:  				binary.UINT16_LE,
-	DllCharacteristics: 		binary.asFlags(binary.UINT16_LE, DLLCHARACTERISTICS),
-	SizeOfStackReserve: 		binary.UINT32_LE,
-	SizeOfStackCommit:  		binary.UINT32_LE,
-	SizeOfHeapReserve:  		binary.UINT32_LE,
-	SizeOfHeapCommit:   		binary.UINT32_LE,
-	LoaderFlags:				binary.UINT32_LE,
-	DataDirectory:  			binary.objectWithNames(binary.ArrayType(binary.UINT32_LE, DATA_DIRECTORY), binary.names(Object.keys(DIRECTORIES))),
+	BaseOfData: 				binary.asHex(uint32),
+	ImageBase:  				binary.asHex(uint32),
+	SectionAlignment:   		uint32,
+	FileAlignment:  			uint32,
+	MajorOperatingSystemVersion:uint16,
+	MinorOperatingSystemVersion:uint16,
+	MajorImageVersion:  		uint16,
+	MinorImageVersion:  		uint16,
+	MajorSubsystemVersion:  	uint16,
+	MinorSubsystemVersion:  	uint16,
+	Win32VersionValue:  		uint32,
+	SizeOfImage:				uint32,
+	SizeOfHeaders:  			uint32,
+	CheckSum:   				uint32,
+	Subsystem:  				uint16,
+	DllCharacteristics: 		binary.asFlags(uint16, DLLCHARACTERISTICS),
+	SizeOfStackReserve: 		uint32,
+	SizeOfStackCommit:  		uint32,
+	SizeOfHeapReserve:  		uint32,
+	SizeOfHeapCommit:   		uint32,
+	LoaderFlags:				uint32,
+	DataDirectory:  			binary.objectWithNames(binary.ArrayType(uint32, DATA_DIRECTORY), binary.names(Object.keys(DIRECTORIES))),
 };
 
 const OPTIONAL_HEADER64 = {
-	ImageBase:  				binary.XINT64_LE,
-	SectionAlignment:   		binary.UINT32_LE,
-	FileAlignment:  			binary.UINT32_LE,
-	MajorOperatingSystemVersion:binary.UINT16_LE,
-	MinorOperatingSystemVersion:binary.UINT16_LE,
-	MajorImageVersion:  		binary.UINT16_LE,
-	MinorImageVersion:  		binary.UINT16_LE,
-	MajorSubsystemVersion:  	binary.UINT16_LE,
-	MinorSubsystemVersion:  	binary.UINT16_LE,
-	Win32VersionValue:  		binary.UINT32_LE,
-	SizeOfImage:				binary.UINT32_LE,
-	SizeOfHeaders:  			binary.UINT32_LE,
-	CheckSum:   				binary.UINT32_LE,
-	Subsystem:  				binary.UINT16_LE,
-	DllCharacteristics: 		binary.asFlags(binary.UINT16_LE, DLLCHARACTERISTICS),
-	SizeOfStackReserve: 		binary.UINT64_LE,
-	SizeOfStackCommit:  		binary.UINT64_LE,
-	SizeOfHeapReserve:  		binary.UINT64_LE,
-	SizeOfHeapCommit:   		binary.UINT64_LE,
-	LoaderFlags:				binary.UINT32_LE,
-	DataDirectory:  			binary.objectWithNames(binary.ArrayType(binary.UINT32_LE, DATA_DIRECTORY), binary.names(Object.keys(DIRECTORIES))),
+	ImageBase:  				binary.asHex(uint64),
+	SectionAlignment:   		uint32,
+	FileAlignment:  			uint32,
+	MajorOperatingSystemVersion:uint16,
+	MinorOperatingSystemVersion:uint16,
+	MajorImageVersion:  		uint16,
+	MinorImageVersion:  		uint16,
+	MajorSubsystemVersion:  	uint16,
+	MinorSubsystemVersion:  	uint16,
+	Win32VersionValue:  		uint32,
+	SizeOfImage:				uint32,
+	SizeOfHeaders:  			uint32,
+	CheckSum:   				uint32,
+	Subsystem:  				uint16,
+	DllCharacteristics: 		binary.asFlags(uint16, DLLCHARACTERISTICS),
+	SizeOfStackReserve: 		uint64,
+	SizeOfStackCommit:  		uint64,
+	SizeOfHeapReserve:  		uint64,
+	SizeOfHeapCommit:   		uint64,
+	LoaderFlags:				uint32,
+	DataDirectory:  			binary.objectWithNames(binary.ArrayType(uint32, DATA_DIRECTORY), binary.names(Object.keys(DIRECTORIES))),
 };
 
 export class PE {
 	header:		binary.ReadType<typeof DOS_HEADER> & binary.ReadType<typeof EXE_HEADER>;
-	sections:	Section[];
 	opt?:		binary.ReadType<typeof OPTIONAL_HEADER> & (binary.ReadType<typeof OPTIONAL_HEADER32> | binary.ReadType<typeof OPTIONAL_HEADER64>);
+	sections:	Section[];
 
 	static check(data: Uint8Array): boolean {
-		return binary.UINT16_LE.get(new binary.stream(data)) === binary.utils.stringCode("MZ");
+		return uint16.get(new binary.stream(data)) === binary.utils.stringCode("MZ");
 	}
 
 	constructor(private data: Uint8Array) {
@@ -274,7 +278,7 @@ export class PE {
 		this.header	= binary.read(file, {...DOS_HEADER, ...EXE_HEADER});
 
 		file.seek(this.header.lfanew);
-		if (binary.UINT32_LE.get(file) == binary.utils.stringCode("PE\0\0")) {
+		if (uint32.get(file) == binary.utils.stringCode("PE\0\0")) {
 			const h = binary.read(file, FILE_HEADER);
 
 			if (h.SizeOfOptionalHeader) {
@@ -345,14 +349,14 @@ export class PE {
 //-----------------------------------------------------------------------------
 
 const EXPORT_DIRECTORY = {
-	ExportFlags:	binary.UINT32_LE,	// Reserved, must be 0.
+	ExportFlags:	uint32,	// Reserved, must be 0.
 	TimeDateStamp:	TIMEDATE,			// The time and date that the export data was created.
-	MajorVersion:	binary.XINT16_LE,	// The major version number. The major and minor version numbers can be set by the user.
-	MinorVersion:	binary.XINT16_LE,	// The minor version number.
+	MajorVersion:	binary.asHex(uint16),	// The major version number. The major and minor version numbers can be set by the user.
+	MinorVersion:	binary.asHex(uint16),	// The minor version number.
 	DLLName:		RVA_STRING,			// The address of the ASCII string that contains the name of the DLL. This address is relative to the image base.
-	OrdinalBase:	binary.UINT32_LE,	// The starting ordinal number for exports in this image. This field specifies the starting ordinal number for the export address table. It is usually set to 1.
-	NumberEntries:	binary.UINT32_LE,	// The number of entries in the export address table.
-	NumberNames:	binary.UINT32_LE,	// The number of entries in the name pointer table. This is also the number of entries in the ordinal table.
+	OrdinalBase:	uint32,				// The starting ordinal number for exports in this image. This field specifies the starting ordinal number for the export address table. It is usually set to 1.
+	NumberEntries:	uint32,				// The number of entries in the export address table.
+	NumberNames:	uint32,				// The number of entries in the name pointer table. This is also the number of entries in the ordinal table.
 	FunctionTable:	RVA_ARRAY32,		// RVA of functions
 	NameTable:		RVA_ARRAY32,		// RVA of names
 	OrdinalTable:	RVA_ARRAY16,		// RVA from base of image
@@ -406,15 +410,15 @@ const RVA_ITA64 = {
 			return result;
 		}
 	},
-	put(s: pe_stream)	{}
+	put(_s: pe_stream)	{}
 };
 
 const IMPORT_DESCRIPTOR = {
-	Characteristics:	binary.UINT32_LE,	// 0 for terminating null import descriptor
+	Characteristics:	uint32,	// 0 for terminating null import descriptor
 	TimeDateStamp:  	TIMEDATE,			// 0 if not bound, -1 if bound, and real date\time stamp in IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT (new BIND)	// O.W. date/time stamp of DLL bound to (Old BIND)
-	ForwarderChain: 	binary.UINT32_LE,	// -1 if no forwarders
-	DllName:			RVA_STRING,//binary.UINT32_LE,
-	FirstThunk:			RVA_ITA64,//binary.UINT32_LE,	// RVA to IAT (if bound this IAT has actual addresses)
+	ForwarderChain: 	uint32,	// -1 if no forwarders
+	DllName:			RVA_STRING,//uint32,
+	FirstThunk:			RVA_ITA64,//uint32,	// RVA to IAT (if bound this IAT has actual addresses)
 };
 
 export function ReadImports(file: pe_stream) {
@@ -432,78 +436,70 @@ export function ReadImports(file: pe_stream) {
 //	resources
 //-----------------------------------------------------------------------------
 
-const RESOURCE_DIRECTORY_ENTRY = {
-	get(s: binary.stream) {
-		const u0 = binary.UINT32_LE.get(s);
-		const u1 = binary.UINT32_LE.get(s);
-		return [u0, u1];
-	},
-	put(s: binary.stream) {}
-
-};
-
-class RESOURCE_DATA_ENTRY extends binary.ReadStruct({
-	OffsetToData:	binary.UINT32_LE,
-	Size:			binary.UINT32_LE,
-	CodePage:		binary.UINT32_LE,
-	Reserved:		binary.UINT32_LE,
+class RESOURCE_DATA_ENTRY extends binary.ReadClass({
+	OffsetToData:	uint32,
+	Size:			uint32,
+	CodePage:		uint32,
+	Reserved:		uint32,
 }) {
 	data:			Uint8Array;
-	constructor(file: binary.stream, data: binary.utils.MappedMemory) {
+	constructor(file: binary.stream, data: binary.MappedMemory) {
 		super(file);
 		this.data	= data.slice(this.OffsetToData, this.OffsetToData + this.Size).data;
 	}
 }
 
 const RESOURCE_DIRECTORY = {
-	Characteristics:		binary.UINT32_LE,
-	TimeDateStamp:			binary.UINT32_LE,
-	MajorVersion:			binary.UINT16_LE,
-	MinorVersion:			binary.UINT16_LE,
-	NumberOfNamedEntries:	binary.UINT16_LE,
-	NumberOfIdEntries:		binary.UINT16_LE,
+	Characteristics:		uint32,
+	TimeDateStamp:			uint32,
+	MajorVersion:			uint16,
+	MinorVersion:			uint16,
+	NumberOfNamedEntries:	uint16,
+	NumberOfIdEntries:		uint16,
+	entries:				binary.ArrayType(obj=> obj.NumberOfNamedEntries + obj.NumberOfIdEntries, {
+		u0: uint32,
+		u1: uint32,
+	})
 };
 
-enum IRT {
-	NONE			= 0,
-	CURSOR			= 1,
-	BITMAP			= 2,
-	ICON			= 3,
-	MENU			= 4,
-	DIALOG			= 5,
-	STRING			= 6,
-	FONTDIR			= 7,
-	FONT			= 8,
-	ACCELERATOR		= 9,
-	RCDATA			= 10,
-	MESSAGETABLE	= 11,
-	GROUP_CURSOR	= 12,
-	GROUP_ICON		= 14,
-	VERSION			= 16,
-	DLGINCLUDE		= 17,
-	PLUGPLAY		= 19,
-	VXD				= 20,
-	ANICURSOR		= 21,
-	ANIICON			= 22,
-	HTML			= 23,
-	MANIFEST		= 24,
-	TOOLBAR			= 241,
-}
-
-export function ReadResourceDirectory(file: binary.stream, data: binary.utils.MappedMemory, type = IRT.NONE) {
+const IRT = {
+	0:	'NONE',
+	1:	'CURSOR',
+	2:	'BITMAP',
+	3:	'ICON',
+	4:	'MENU',
+	5:	'DIALOG',
+	6:	'STRING',
+	7:	'FONTDIR',
+	8:	'FONT',
+	9:	'ACCELERATOR',
+	10:	'RCDATA',
+	11:	'MESSAGETABLE',
+	12:	'GROUP_CURSOR',
+	14:	'GROUP_ICON',
+	16:	'VERSION',
+	17:	'DLGINCLUDE',
+	19:	'PLUGPLAY',
+	20:	'VXD',
+	21:	'ANICURSOR',
+	22:	'ANIICON',
+	23:	'HTML',
+	24:	'MANIFEST',
+	241:'TOOLBAR',
+} as const;
+
+export function ReadResourceDirectory(file: binary.stream, data: binary.MappedMemory, type = 0) {
 	const dir 		= binary.read(file, RESOURCE_DIRECTORY);
-	const n			= dir.NumberOfNamedEntries + dir.NumberOfIdEntries;
-	const entries	= binary.readn(file, RESOURCE_DIRECTORY_ENTRY, n);
-	const id_type	= binary.StringType(binary.UINT16_LE, 'utf16le');
+	const id_type	= binary.StringType(uint16, 'utf16le');
 	const topbit	= 0x80000000;
 	const result : Record<string, any> = {};
 
-	for (const i of entries) {
-		const id = i[0] & topbit ? id_type.get(file.seek(i[0] & ~topbit)) : !type ? IRT[i[0]] : i[0];
+	for (const i of dir.entries) {
+		const id = i.u0 & topbit ? id_type.get(file.seek(i.u0 & ~topbit)) : !type ? IRT[i.u0 as keyof typeof IRT] : i.u0;
 		
-		file.seek(i[1] & ~topbit);
-		result[id]	= i[1] & topbit
-			? ReadResourceDirectory(file, data, type || i[0])
+		file.seek(i.u1 & ~topbit);
+		result[id]	= i.u1 & topbit
+			? ReadResourceDirectory(file, data, type || i.u0)
 			: new RESOURCE_DATA_ENTRY(file, data);
 	}
 	return result;