@isopodlabs/binary_libs 0.0.1 → 0.1.1

package/src/mach.ts

@@ -1,7 +1,7 @@
 import * as binary from '@isopodlabs/binary';
 
-class mach_stream extends binary.stream_endian {
-	constructor(public base: Uint8Array, data: Uint8Array, be: boolean, public mem?: binary.utils.memory) { super(data, be); }
+class mach_stream extends binary.endianStream {
+	constructor(public base: Uint8Array, data: Uint8Array, be: boolean, public mem?: binary.memory) { super(data, be); }
 	subdata(offset: number, size?: number) {
 		return this.base.subarray(offset, size && offset + size);
 	}
@@ -17,8 +17,8 @@ const uint16	= binary.UINT16;
 const uint32	= binary.UINT32;
 const uint64	= binary.UINT64;
 const int32		= binary.INT32;
-const xint32	= binary.XINT32;
-const xint64	= binary.XINT64;
+const xint32	= binary.asHex(uint32);
+const xint64	= binary.asHex(uint64);
 
 const FILETYPE = {
 	OBJECT:			1,	// Relocatable object file
@@ -33,7 +33,7 @@ const FILETYPE = {
 	DSYM:			10,	// Companion file with only debug sections
 	KEXT_BUNDLE:	11,	// x86_64 kexts
 	FILESET:		12
-}
+} as const;
 
 //	Machine types known by all
 enum CPU_TYPE {
@@ -57,7 +57,7 @@ enum CPU_TYPE {
 	X86_64		= X86 		| ARCH_64,
 	POWERPC_64	= POWERPC 	| ARCH_64,
 	ARM_64		= ARM 		| ARCH_64,
-}
+};
 
 const CPU_SUBTYPES: {[K in CPU_TYPE]?: any} = {
 	[CPU_TYPE.VAX]			: {
@@ -185,7 +185,7 @@ const CPU_SUBTYPES: {[K in CPU_TYPE]?: any} = {
 		ARM64_V8: 		1,
 		ARM64E:	 		2,
 	},
-}
+};
 
 // Constants for the flags field of the header
 const HEADER_FLAGS = {
@@ -214,7 +214,7 @@ const HEADER_FLAGS = {
 	DEAD_STRIPPABLE_DYLIB:	0x400000,	// Only for use on dylibs.	When linking against a dylib that has this bit set, the static linker will automatically not create a LC_LOAD_DYLIBload command to the dylib if no symbols are being referenced from the dylib.
 	HAS_TLV_DESCRIPTORS:	0x800000,	// Contains a section of type S_THREAD_LOCAL_VARIABLES
 	NO_HEAP_EXECUTION:		0x1000000,	// When this bit is set, the OS will run the main executable with a non-executable heap even on platforms (e.g. i386) that don't require it.Only used in MH_EXECUTE filetypes.
-}
+} as const;
 
 const header = {
 	magic:		uint32,			// mach magic number identifier
@@ -241,62 +241,61 @@ const fat_header = {
 };
 
 const REQ_DYLD = 0x80000000;
-export const CMD = {
-	SEGMENT:					0x01,				// segment of this file to be mapped
-	SYMTAB:						0x02,				// link-edit stab symbol table info
-	SYMSEG:						0x03,				// link-edit gdb symbol table info (obsolete)
-	THREAD:						0x04,				// thread
-	UNIXTHREAD:					0x05,				// unix thread (includes a stack)
-	LOADFVMLIB:					0x06,				// load a specified fixed VM shared library
-	IDFVMLIB:					0x07,				// fixed VM shared library identification
-	IDENT:						0x08,				// object identification info (obsolete)
-	FVMFILE:					0x09,				// fixed VM file inclusion (internal use)
-	PREPAGE:					0x0a,				// prepage command (internal use)
-	DYSYMTAB:					0x0b,				// dynamic link-edit symbol table info
-	LOAD_DYLIB:					0x0c,				// load a dynamically linked shared library
-	ID_DYLIB:					0x0d,				// dynamically linked shared lib ident
-	LOAD_DYLINKER:				0x0e,				// load a dynamic linker
-	ID_DYLINKER:				0x0f,				// dynamic linker identification
-	PREBOUND_DYLIB:				0x10,				// modules prebound for a dynamically linked shared library
-	ROUTINES:					0x11,				// image routines
-	SUB_FRAMEWORK:				0x12,				// sub framework
-	SUB_UMBRELLA:				0x13,				// sub umbrella
-	SUB_CLIENT:					0x14,				// sub client
-	SUB_LIBRARY:				0x15,				// sub library
-	TWOLEVEL_HINTS:				0x16,				// two-level namespace lookup hints
-	PREBIND_CKSUM:				0x17,				// prebind checksum
-	LOAD_WEAK_DYLIB:			0x18 + REQ_DYLD,	// load a dynamically linked shared library that is allowed to be missing (all symbols are weak imported).
-	SEGMENT_64:					0x19,				// 64-bit segment of this file to be mapped
-	ROUTINES_64:				0x1a,				// 64-bit image routines
-	UUID:						0x1b,				// the uuid
-	RPATH:						0x1c + REQ_DYLD,	// runpath additions
-	CODE_SIGNATURE:				0x1d,				// local of code signature
-	SEGMENT_SPLIT_INFO:			0x1e,				// local of info to split segments
-	REEXPORT_DYLIB:				0x1f + REQ_DYLD,	// load and re-export dylib
-	LAZY_LOAD_DYLIB:			0x20,				// delay load of dylib until first use
-	ENCRYPTION_INFO:			0x21,				// encrypted segment information
-	DYLD_INFO:					0x22,				// compressed dyld information
-	DYLD_INFO_ONLY:				0x22 + REQ_DYLD,	// compressed dyld information only
-	LOAD_UPWARD_DYLIB:			0x23 + REQ_DYLD,	// load upward dylib
-	VERSION_MIN_MACOSX:			0x24,				// build for MacOSX min OS version
-	VERSION_MIN_IPHONEOS:		0x25,				// build for iPhoneOS min OS version
-	FUNCTION_STARTS:			0x26,				// compressed table of function start addresses
-	DYLD_ENVIRONMENT:			0x27,				// string for dyld to treat like environment variable
-	MAIN:						0x28 + REQ_DYLD,	// replacement for LC_UNIXTHREAD
-	DATA_IN_CODE:				0x29,				// table of non-instructions in __text
-	SOURCE_VERSION:				0x2A,				// source version used to build binary
-	DYLIB_CODE_SIGN_DRS:		0x2B,				// Code signing DRs copied from linked dylibs
-	ENCRYPTION_INFO_64:			0x2C,				// 64-bit encrypted segment information
-	LINKER_OPTION:				0x2D,				// linker options in MH_OBJECT files
-	LINKER_OPTIMIZATION_HINT:	0x2E,				// optimization hints in MH_OBJECT files
-	VERSION_MIN_TVOS:			0x2F,				// build for AppleTV min OS version
-	VERSION_MIN_WATCHOS:		0x30,				// build for Watch min OS version
-	NOTE:						0x31,				// arbitrary data included within a Mach-O file
-	BUILD_VERSION:				0x32,				// build for platform min OS version
-	DYLD_EXPORTS_TRIE:			0x33 + REQ_DYLD,	// used with linkedit_data_command, payload is trie
-	DYLD_CHAINED_FIXUPS:		0x34 + REQ_DYLD,	// used with linkedit_data_command
-} as const;
-export type CMD = typeof CMD[keyof typeof CMD];
+const enum CMD {
+	SEGMENT						= 0x01,				// segment of this file to be mapped
+	SYMTAB						= 0x02,				// link-edit stab symbol table info
+	SYMSEG						= 0x03,				// link-edit gdb symbol table info (obsolete)
+	THREAD						= 0x04,				// thread
+	UNIXTHREAD					= 0x05,				// unix thread (includes a stack)
+	LOADFVMLIB					= 0x06,				// load a specified fixed VM shared library
+	IDFVMLIB					= 0x07,				// fixed VM shared library identification
+//	IDENT						= 0x08,				// object identification info (obsolete)
+	FVMFILE						= 0x09,				// fixed VM file inclusion (internal use)
+//	PREPAGE						= 0x0a,				// prepage command (internal use)
+	DYSYMTAB					= 0x0b,				// dynamic link-edit symbol table info
+	LOAD_DYLIB					= 0x0c,				// load a dynamically linked shared library
+	ID_DYLIB					= 0x0d,				// dynamically linked shared lib ident
+	LOAD_DYLINKER				= 0x0e,				// load a dynamic linker
+	ID_DYLINKER					= 0x0f,				// dynamic linker identification
+	PREBOUND_DYLIB				= 0x10,				// modules prebound for a dynamically linked shared library
+	ROUTINES					= 0x11,				// image routines
+	SUB_FRAMEWORK				= 0x12,				// sub framework
+	SUB_UMBRELLA				= 0x13,				// sub umbrella
+	SUB_CLIENT					= 0x14,				// sub client
+	SUB_LIBRARY					= 0x15,				// sub library
+	TWOLEVEL_HINTS				= 0x16,				// two-level namespace lookup hints
+	PREBIND_CKSUM				= 0x17,				// prebind checksum
+	LOAD_WEAK_DYLIB				= REQ_DYLD+0x18,	// load a dynamically linked shared library that is allowed to be missing (all symbols are weak imported).
+	SEGMENT_64					= 0x19,				// 64-bit segment of this file to be mapped
+	ROUTINES_64					= 0x1a,				// 64-bit image routines
+	UUID						= 0x1b,				// the uuid
+	RPATH						= REQ_DYLD+0x1c,	// runpath additions
+	CODE_SIGNATURE				= 0x1d,				// local of code signature
+	SEGMENT_SPLIT_INFO			= 0x1e,				// local of info to split segments
+	REEXPORT_DYLIB				= REQ_DYLD+0x1f,	// load and re-export dylib
+	LAZY_LOAD_DYLIB				= 0x20,				// delay load of dylib until first use
+	ENCRYPTION_INFO				= 0x21,				// encrypted segment information
+	DYLD_INFO					= 0x22,				// compressed dyld information
+	DYLD_INFO_ONLY				= REQ_DYLD+0x22,	// compressed dyld information only
+	LOAD_UPWARD_DYLIB			= REQ_DYLD+0x23,	// load upward dylib
+	VERSION_MIN_MACOSX			= 0x24,				// build for MacOSX min OS version
+	VERSION_MIN_IPHONEOS		= 0x25,				// build for iPhoneOS min OS version
+	FUNCTION_STARTS				= 0x26,				// compressed table of function start addresses
+	DYLD_ENVIRONMENT			= 0x27,				// string for dyld to treat like environment variable
+	MAIN						= REQ_DYLD+0x28,	// replacement for LC_UNIXTHREAD
+	DATA_IN_CODE				= 0x29,				// table of non-instructions in __text
+	SOURCE_VERSION				= 0x2A,				// source version used to build binary
+	DYLIB_CODE_SIGN_DRS			= 0x2B,				// Code signing DRs copied from linked dylibs
+	ENCRYPTION_INFO_64			= 0x2C,				// 64-bit encrypted segment information
+	LINKER_OPTION				= 0x2D,				// linker options in MH_OBJECT files
+	LINKER_OPTIMIZATION_HINT	= 0x2E,				// optimization hints in MH_OBJECT files
+	VERSION_MIN_TVOS			= 0x2F,				// build for AppleTV min OS version
+	VERSION_MIN_WATCHOS			= 0x30,				// build for Watch min OS version
+	NOTE						= 0x31,				// arbitrary data included within a Mach-O file
+	BUILD_VERSION				= 0x32,				// build for platform min OS version
+	DYLD_EXPORTS_TRIE			= REQ_DYLD+0x33,	// used with linkedit_data_command, payload is trie
+	DYLD_CHAINED_FIXUPS			= REQ_DYLD+0x34,	// used with linkedit_data_command
+};
 
 const str = {
 	get(s: binary.stream) {
@@ -308,7 +307,7 @@ const str = {
 const index_table = {
 	first:	uint32,
 	count:	uint32,
-}
+};
 
 const blob = {
 	get(s: mach_stream) {
@@ -327,11 +326,16 @@ function blobT<T extends binary.TypeReader>(type: T) {
 			return {
 				data: s.subdata(offset, size),
 				contents: binary.read(s.substream(offset, size), type)
-			}
+			};
 		}
 	};
 }
 
+function blobArray<T extends binary.Type>(type: T) {
+	return blobT(binary.RemainingArrayType(type));
+}
+
+
 function count_table<T extends binary.TypeReader>(type: T) {
 	return {
 		get(s: mach_stream) {
@@ -347,9 +351,9 @@ const fixed_string16	= binary.StringType(16);
 const version			= binary.asFlags(uint32, {major: 0xffff0000, minor: 0xff00, patch: 0xff}, false);
 
 const command = {
-	cmd:		binary.as(uint32, binary.EnumV(CMD)),
+	cmd:		binary.as(uint32, v => v as CMD),
 	cmdsize:	uint32,
-}
+};
 
 const SECTION_FLAGS = binary.BitFields({
 	TYPE: [8, binary.Enum({
@@ -398,7 +402,7 @@ const SECTION_FLAGS = binary.BitFields({
 function section(bits: 32|64) {
 	const type		= binary.UINT(bits);
 
-	class Section extends binary.ReadWriteStruct({
+	class Section extends binary.Class({
 		//data:		binary.DontRead<binary.utils.MappedMemory>(),
 		sectname: 	fixed_string16,
 		segname: 	fixed_string16,
@@ -413,14 +417,14 @@ function section(bits: 32|64) {
 		reserved2:	uint32,		// reserved (for count or sizeof)
 		_:			binary.AlignType(bits / 8)
 	}) {
-		data:	Promise<binary.utils.MappedMemory>;
+		data:	Promise<binary.MappedMemory>;
 		constructor(s: mach_stream) {
 			super(s);
-			const prot	= this.flags.ATTRIBUTES.SYS.SOME_INSTRUCTIONS ? binary.utils.MEM.EXECUTE : binary.utils.MEM.NONE;
-			this.data 	= (async () => {
-				//return new binary.utils.MappedMemory(await s.file.get(BigInt(this.addr), Number(this.size)), Number(this.addr), prot)
-				return new binary.utils.MappedMemory(s.subdata(+this.offset, Number(this.size)), Number(this.addr), prot)
-			})();
+			const prot	= this.flags.ATTRIBUTES.SYS.SOME_INSTRUCTIONS ? binary.MEM.EXECUTE : binary.MEM.NONE;
+			this.data 	= (async () =>
+				//new binary.utils.MappedMemory(await s.file.get(BigInt(this.addr), Number(this.size)), Number(this.addr), prot)
+				new binary.MappedMemory(s.subdata(+this.offset, Number(this.size)), Number(this.addr), prot)
+			)();
 		}
 	}
 	return Section;
@@ -431,12 +435,12 @@ const SEGMENT_FLAGS = {
 	FVMLIB:					0x2,	// this segment is the VM that is allocated by a fixed VM library, for overlap checking in the link editor
 	NORELOC:				0x4,	// this segment has nothing that was relocated in it and nothing relocated to it, that is it maybe safely replaced without relocation
 	PROTECTED_VERSION_1:	0x8,	// This segment is protected.	If the segment starts at file offset 0, the first page of the segment is not protected.	All other pages of the segment are protected.
-}
+};
 
-function segment(bits: 32|64) {
+function segment<T extends 32|64>(bits: T) {
 	const type		= binary.UINT(bits);
 	const fields	= {
-		data:		binary.DontRead<binary.utils.MappedMemory>(),
+		data:		binary.DontRead<binary.MappedMemory>(),
 		segname: 	fixed_string16,	// segment name
 		vmaddr:		type,		// memory address of this segment
 		vmsize:		type,		// memory size of this segment
@@ -449,21 +453,62 @@ function segment(bits: 32|64) {
 		sections:	binary.DontRead<Record<string, any>>(),//binary.ReadType<typeof section(bits)>)),
 	};
 	return {
-		async get(s: mach_stream) {
+		get(s: mach_stream) {
 			const o = binary.read(s, fields);
-			const data = await s.getmem(BigInt(o.vmaddr), Number(o.filesize)) ?? s.subdata(Number(o.fileoff), Number(o.filesize));
-			o.data = new binary.utils.MappedMemory(data, Number(o.vmaddr), o.initprot);
 
-			const sect = section(bits);
-			if (o.nsects) {
-				o.sections = binary.objectWithNames(binary.ArrayType(o.nsects, section(bits)), binary.field('sectname')).get(s);
-				//o.sections = Object.fromEntries(Array.from({length: o.nsects}, (_,i)=>new sect(s)).map(s => [s.sectname, s]));
+			async function load() {
+				const data = await s.getmem(BigInt(Number(o.vmaddr)), Number(o.filesize)) ?? s.subdata(Number(o.fileoff), Number(o.filesize));
+				o.data = new binary.MappedMemory(data, Number(o.vmaddr), o.initprot);
+
+				//const sect = section(bits);
+				if (o.nsects) {
+					o.sections = binary.objectWithNames(binary.ArrayType(o.nsects, section(bits)), binary.field('sectname')).get(s);
+					//o.sections = Object.fromEntries(Array.from({length: o.nsects}, (_,i)=>new sect(s)).map(s => [s.sectname, s]));
+				}
 			}
+		
+			load();
 			return o;
 		}
 	};
 }
 
+/*
+function segment(bits: 32|64) {
+	const type		= binary.UINT(bits);
+	return class extends binary.ReadWriteStruct({
+		segname: 	fixed_string16,	// segment name
+		vmaddr:		type,		// memory address of this segment
+		vmsize:		type,		// memory size of this segment
+		fileoff:	type,		// file offset of this segment
+		filesize:	type,		// amount to map from the file
+		maxprot:	uint32,		// maximum VM protection
+		initprot:	uint32,		// initial VM protection
+		nsects:		uint32,		// number of sections in segment
+		flags:		binary.as(uint32, binary.Flags(SEGMENT_FLAGS,true)),			// flags
+	}) {
+		data?:		binary.MappedMemory;
+		sections:	Record<string, any>	= {};
+
+		constructor(s: mach_stream) {
+			super(s);
+			this.load(s);
+		}
+		async load(s: mach_stream) {
+			const data = await s.getmem(BigInt(this.vmaddr), Number(this.filesize)) ?? s.subdata(Number(this.fileoff), Number(this.filesize));
+			this.data = new binary.MappedMemory(data, Number(this.vmaddr), this.initprot);
+
+			//const sect = section(bits);
+			if (this.nsects) {
+				this.sections = binary.objectWithNames(binary.ArrayType(this.nsects, section(bits)), binary.field('sectname')).get(s);
+				//o.sections = Object.fromEntries(Array.from({length: o.nsects}, (_,i)=>new sect(s)).map(s => [s.sectname, s]));
+			}
+
+		}
+	};
+}
+*/
+
 const fvmlib = {
 	name:			str,	// library's target pathname
 	minor_version:	xint32,	// library's minor version number
@@ -478,8 +523,8 @@ const	dylib = {
 };
 
 const thread_command = {
-	// uint32 flavor			flavor of thread state
-	// uint32 count			count of longs in thread state
+	flavor:			uint32,	// flavor of thread state
+	count:			uint32, // count of longs in thread state
 	// struct XXX_thread_state state	thread state for this flavor
 	// ...
 };
@@ -594,7 +639,7 @@ const symtab = {
 const INDIRECT = {
 	INDIRECT_SYMBOL_LOCAL:	0x80000000,	// non-lazy symbol pointer section for a defined symbol which strip(1) has removed
 	INDIRECT_SYMBOL_ABS:	0x40000000,
-}
+} as const;
 
 const toc_entry = {
 	symbol_index:	uint32,			// the defined external symbol (index into the symbol table)
@@ -687,7 +732,7 @@ const dyld_kind = {
 	WEAK_DEFINITION:	0x04,
 	REEXPORT:			0x08,
 	STUB_AND_RESOLVER:	0x10,
-}
+} as const;
 
 const dyldinfo = {
 	rebase:		blob,
@@ -703,7 +748,8 @@ const TOOL = {
 	SWIFT:	2,
 	LD:		3,
 	LLD:	4,
-}
+} as const;
+
 const PLATFORM = {
 	MACOS:				1,
 	IOS:				2,
@@ -715,7 +761,7 @@ const PLATFORM = {
 	TVOSSIMULATOR:		8,
 	WATCHOSSIMULATOR:	9,
 	DRIVERKIT:			10,
-}
+} as const;
 
 //DYLD_CHAINED_FIXUPS
 
@@ -768,7 +814,7 @@ const dyld_chained_import_addend64 = {
 	addend:	uint64,
 };
 
-class dyld_chained_fixups extends binary.ReadStruct({
+class dyld_chained_fixups extends binary.ReadClass({
 	fixups_version:	uint32,	// currently 0
 	starts:			binary.OffsetType(uint32, dyld_chained_starts_in_image),
 	imports:		binary.OffsetType(uint32, binary.Remainder),	// offset of imports table in chain_data
@@ -784,18 +830,20 @@ class dyld_chained_fixups extends binary.ReadStruct({
 		ZLIB:				1,
 	}),
 }) {
-	constructor(s: binary.stream_endian) {
+	imports2;
+	constructor(s: binary.endianStream) {
 		super(s);
-		const imports = new binary.stream_endian(this.imports, s.be);
+		const imports = new binary.endianStream(this.imports, s.be);
 		switch (this.imports_format) {
-			case 'IMPORT':
-				this.imports = binary.withNames(binary.readn(imports, dyld_chained_import, this.imports_count), imp => binary.utils.decodeTextTo0(this.symbols.subarray(imp.name_offset)));
+			case 'IMPORT': {
+				this.imports2 = binary.withNames(binary.readn(imports, dyld_chained_import, this.imports_count), imp => binary.utils.decodeTextTo0(this.symbols.subarray(Number(imp.name_offset))));
 				break;
+			}
 			case 'IMPORT_ADDEND':
-				this.imports = binary.withNames(binary.readn(imports, dyld_chained_import_addend, this.imports_count), imp => binary.utils.decodeTextTo0(this.symbols.subarray(imp.import.name_offset)));
+				this.imports2 = binary.withNames(binary.readn(imports, dyld_chained_import_addend, this.imports_count), imp => binary.utils.decodeTextTo0(this.symbols.subarray(Number(imp.import.name_offset))));
 				break;
 			case 'IMPORT_ADDEND64':
-				this.imports = binary.withNames(binary.readn(imports, dyld_chained_import_addend64, this.imports_count), imp => binary.utils.decodeTextTo0(this.symbols.subarray(imp.import.name_offset)));
+				this.imports2 = binary.withNames(binary.readn(imports, dyld_chained_import_addend64, this.imports_count), imp => binary.utils.decodeTextTo0(this.symbols.subarray(Number(imp.import.name_offset))));
 				break;
 		}
 	}
@@ -858,7 +906,6 @@ function routines(bits:32|64) {
 
 //const cmd_table : {[K in CMD]?: binary.TypeReader2} = {
 const cmd_table = {//: Record<CMD, binary.TypeReader2> = {
-		//const cmd_table = {
 	[CMD.SEGMENT]:					segment(32),
 	[CMD.SEGMENT_64]:				segment(64),
 	[CMD.LOADFVMLIB]:				fvmlib,
@@ -906,8 +953,8 @@ const cmd_table = {//: Record<CMD, binary.TypeReader2> = {
 
 	[CMD.CODE_SIGNATURE]:			blob,
 	[CMD.SEGMENT_SPLIT_INFO]:		blob,
-	[CMD.FUNCTION_STARTS]:			blobT(binary.RemainingArrayType(binary.ULEB128)),
-	[CMD.DATA_IN_CODE]:				blobT(binary.RemainingArrayType(data_in_code_entry)),
+	[CMD.FUNCTION_STARTS]:			blobArray(binary.ULEB128),
+	[CMD.DATA_IN_CODE]:				blobArray(data_in_code_entry),
 	[CMD.DYLIB_CODE_SIGN_DRS]:		blob,
 	[CMD.LINKER_OPTIMIZATION_HINT]:	blob,
 	[CMD.DYLD_EXPORTS_TRIE]:		blob,
@@ -935,7 +982,7 @@ const cmd_table = {//: Record<CMD, binary.TypeReader2> = {
 
 	[CMD.SYMSEG]:					blob,//OBSOLETE
 
-	[CMD.IDENT]:					{},//OBSOLETE
+//	[CMD.IDENT]:					{},//OBSOLETE
 
 	[CMD.FVMFILE]:					{//OBSOLETE
 		name:			str,
@@ -963,7 +1010,7 @@ const cmd_table = {//: Record<CMD, binary.TypeReader2> = {
 		data_owner:		fixed_string16,	// owner name for this LC_NOTE
 		data:			blob
 	},
-	[CMD.PREPAGE]:					{},
+//	[CMD.PREPAGE]:					{},
 	[CMD.DYSYMTAB]:					{
 		localsym:		index_table,	// local symbols
 		extdefsym:		index_table,	// externally defined symbols
@@ -994,7 +1041,7 @@ export class MachFile {
 		}
 	}
 
-	constructor(data: Uint8Array, mem?: binary.utils.memory) {
+	constructor(data: Uint8Array, mem?: binary.memory) {
 		const magic	= binary.UINT32_LE.get(new binary.stream(data));
 		switch (magic) {
 			case 0xfeedface:	this.ready = this.load(data, false, 32, mem); break;
@@ -1005,8 +1052,8 @@ export class MachFile {
 		}
 	}
 
-	async load(data: Uint8Array, be: boolean, bits: 32|64, mem?: binary.utils.memory) {
-		const file	= new binary.stream_endian(data, be);
+	async load(data: Uint8Array, be: boolean, bits: 32|64, mem?: binary.memory) {
+		const file	= new binary.endianStream(data, be);
 		const h 	= binary.read(file, header);
 		const cpu	= CPU_TYPE[h.cputype as keyof typeof CPU_TYPE];
 		h.cpusubtype = binary.Enum(CPU_SUBTYPES[cpu])(+h.cpusubtype);
@@ -1021,7 +1068,7 @@ export class MachFile {
 		}
 		this.header = h;
 
-		const funcs = this.getCommandT(CMD.FUNCTION_STARTS);
+		const funcs = this.getCommand(CMD.FUNCTION_STARTS);
 		if (funcs) {
 			const array = funcs.contents;
 			const text	= await this.getSegment('__TEXT');
@@ -1030,7 +1077,8 @@ export class MachFile {
 				array[i] = (acc += BigInt(array[i]));
 		}
 	}
-
+	
+	getCommand<T extends CMD>(cmd: T) : binary.ReadType<typeof cmd_table[T]>;
 	getCommand(cmd: CMD) {
 		for (const i of this.commands) {
 			if (i.cmd === cmd)
@@ -1038,14 +1086,12 @@ export class MachFile {
 		}
 	}
 
-	getCommandT<T extends CMD>(cmd: T) {
-		const c = this.getCommand(cmd);
-		return c as binary.ReadType<typeof cmd_table[T]>;
-	}
-	getSegment(name: string) : binary.ReadType<ReturnType<typeof segment>> | undefined {
+	getSegment(name: string) {
 		for (const i of this.commands) {
-			if ((i.cmd === CMD.SEGMENT || i.cmd === CMD.SEGMENT_64) && i.data.segname === name)
-				return i.data;
+			if (i.cmd === CMD.SEGMENT && i.data.segname === name)
+				return i.data as binary.ReadType<typeof cmd_table[CMD.SEGMENT]>;
+			if (i.cmd === CMD.SEGMENT_64 && i.data.segname === name)
+				return i.data as binary.ReadType<typeof cmd_table[CMD.SEGMENT_64]>;;
 		}
 	}
 }
@@ -1066,24 +1112,29 @@ export class FATMachFile {
 		}
 	}
 	
-	constructor(data: Uint8Array, mem?: binary.utils.memory) {
+	constructor(data: Uint8Array, mem?: binary.memory) {
 		switch (binary.UINT32_BE.get(new binary.stream(data))) {
-			case FAT_MAGIC:		this.load(new binary.stream_endian(data, false), mem); break;
-			case FAT_CIGAM:		this.load(new binary.stream_endian(data, true), mem); break;
+			case FAT_MAGIC:		this.load(new binary.endianStream(data, false), mem); break;
+			case FAT_CIGAM:		this.load(new binary.endianStream(data, true), mem); break;
 			default:
 				throw new Error('not a fat mach file');
 		}
 	}
 
-	load(file: binary.stream_endian, mem?: binary.utils.memory) {
+	load(file: binary.endianStream, mem?: binary.memory) {
 		const header = binary.read(file, fat_header);
 		this.archs = header.archs;
 		for (const arch of header.archs) {
 			const cpu	= CPU_TYPE[arch.cputype as keyof typeof CPU_TYPE];
 			const data	= file.buffer_at(arch.offset, arch. size);
 			arch.cpusubtype = binary.Enum(CPU_SUBTYPES[cpu])(+arch.cpusubtype);
-			arch.contents	= new MachFile(data);
+			arch.contents	= new MachFile(data, mem);
 		}
 	}
 }
-
+/*
+export function freestanding<T extends CMD>(s: binary.stream, cmd: T) : binary.ReadType<typeof cmd_table[T]>;
+export function freestanding(s: binary.stream, cmd: CMD) {
+	return binary.read(s, cmd_table[cmd]);
+}
+*/