@isopodlabs/binary_libs 0.0.1

package/dist/mach.js

@@ -0,0 +1,1034 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FATMachFile = exports.MachFile = exports.CMD = void 0;
+const binary = __importStar(require("@isopodlabs/binary"));
+class mach_stream extends binary.stream_endian {
+    base;
+    mem;
+    constructor(base, data, be, mem) {
+        super(data, be);
+        this.base = base;
+        this.mem = mem;
+    }
+    subdata(offset, size) {
+        return this.base.subarray(offset, size && offset + size);
+    }
+    substream(offset, size) {
+        return new mach_stream(this.base, this.subdata(offset, size), this.be, this.mem);
+    }
+    getmem(address, size) {
+        return this.mem?.get(address, size);
+    }
+}
+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 FILETYPE = {
+    OBJECT: 1,
+    EXECUTE: 2,
+    FVMLIB: 3,
+    CORE: 4,
+    PRELOAD: 5,
+    DYLIB: 6,
+    DYLINKER: 7,
+    BUNDLE: 8,
+    DYLIB_STUB: 9,
+    DSYM: 10,
+    KEXT_BUNDLE: 11,
+    FILESET: 12
+};
+//	Machine types known by all
+var CPU_TYPE;
+(function (CPU_TYPE) {
+    CPU_TYPE[CPU_TYPE["ANY"] = -1] = "ANY";
+    CPU_TYPE[CPU_TYPE["ARCH_MASK"] = 4278190080] = "ARCH_MASK";
+    CPU_TYPE[CPU_TYPE["ARCH_64"] = 16777216] = "ARCH_64";
+    CPU_TYPE[CPU_TYPE["VAX"] = 1] = "VAX";
+    CPU_TYPE[CPU_TYPE["MC680x0"] = 6] = "MC680x0";
+    CPU_TYPE[CPU_TYPE["X86"] = 7] = "X86";
+    CPU_TYPE[CPU_TYPE["MIPS"] = 8] = "MIPS";
+    CPU_TYPE[CPU_TYPE["MC98000"] = 10] = "MC98000";
+    CPU_TYPE[CPU_TYPE["HPPA"] = 11] = "HPPA";
+    CPU_TYPE[CPU_TYPE["ARM"] = 12] = "ARM";
+    CPU_TYPE[CPU_TYPE["MC88000"] = 13] = "MC88000";
+    CPU_TYPE[CPU_TYPE["SPARC"] = 14] = "SPARC";
+    CPU_TYPE[CPU_TYPE["I860"] = 15] = "I860";
+    CPU_TYPE[CPU_TYPE["ALPHA"] = 16] = "ALPHA";
+    CPU_TYPE[CPU_TYPE["POWERPC"] = 18] = "POWERPC";
+    CPU_TYPE[CPU_TYPE["X86_64"] = 16777223] = "X86_64";
+    CPU_TYPE[CPU_TYPE["POWERPC_64"] = 16777234] = "POWERPC_64";
+    CPU_TYPE[CPU_TYPE["ARM_64"] = 16777228] = "ARM_64";
+})(CPU_TYPE || (CPU_TYPE = {}));
+const CPU_SUBTYPES = {
+    [CPU_TYPE.VAX]: {
+        VAX_ALL: 0,
+        VAX780: 1,
+        VAX785: 2,
+        VAX750: 3,
+        VAX730: 4,
+        UVAXI: 5,
+        UVAXII: 6,
+        VAX8200: 7,
+        VAX8500: 8,
+        VAX8600: 9,
+        VAX8650: 10,
+        VAX8800: 11,
+        UVAXIII: 12,
+    },
+    [CPU_TYPE.MC680x0]: {
+        MC680x0_ALL: 1,
+        MC68030: 1,
+        MC68040: 2,
+        MC68030_ONLY: 3,
+    },
+    [CPU_TYPE.X86]: {
+        X86_ALL: 3,
+        X86_64_ALL: 3,
+        X86_ARCH1: 4,
+    },
+    [CPU_TYPE.MIPS]: {
+        MIPS_ALL: 0,
+        MIPS_R2300: 1,
+        MIPS_R2600: 2,
+        MIPS_R2800: 3,
+        MIPS_R2000a: 4,
+        MIPS_R2000: 5,
+        MIPS_R3000a: 6,
+        MIPS_R3000: 7,
+    },
+    [CPU_TYPE.MC98000]: {
+        MC98000_ALL: 0,
+        MC98601: 1,
+    },
+    [CPU_TYPE.HPPA]: {
+        HPPA_ALL: 0,
+        HPPA_7100: 0,
+        HPPA_7100LC: 1,
+    },
+    [CPU_TYPE.ARM]: {
+        ARM_ALL: 0,
+        ARM_V4T: 5,
+        ARM_V6: 6,
+        ARM_V5TEJ: 7,
+        ARM_XSCALE: 8,
+        ARM_V7: 9,
+        ARM_V7S: 11,
+        ARM_V7K: 12,
+        ARM_V6M: 14,
+        ARM_V7M: 15,
+        ARM_V7EM: 16,
+    },
+    [CPU_TYPE.MC88000]: {
+        MC88000_ALL: 0,
+        MC88100: 1,
+        MC88110: 2,
+    },
+    [CPU_TYPE.SPARC]: {
+        SPARC_ALL: 0,
+    },
+    [CPU_TYPE.I860]: {
+        I860_ALL: 0,
+        I860_860: 1,
+    },
+    [CPU_TYPE.ALPHA]: {},
+    [CPU_TYPE.POWERPC]: {
+        POWERPC_ALL: 0,
+        POWERPC_601: 1,
+        POWERPC_602: 2,
+        POWERPC_603: 3,
+        POWERPC_603e: 4,
+        POWERPC_603ev: 5,
+        POWERPC_604: 6,
+        POWERPC_604e: 7,
+        POWERPC_620: 8,
+        POWERPC_750: 9,
+        POWERPC_7400: 10,
+        POWERPC_7450: 11,
+        POWERPC_970: 100,
+    },
+    [CPU_TYPE.X86_64]: {
+        I386_ALL: 0x03,
+        I386: 0x03,
+        I486: 0x04,
+        I486SX: 0x84,
+        I586: 0x05,
+        PENT: 0x05,
+        PENTPRO: 0x16,
+        PENTII_M3: 0x36,
+        PENTII_M5: 0x56,
+        CELERON: 0x67,
+        CELERON_MOBILE: 0x77,
+        PENTIUM_3: 0x08,
+        PENTIUM_3_M: 0x18,
+        PENTIUM_3_XEON: 0x28,
+        PENTIUM_M: 0x09,
+        PENTIUM_4: 0x0a,
+        PENTIUM_4_M: 0x1a,
+        ITANIUM: 0x0b,
+        ITANIUM_2: 0x1b,
+        XEON: 0x0c,
+        XEON_MP: 0x1c,
+    },
+    [CPU_TYPE.POWERPC_64]: {},
+    [CPU_TYPE.ARM_64]: {
+        FEATURE: 0x01000000,
+        LIB64: 0x80000000,
+        ARM64_ALL: 0,
+        ARM64_V8: 1,
+        ARM64E: 2,
+    },
+};
+// Constants for the flags field of the header
+const HEADER_FLAGS = {
+    NOUNDEFS: 0x1,
+    INCRLINK: 0x2,
+    DYLDLINK: 0x4,
+    BINDATLOAD: 0x8,
+    PREBOUND: 0x10,
+    SPLIT_SEGS: 0x20,
+    LAZY_INIT: 0x40,
+    TWOLEVEL: 0x80,
+    FORCE_FLAT: 0x100,
+    NOMULTIDEFS: 0x200,
+    NOFIXPREBINDING: 0x400,
+    PREBINDABLE: 0x800,
+    ALLMODSBOUND: 0x1000,
+    SUBSECTIONS_VIA_SYMBOLS: 0x2000,
+    CANONICAL: 0x4000,
+    WEAK_DEFINES: 0x8000,
+    BINDS_TO_WEAK: 0x10000,
+    ALLOW_STACK_EXECUTION: 0x20000,
+    ROOT_SAFE: 0x40000,
+    SETUID_SAFE: 0x80000,
+    NO_REEXPORTED_DYLIBS: 0x100000,
+    PIE: 0x200000,
+    DEAD_STRIPPABLE_DYLIB: 0x400000,
+    HAS_TLV_DESCRIPTORS: 0x800000,
+    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.
+};
+const header = {
+    magic: uint32,
+    cputype: binary.as(uint32, binary.Enum(CPU_TYPE)),
+    cpusubtype: binary.as(uint32, (x) => x),
+    filetype: binary.as(uint32, binary.Enum(FILETYPE)),
+    ncmds: uint32,
+    sizeofcmds: uint32,
+    flags: binary.as(uint32, binary.Flags(HEADER_FLAGS, true))
+};
+const fat_arch = {
+    cputype: binary.as(uint32, binary.Enum(CPU_TYPE)),
+    cpusubtype: binary.as(uint32, (x) => x),
+    offset: binary.UINT32_BE,
+    size: binary.UINT32_BE,
+    align: binary.UINT32_BE,
+    contents: binary.DontRead(),
+};
+const fat_header = {
+    magic: uint32,
+    archs: binary.ArrayType(uint32, fat_arch)
+};
+const REQ_DYLD = 0x80000000;
+exports.CMD = {
+    SEGMENT: 0x01,
+    SYMTAB: 0x02,
+    SYMSEG: 0x03,
+    THREAD: 0x04,
+    UNIXTHREAD: 0x05,
+    LOADFVMLIB: 0x06,
+    IDFVMLIB: 0x07,
+    IDENT: 0x08,
+    FVMFILE: 0x09,
+    PREPAGE: 0x0a,
+    DYSYMTAB: 0x0b,
+    LOAD_DYLIB: 0x0c,
+    ID_DYLIB: 0x0d,
+    LOAD_DYLINKER: 0x0e,
+    ID_DYLINKER: 0x0f,
+    PREBOUND_DYLIB: 0x10,
+    ROUTINES: 0x11,
+    SUB_FRAMEWORK: 0x12,
+    SUB_UMBRELLA: 0x13,
+    SUB_CLIENT: 0x14,
+    SUB_LIBRARY: 0x15,
+    TWOLEVEL_HINTS: 0x16,
+    PREBIND_CKSUM: 0x17,
+    LOAD_WEAK_DYLIB: 0x18 + REQ_DYLD,
+    SEGMENT_64: 0x19,
+    ROUTINES_64: 0x1a,
+    UUID: 0x1b,
+    RPATH: 0x1c + REQ_DYLD,
+    CODE_SIGNATURE: 0x1d,
+    SEGMENT_SPLIT_INFO: 0x1e,
+    REEXPORT_DYLIB: 0x1f + REQ_DYLD,
+    LAZY_LOAD_DYLIB: 0x20,
+    ENCRYPTION_INFO: 0x21,
+    DYLD_INFO: 0x22,
+    DYLD_INFO_ONLY: 0x22 + REQ_DYLD,
+    LOAD_UPWARD_DYLIB: 0x23 + REQ_DYLD,
+    VERSION_MIN_MACOSX: 0x24,
+    VERSION_MIN_IPHONEOS: 0x25,
+    FUNCTION_STARTS: 0x26,
+    DYLD_ENVIRONMENT: 0x27,
+    MAIN: 0x28 + REQ_DYLD,
+    DATA_IN_CODE: 0x29,
+    SOURCE_VERSION: 0x2A,
+    DYLIB_CODE_SIGN_DRS: 0x2B,
+    ENCRYPTION_INFO_64: 0x2C,
+    LINKER_OPTION: 0x2D,
+    LINKER_OPTIMIZATION_HINT: 0x2E,
+    VERSION_MIN_TVOS: 0x2F,
+    VERSION_MIN_WATCHOS: 0x30,
+    NOTE: 0x31,
+    BUILD_VERSION: 0x32,
+    DYLD_EXPORTS_TRIE: 0x33 + REQ_DYLD,
+    DYLD_CHAINED_FIXUPS: 0x34 + REQ_DYLD, // used with linkedit_data_command
+};
+const str = {
+    get(s) {
+        const off = uint32.get(s); // offset to the string
+        return binary.utils.decodeTextTo0(s.buffer_at(off - 8), 'utf8');
+    }
+};
+const index_table = {
+    first: uint32,
+    count: uint32,
+};
+const blob = {
+    get(s) {
+        const offset = uint32.get(s);
+        const size = uint32.get(s);
+        if (size)
+            return s.subdata(offset, size); //.buffer_at(offset, size);
+    }
+};
+function blobT(type) {
+    return {
+        get(s) {
+            const offset = uint32.get(s);
+            const size = uint32.get(s);
+            return {
+                data: s.subdata(offset, size),
+                contents: binary.read(s.substream(offset, size), type)
+            };
+        }
+    };
+}
+function count_table(type) {
+    return {
+        get(s) {
+            const offset = uint32.get(s);
+            const count = uint32.get(s);
+            if (count)
+                return binary.readn(s.substream(offset), type, count);
+        }
+    };
+}
+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(exports.CMD)),
+    cmdsize: uint32,
+};
+const SECTION_FLAGS = binary.BitFields({
+    TYPE: [8, binary.Enum({
+            REGULAR: 0x0,
+            ZEROFILL: 0x1,
+            CSTRING_LITERALS: 0x2,
+            LITERALS4: 0x3,
+            LITERALS8: 0x4,
+            LITERAL_POINTERS: 0x5,
+            NON_LAZY_SYMBOL_POINTERS: 0x6,
+            LAZY_SYMBOL_POINTERS: 0x7,
+            SYMBOL_STUBS: 0x8,
+            MOD_INIT_FUNC_POINTERS: 0x9,
+            MOD_TERM_FUNC_POINTERS: 0xa,
+            COALESCED: 0xb,
+            GB_ZEROFILL: 0xc,
+            INTERPOSING: 0xd,
+            LITERALS16: 0xe,
+            DTRACE_DOF: 0xf,
+            LAZY_DYLIB_SYMBOL_POINTERS: 0x10,
+            // Section types to support thread local variables
+            THREAD_LOCAL_REGULAR: 0x11,
+            THREAD_LOCAL_ZEROFILL: 0x12,
+            THREAD_LOCAL_VARIABLES: 0x13,
+            THREAD_LOCAL_VARIABLE_POINTERS: 0x14,
+            THREAD_LOCAL_INIT_FUNCTION_POINTERS: 0x15, // functions to call to initialize TLV values
+        })],
+    ATTRIBUTES: [24, binary.BitFields({
+            SYS: [16, binary.Flags({
+                    SOME_INSTRUCTIONS: 0x0004,
+                    EXT_RELOC: 0x0002,
+                    LOC_RELOC: 0x0001, // section has local relocation entries
+                }, true)],
+            USR: [8, binary.Flags({
+                    PURE_INSTRUCTIONS: 0x80,
+                    NO_TOC: 0x40,
+                    STRIP_STATIC_SYMS: 0x20,
+                    NO_DEAD_STRIP: 0x10,
+                    LIVE_SUPPORT: 0x08,
+                    SELF_MODIFYING_CODE: 0x04,
+                    DEBUG: 0x02, // a debug section
+                }, true)],
+        })],
+});
+function section(bits) {
+    const type = binary.UINT(bits);
+    class Section extends binary.ReadWriteStruct({
+        //data:		binary.DontRead<binary.utils.MappedMemory>(),
+        sectname: fixed_string16,
+        segname: fixed_string16,
+        addr: type,
+        size: type,
+        offset: xint32,
+        align: uint32,
+        reloff: xint32,
+        nreloc: uint32,
+        flags: binary.as(uint32, SECTION_FLAGS),
+        reserved1: uint32,
+        reserved2: uint32,
+        _: binary.AlignType(bits / 8)
+    }) {
+        data;
+        constructor(s) {
+            super(s);
+            const prot = this.flags.ATTRIBUTES.SYS.SOME_INSTRUCTIONS ? 4 /* binary.utils.MEM.EXECUTE */ : 0 /* 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);
+            })();
+        }
+    }
+    return Section;
+}
+const SEGMENT_FLAGS = {
+    HIGHVM: 0x1,
+    FVMLIB: 0x2,
+    NORELOC: 0x4,
+    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) {
+    const type = binary.UINT(bits);
+    const fields = {
+        data: binary.DontRead(),
+        segname: fixed_string16,
+        vmaddr: type,
+        vmsize: type,
+        fileoff: type,
+        filesize: type,
+        maxprot: uint32,
+        initprot: uint32,
+        nsects: uint32,
+        flags: binary.as(uint32, binary.Flags(SEGMENT_FLAGS, true)),
+        sections: binary.DontRead(), //binary.ReadType<typeof section(bits)>)),
+    };
+    return {
+        async get(s) {
+            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]));
+            }
+            return o;
+        }
+    };
+}
+const fvmlib = {
+    name: str,
+    minor_version: xint32,
+    header_addr: xint32, // library's header address
+};
+const dylib = {
+    name: str,
+    timestamp: uint32,
+    current_version: version,
+    compatibility_version: version,
+};
+const thread_command = {
+// uint32 flavor			flavor of thread state
+// uint32 count			count of longs in thread state
+// struct XXX_thread_state state	thread state for this flavor
+// ...
+};
+// SYMTAB
+const nlist_flags = binary.BitFields({
+    ext: 1,
+    type: [3, binary.Enum({
+            UNDF: 0,
+            ABS: 1,
+            INDR: 5,
+            PBUD: 6,
+            SECT: 7, // defined in section number n_sect
+        })],
+    pext: 1,
+    stab: [3, binary.Enum({})],
+});
+/*
+//masks
+    //STAB	= 0xe0,		// if any of these bits set, a symbolic debugging entry
+    PEXT	= 0x10,		// private external symbol bit
+    //TYPE	= 0x0e,		// mask for the type bits
+    EXT		= 0x01,		// external symbol bit, set for external symbols
+    
+    UNDF	= 0x00,		// undefined, n_sect == NO_SECT
+    ABS		= 0x02,		// absolute, n_sect == NO_SECT
+    INDR	= 0x0a,		// indirect
+    PBUD	= 0x0c,		// prebound undefined (defined in a dylib)
+    SECT	= 0x0e,		// defined in section number n_sect
+// STAB values
+    GSYM	= 0x20,		// global symbol: name,,NO_SECT,type,0
+    FNAME	= 0x22,		// procedure name (f77 kludge): name,,NO_SECT,0,0
+    FUN		= 0x24,		// procedure: name,,n_sect,linenumber,address
+    STSYM	= 0x26,		// static symbol: name,,n_sect,type,address
+    LCSYM	= 0x28,		// .lcomm symbol: name,,n_sect,type,address
+    BNSYM	= 0x2e,		// begin nsect sym: 0,,n_sect,0,address
+    OPT		= 0x3c,		// emitted with gcc2_compiled and in gcc source
+    RSYM	= 0x40,		// register sym: name,,NO_SECT,type,register
+    SLINE	= 0x44,		// src line: 0,,n_sect,linenumber,address
+    ENSYM	= 0x4e,		// end nsect sym: 0,,n_sect,0,address
+    SSYM	= 0x60,		// structure elt: name,,NO_SECT,type,struct_offset
+    SO		= 0x64,		// source file name: name,,n_sect,0,address
+    OSO		= 0x66,		// object file name: name,,0,0,st_mtime
+    LSYM	= 0x80,		// local sym: name,,NO_SECT,type,offset
+    BINCL	= 0x82,		// include file beginning: name,,NO_SECT,0,sum
+    SOL		= 0x84,		// #included file name: name,,n_sect,0,address
+    PARAMS	= 0x86,		// compiler parameters: name,,NO_SECT,0,0
+    VERSION	= 0x88,		// compiler version: name,,NO_SECT,0,0
+    OLEVEL	= 0x8A,		// compiler -O level: name,,NO_SECT,0,0
+    PSYM	= 0xa0,		// parameter: name,,NO_SECT,type,offset
+    EINCL	= 0xa2,		// include file end: name,,NO_SECT,0,0
+    ENTRY	= 0xa4,		// alternate entry: name,,n_sect,linenumber,address
+    LBRAC	= 0xc0,		// left bracket: 0,,NO_SECT,nesting level,address
+    EXCL	= 0xc2,		// deleted include file: name,,NO_SECT,0,sum
+    RBRAC	= 0xe0,		// right bracket: 0,,NO_SECT,nesting level,address
+    BCOMM	= 0xe2,		// begin common: name,,NO_SECT,0,0
+    ECOMM	= 0xe4,		// end common: name,,n_sect,0,0
+    ECOML	= 0xe8,		// end common (local name): 0,,n_sect,0,address
+    LENG	= 0xfe,		// second stab entry with length information
+}
+*/
+const nlist_desc = binary.BitFields({
+    ref: [3, binary.Enum({
+            UNDEFINED_NON_LAZY: 0,
+            UNDEFINED_LAZY: 1,
+            DEFINED: 2,
+            PRIVATE_DEFINED: 3,
+            PRIVATE_UNDEFINED_NON_LAZY: 4,
+            PRIVATE_UNDEFINED_LAZY: 5,
+        })],
+    flags: [5, binary.Flags({
+            ARM_THUMB_DEF: 1 << 0,
+            REF_DYNAMIC: 1 << 1,
+            NO_DEAD_STRIP: 1 << 2,
+            //DESC_DISCARDE:				1 << 2,	// symbol is discarded
+            WEAK_REF: 1 << 3,
+            WEAK_DEF: 1 << 4, // coalesed symbol is a weak definition
+            //REF_TO_WEA					1 << 4,	// reference to a weak symbol
+            //SYMBOL_RESOLVER:				0x0100,
+        }, true)],
+    align: 8
+    //MAX_LIBRARY_ORDINAL				= 0xfd	<< 8,
+    //DYNAMIC_LOOKUP_ORDINAL			= 0xfe	<< 8,
+    //EXECUTABLE_ORDINAL				= 0xff	<< 8,
+});
+function nlist(bits) {
+    return {
+        strx: uint32,
+        flags: binary.as(binary.UINT8, nlist_flags),
+        sect: binary.UINT8,
+        desc: binary.as(uint16, nlist_desc),
+        value: binary.UINT(bits),
+        //const char *name(const char *s) const { return s ? s + strx : ""; }
+        //FLAGS		type()	const	{ return FLAGS(flags & TYPE); }
+        //FLAGS		stab()	const	{ return FLAGS(flags & STAB); }
+    };
+}
+const symtab = {
+    get(s) {
+        const sym = binary.read(s, count_table(nlist(64)));
+        const str = binary.read(s, blob);
+        return sym?.map(v => [binary.utils.decodeTextTo0(str.subarray(v.strx), 'utf8'), v]);
+    }
+};
+// DYSYMTAB
+const INDIRECT = {
+    INDIRECT_SYMBOL_LOCAL: 0x80000000,
+    INDIRECT_SYMBOL_ABS: 0x40000000,
+};
+const toc_entry = {
+    symbol_index: uint32,
+    module_index: uint32, // index into the module table this symbol is defined in
+};
+function module(bits) {
+    const fields = {
+        module_name: uint32,
+        extdefsym: index_table,
+        refsym: index_table,
+        localsym: index_table,
+        extrel: index_table,
+        init_iterm: index_table, // low 16 bits are the index into the init section, high 16 bits are the index into the term section
+    };
+    return bits == 32 ? { ...fields,
+        objc_module_info_addr: uint32,
+        objc_module_info_size: uint32, // for this module size of the (__OBJC,__module_info) section
+    } : { ...fields,
+        objc_module_info_size: uint32,
+        objc_module_info_addr: uint64, // for this module address of the start of the (__OBJC, __module_info) section
+    };
+}
+const symbol_ref = binary.as(uint32, binary.BitFields({
+    symbol_index: 24,
+    flags: 8
+}));
+const hint = binary.as(uint32, binary.BitFields({
+    sub_image: 8,
+    toc: 24 // index into the table of contents
+}));
+const version_min = {
+    version,
+    reserved: uint32, // zero
+};
+const REBASE = binary.BitFields({
+    immediate: 4,
+    opcode: [4, binary.Enum({
+            DONE: 0,
+            SET_TYPE_IMM: 1,
+            SET_SEGMENT_AND_OFFSET_ULEB: 2,
+            ADD_ADDR_ULEB: 3,
+            ADD_ADDR_IMM_SCALED: 4,
+            DO_REBASE_IMM_TIMES: 5,
+            DO_REBASE_ULEB_TIMES: 6,
+            DO_REBASE_ADD_ADDR_ULEB: 7,
+            DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: 8,
+        })]
+    //TYPE_POINTER							= 1,
+    //TYPE_TEXT_ABSOLUTE32					= 2,
+    //TYPE_TEXT_PCREL32						= 3,
+});
+const BIND = binary.BitFields({
+    immediate: 4,
+    opcode: [4, binary.Enum({
+            DONE: 0,
+            SET_DYLIB_ORDINAL_IMM: 1,
+            SET_DYLIB_ORDINAL_ULEB: 2,
+            SET_DYLIB_SPECIAL_IMM: 3,
+            SET_SYMBOL_TRAILING_FLAGS_IMM: 4,
+            SET_TYPE_IMM: 5,
+            SET_ADDEND_SLEB: 6,
+            SET_SEGMENT_AND_OFFSET_ULEB: 7,
+            ADD_ADDR_ULEB: 8,
+            DO_BIND: 9,
+            DO_BIND_ADD_ADDR_ULEB: 10,
+            DO_BIND_ADD_ADDR_IMM_SCALED: 11,
+            DO_BIND_ULEB_TIMES_SKIPPING_ULEB: 12,
+        })]
+    //TYPE_POINTER							= 1,
+    //TYPE_TEXT_ABSOLUTE32					= 2,
+    //TYPE_TEXT_PCREL32						= 3,
+    //SPECIAL_DYLIB_SELF					= 0,
+    //SPECIAL_DYLIB_MAIN_EXECUTABLE			= -1,
+    //SPECIAL_DYLIB_FLAT_LOOKUP				= -2,
+    //SYMBOL_FLAGS_WEAK_IMPORT				= 0x1,
+    //SYMBOL_FLAGS_NON_WEAK_DEFINITION		= 0x8,
+});
+const dyld_kind = {
+    KIND_MASK: 0x03,
+    KIND_REGULAR: 0x00,
+    KIND_THREAD_LOCAL: 0x01,
+    KIND_ABSOLUTE: 0x02,
+    WEAK_DEFINITION: 0x04,
+    REEXPORT: 0x08,
+    STUB_AND_RESOLVER: 0x10,
+};
+const dyldinfo = {
+    rebase: blob,
+    bind: blob,
+    weak_bind: blob,
+    lazy_bind: blob,
+    exprt: blob,
+};
+//BUILD_VERSION
+const TOOL = {
+    CLANG: 1,
+    SWIFT: 2,
+    LD: 3,
+    LLD: 4,
+};
+const PLATFORM = {
+    MACOS: 1,
+    IOS: 2,
+    TVOS: 3,
+    WATCHOS: 4,
+    BRIDGEOS: 5,
+    MACCATALYST: 6,
+    IOSSIMULATOR: 7,
+    TVOSSIMULATOR: 8,
+    WATCHOSSIMULATOR: 9,
+    DRIVERKIT: 10,
+};
+//DYLD_CHAINED_FIXUPS
+const dyld_chained_starts_in_segment = {
+    size: uint32,
+    page_size: uint16,
+    pointer_format: binary.asEnum(uint16, {
+        ARM64E: 1,
+        '64': 2,
+        '32': 3,
+        '32_CACHE': 4,
+        '32_FIRMWARE': 5,
+        '64_OFFSET': 6,
+        ARM64E_KERNEL: 7,
+        '64_KERNEL_CACHE': 8,
+        ARM64E_USERLAND: 9,
+        ARM64E_FIRMWARE: 10,
+        X86_64_KERNEL_CACHE: 11,
+        ARM64E_USERLAND24: 12,
+    }),
+    segment_offset: xint64,
+    max_valid_pointer: xint32,
+    pages: binary.ArrayType(uint16, binary.asEnum(uint16, {
+        NONE: 0xFFFF,
+        MULTI: 0x8000,
+        LAST: 0x8000, // last chain_start for a given page
+    }))
+};
+const dyld_chained_starts_in_image = binary.ArrayType(uint32, binary.OffsetType(uint32, dyld_chained_starts_in_segment));
+const dyld_chained_import = binary.as(uint32, binary.BitFields({
+    lib_ordinal: 8,
+    weak_import: 1,
+    name_offset: 23,
+}));
+const dyld_chained_import_addend = {
+    import: dyld_chained_import,
+    addend: int32,
+};
+const dyld_chained_import_addend64 = {
+    import: binary.as(uint64, binary.BitFields({
+        lib_ordinal: 16,
+        weak_import: 1,
+        reserved: 15,
+        name_offset: 32,
+    })),
+    addend: uint64,
+};
+class dyld_chained_fixups extends binary.ReadStruct({
+    fixups_version: uint32,
+    starts: binary.OffsetType(uint32, dyld_chained_starts_in_image),
+    imports: binary.OffsetType(uint32, binary.Remainder),
+    symbols: binary.OffsetType(uint32, binary.Remainder),
+    imports_count: uint32,
+    imports_format: binary.asEnum(uint32, {
+        IMPORT: 1,
+        IMPORT_ADDEND: 2,
+        IMPORT_ADDEND64: 3
+    }),
+    symbols_format: binary.asEnum(uint32, {
+        UNCOMPRESSED: 0,
+        ZLIB: 1,
+    }),
+}) {
+    constructor(s) {
+        super(s);
+        const imports = new binary.stream_endian(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)));
+                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)));
+                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)));
+                break;
+        }
+    }
+}
+const dyld_chained_ptr_64_bind = binary.as(uint64, binary.BitFields({
+    ordinal: 24,
+    addend: 8,
+    reserved: 19,
+    next: 12,
+    bind: 1, // set to 1
+}));
+const dyld_chained_ptr_64_rebase = binary.as(uint64, binary.BitFields({
+    target: 36,
+    high8: 8,
+    reserved: 7,
+    next: 12,
+    bind: 1, // set to 0
+}));
+//DATA_IN_CODE
+const data_in_code_entry = {
+    offset: xint32,
+    length: uint16,
+    kind: binary.as(uint16, binary.Enum({
+        DATA: 0x0001,
+        JUMP_TABLE8: 0x0002,
+        JUMP_TABLE16: 0x0003,
+        JUMP_TABLE32: 0x0004,
+        ABS_JUMP_TABLE32: 0x0005,
+    })),
+};
+// Sections of type S_THREAD_LOCAL_VARIABLES contain an array of tlv_descriptor structures.
+/*
+const tlv_descriptor = {
+    void*			(*thunk)(tlv_descriptor*);
+    unsigned long	key;
+    unsigned long	offset;
+};
+*/
+function routines(bits) {
+    const type = binary.UINT(bits);
+    return {
+        init_address: type,
+        init_module: type,
+        reserved1: type,
+        reserved2: type,
+        reserved3: type,
+        reserved4: type,
+        reserved5: type,
+        reserved6: type,
+    };
+}
+//const cmd_table : {[K in CMD]?: binary.TypeReader2} = {
+const cmd_table = {
+    //const cmd_table = {
+    [exports.CMD.SEGMENT]: segment(32),
+    [exports.CMD.SEGMENT_64]: segment(64),
+    [exports.CMD.LOADFVMLIB]: fvmlib,
+    [exports.CMD.IDFVMLIB]: fvmlib,
+    [exports.CMD.LOAD_DYLIB]: dylib,
+    [exports.CMD.ID_DYLIB]: dylib,
+    [exports.CMD.LOAD_WEAK_DYLIB]: dylib,
+    [exports.CMD.REEXPORT_DYLIB]: dylib,
+    [exports.CMD.LAZY_LOAD_DYLIB]: dylib,
+    [exports.CMD.LOAD_UPWARD_DYLIB]: dylib,
+    [exports.CMD.SUB_FRAMEWORK]: str,
+    [exports.CMD.SUB_UMBRELLA]: str,
+    [exports.CMD.SUB_CLIENT]: str,
+    [exports.CMD.SUB_LIBRARY]: str,
+    [exports.CMD.LOAD_DYLINKER]: str,
+    [exports.CMD.ID_DYLINKER]: str,
+    [exports.CMD.DYLD_ENVIRONMENT]: str,
+    [exports.CMD.RPATH]: str,
+    [exports.CMD.PREBOUND_DYLIB]: {
+        name: str,
+        nmodules: uint32,
+        linked_modules: str,
+    },
+    [exports.CMD.THREAD]: thread_command,
+    [exports.CMD.UNIXTHREAD]: thread_command,
+    [exports.CMD.ROUTINES]: routines(32),
+    [exports.CMD.ROUTINES_64]: routines(64),
+    [exports.CMD.SYMTAB]: symtab,
+    [exports.CMD.TWOLEVEL_HINTS]: count_table(hint),
+    [exports.CMD.PREBIND_CKSUM]: {
+        cksum: uint32,
+    },
+    [exports.CMD.UUID]: {
+        uuid: binary.Buffer(16),
+    },
+    [exports.CMD.CODE_SIGNATURE]: blob,
+    [exports.CMD.SEGMENT_SPLIT_INFO]: blob,
+    [exports.CMD.FUNCTION_STARTS]: blobT(binary.RemainingArrayType(binary.ULEB128)),
+    [exports.CMD.DATA_IN_CODE]: blobT(binary.RemainingArrayType(data_in_code_entry)),
+    [exports.CMD.DYLIB_CODE_SIGN_DRS]: blob,
+    [exports.CMD.LINKER_OPTIMIZATION_HINT]: blob,
+    [exports.CMD.DYLD_EXPORTS_TRIE]: blob,
+    [exports.CMD.DYLD_CHAINED_FIXUPS]: blob,
+    [exports.CMD.ENCRYPTION_INFO]: {
+        cryptoff: uint32,
+        cryptsize: uint32,
+        cryptid: uint32, // which enryption system, 0 means not-encrypted yet
+    },
+    [exports.CMD.ENCRYPTION_INFO_64]: {
+        cryptoff: uint32,
+        cryptsize: uint32,
+        cryptid: uint32,
+        pad: uint32, // must be zero
+    },
+    [exports.CMD.VERSION_MIN_MACOSX]: version_min,
+    [exports.CMD.VERSION_MIN_IPHONEOS]: version_min,
+    [exports.CMD.VERSION_MIN_TVOS]: version_min,
+    [exports.CMD.VERSION_MIN_WATCHOS]: version_min,
+    [exports.CMD.DYLD_INFO]: dyldinfo,
+    [exports.CMD.DYLD_INFO_ONLY]: dyldinfo,
+    [exports.CMD.SYMSEG]: blob,
+    [exports.CMD.IDENT]: {},
+    [exports.CMD.FVMFILE]: {
+        name: str,
+        header_addr: uint32,
+    },
+    [exports.CMD.MAIN]: {
+        entryoff: uint32,
+        stacksize: uint32, // if not zero, initialize stack size
+    },
+    [exports.CMD.SOURCE_VERSION]: {
+        version: binary.as(binary.UINT64_BE, binary.BitFields({ a: 24, b: 10, c: 10, d: 10, e: 10 })) // A.B.C.D.E packed as a24.b10.c10.d10.e10
+    },
+    [exports.CMD.BUILD_VERSION]: {
+        platform: binary.asEnum(uint32, PLATFORM),
+        minos: version,
+        sdk: version,
+        tools: binary.objectWithNames(binary.ArrayType(uint32, { tool: binary.as(uint32, binary.Enum(TOOL)), version }), binary.field('tool')),
+    },
+    [exports.CMD.LINKER_OPTION]: {
+        count: uint32, // number of strings following
+    },
+    [exports.CMD.NOTE]: {
+        data_owner: fixed_string16,
+        data: blob
+    },
+    [exports.CMD.PREPAGE]: {},
+    [exports.CMD.DYSYMTAB]: {
+        localsym: index_table,
+        extdefsym: index_table,
+        undefsym: index_table,
+        toc: count_table(toc_entry),
+        modtab: count_table(module(64)),
+        extrefsym: count_table(symbol_ref),
+        indirectsym: count_table(symbol_ref),
+        extrel: count_table({ address: uint32, symbol_ref }),
+        locrel: count_table({ address: uint32, symbol_ref }), // local relocation entries
+    },
+};
+class MachFile {
+    header;
+    commands = [];
+    ready;
+    static check(data) {
+        switch (binary.UINT32_BE.get(new binary.stream(data))) {
+            case 0xfeedface:
+            case 0xcefaedfe:
+            case 0xfeedfacf:
+            case 0xcffaedfe:
+                return true;
+            default:
+                return false;
+        }
+    }
+    constructor(data, mem) {
+        const magic = binary.UINT32_LE.get(new binary.stream(data));
+        switch (magic) {
+            case 0xfeedface:
+                this.ready = this.load(data, false, 32, mem);
+                break;
+            case 0xcefaedfe:
+                this.ready = this.load(data, true, 32, mem);
+                break;
+            case 0xfeedfacf:
+                this.ready = this.load(data, false, 64, mem);
+                break;
+            case 0xcffaedfe:
+                this.ready = this.load(data, true, 64, mem);
+                break;
+            default: throw new Error('not a mach file');
+        }
+    }
+    async load(data, be, bits, mem) {
+        const file = new binary.stream_endian(data, be);
+        const h = binary.read(file, header);
+        const cpu = CPU_TYPE[h.cputype];
+        h.cpusubtype = binary.Enum(CPU_SUBTYPES[cpu])(+h.cpusubtype);
+        if (bits === 64)
+            file.skip(4);
+        for (let i = 0; i < h.ncmds; ++i) {
+            const cmd = binary.read(file, command);
+            const file2 = new mach_stream(data, file.read_buffer(cmd.cmdsize - 8), file.be, mem);
+            const result = await binary.read(file2, cmd_table[cmd.cmd] ?? {});
+            this.commands.push({ cmd: cmd.cmd, data: result });
+        }
+        this.header = h;
+        const funcs = this.getCommandT(exports.CMD.FUNCTION_STARTS);
+        if (funcs) {
+            const array = funcs.contents;
+            const text = await this.getSegment('__TEXT');
+            let acc = BigInt(text?.vmaddr ?? 0);
+            for (const i in array)
+                array[i] = (acc += BigInt(array[i]));
+        }
+    }
+    getCommand(cmd) {
+        for (const i of this.commands) {
+            if (i.cmd === cmd)
+                return i.data;
+        }
+    }
+    getCommandT(cmd) {
+        const c = this.getCommand(cmd);
+        return c;
+    }
+    getSegment(name) {
+        for (const i of this.commands) {
+            if ((i.cmd === exports.CMD.SEGMENT || i.cmd === exports.CMD.SEGMENT_64) && i.data.segname === name)
+                return i.data;
+        }
+    }
+}
+exports.MachFile = MachFile;
+const FAT_MAGIC = 0xcafebabe;
+const FAT_CIGAM = 0xbebafeca;
+class FATMachFile {
+    archs = [];
+    static check(data) {
+        switch (binary.UINT32_BE.get(new binary.stream(data))) {
+            case FAT_MAGIC:
+            case FAT_CIGAM:
+                return true;
+            default:
+                return false;
+        }
+    }
+    constructor(data, mem) {
+        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;
+            default:
+                throw new Error('not a fat mach file');
+        }
+    }
+    load(file, mem) {
+        const header = binary.read(file, fat_header);
+        this.archs = header.archs;
+        for (const arch of header.archs) {
+            const cpu = CPU_TYPE[arch.cputype];
+            const data = file.buffer_at(arch.offset, arch.size);
+            arch.cpusubtype = binary.Enum(CPU_SUBTYPES[cpu])(+arch.cpusubtype);
+            arch.contents = new MachFile(data);
+        }
+    }
+}
+exports.FATMachFile = FATMachFile;