@isopodlabs/binary_libs 0.0.1 → 0.1.0

package/dist/mach.js

@@ -1,1034 +0,0 @@
-"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;