@isopodlabs/binary_libs 1.2.0 → 1.3.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adrian Stephens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,9 +1,12 @@
 # Binary Libs
+[![npm version](https://img.shields.io/npm/v/@isopodlabs/binary_libs.svg)](https://www.npmjs.com/package/@isopodlabs/binary_libs)
+[![GitHub stars](https://img.shields.io/github/stars/adrianstephens/binary_libs.svg?style=social)](https://github.com/adrianstephens/binary_libs)
+[![License](https://img.shields.io/npm/l/@isopodlabs/binary_libs.svg)](LICENSE.txt)
 
 This package provides readers for various library formats, using the @isopodlabs/binary binary file loading library
 
 ## ☕ Support My Work  
-If you use this package, consider [buying me a tea](https://coff.ee/adrianstephens) to support future updates!  
+If you use this package, consider [buying me a cup of tea](https://coff.ee/adrianstephens) to support future updates!  
 
 ## Supported File Types
 

package/dist/CompoundDocument.d.ts

@@ -1,4 +1,4 @@
-import * as binary from '@isopodlabs/binary';
+import * as bin from '@isopodlabs/binary';
 declare class FAT {
     shift: number;
     sectors: Uint8Array;
@@ -18,7 +18,7 @@ declare class FAT {
     write_chain(chain: number[], source: Uint8Array): void;
     dirty_chain_part(chain: number[], offset: number): Uint8Array;
 }
-declare const Header_base: (new (s: binary._stream) => {
+declare const Header_base: (new (s: bin._stream) => {
     magic: bigint;
     id: Uint8Array;
     revision: number;
@@ -38,17 +38,17 @@ declare const Header_base: (new (s: binary._stream) => {
     num_difat: number;
     difat: Uint8Array;
 } & {
-    write(w: binary._stream): void;
+    write(w: bin._stream): void;
 }) & {
-    get: <X extends abstract new (...args: any) => any>(this: X, s: binary._stream) => InstanceType<X>;
-    put: (s: binary._stream, v: any) => void;
+    get: <X extends abstract new (...args: any) => any>(this: X, s: bin._stream) => InstanceType<X>;
+    put: (s: bin._stream, v: any) => void;
 };
 export declare class Header extends Header_base {
     sector_size(): number;
     use_mini(size: number): boolean;
     valid(): boolean;
 }
-declare const DirEntry_base: (new (s: binary._stream) => {
+declare const DirEntry_base: (new (s: bin._stream) => {
     name: string;
     name_size: number;
     type: number;
@@ -64,14 +64,14 @@ declare const DirEntry_base: (new (s: binary._stream) => {
     size: number;
     unused: number;
 } & {
-    write(w: binary._stream): void;
+    write(w: bin._stream): void;
 }) & {
-    get: <X extends abstract new (...args: any) => any>(this: X, s: binary._stream) => InstanceType<X>;
-    put: (s: binary._stream, v: any) => void;
+    get: <X extends abstract new (...args: any) => any>(this: X, s: bin._stream) => InstanceType<X>;
+    put: (s: bin._stream, v: any) => void;
 };
 declare class DirEntry extends DirEntry_base {
     index: number;
-    constructor(index: number, r: binary.stream);
+    constructor(index: number, r: bin.stream);
     load(fat: FAT): Uint8Array;
 }
 declare class Master {

package/dist/CompoundDocument.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Reader = exports.Header = void 0;
-const binary = __importStar(require("@isopodlabs/binary"));
+const bin = __importStar(require("@isopodlabs/binary"));
 const fs_1 = require("fs");
 class FAT {
     shift;
@@ -111,25 +111,25 @@ class FAT {
         return this.sectors.subarray((sector << this.shift) + (offset & ((1 << this.shift) - 1)));
     }
 }
-class Header extends binary.Class({
-    magic: binary.UINT64_BE,
-    id: binary.Buffer(16),
-    revision: binary.UINT16_LE,
-    version: binary.UINT16_LE,
-    byteorder: binary.UINT16_LE,
-    sector_shift: binary.UINT16_LE,
-    mini_shift: binary.UINT16_LE,
-    unused1: binary.SkipType(6),
-    num_directory: binary.UINT32_LE,
-    num_fat: binary.UINT32_LE,
-    first_directory: binary.UINT32_LE,
-    transaction: binary.SkipType(4), //must be 0
-    mini_cutoff: binary.UINT32_LE,
-    first_mini: binary.UINT32_LE,
-    num_mini: binary.UINT32_LE,
-    first_difat: binary.UINT32_LE,
-    num_difat: binary.UINT32_LE,
-    difat: binary.Buffer(436),
+class Header extends bin.Class({
+    magic: bin.UINT64_BE,
+    id: bin.Buffer(16),
+    revision: bin.UINT16_LE,
+    version: bin.UINT16_LE,
+    byteorder: bin.UINT16_LE,
+    sector_shift: bin.UINT16_LE,
+    mini_shift: bin.UINT16_LE,
+    unused1: bin.SkipType(6),
+    num_directory: bin.UINT32_LE,
+    num_fat: bin.UINT32_LE,
+    first_directory: bin.UINT32_LE,
+    transaction: bin.SkipType(4), //must be 0
+    mini_cutoff: bin.UINT32_LE,
+    first_mini: bin.UINT32_LE,
+    num_mini: bin.UINT32_LE,
+    first_difat: bin.UINT32_LE,
+    num_difat: bin.UINT32_LE,
+    difat: bin.Buffer(436),
 }) {
     sector_size() { return 1 << this.sector_shift; }
     use_mini(size) { return size < this.mini_cutoff; }
@@ -144,24 +144,26 @@ const TYPE = {
     Property: 4,
     RootStorage: 5,
 };
+/*
 const COLOUR = {
     RED: 0, BLACK: 1
-};
-class DirEntry extends binary.Class({
-    name: binary.StringType(64, 'utf16le'),
-    name_size: binary.UINT16_LE,
-    type: binary.UINT8,
-    colour: binary.UINT8,
-    left: binary.INT32_LE,
-    right: binary.INT32_LE,
-    root: binary.INT32_LE,
-    guid: binary.Buffer(16),
-    flags: binary.UINT32_LE,
-    creation: binary.UINT64_LE,
-    modification: binary.UINT64_LE,
-    sec_id: binary.INT32_LE,
-    size: binary.UINT32_LE,
-    unused: binary.UINT32_LE
+} as const;
+*/
+class DirEntry extends bin.Class({
+    name: bin.StringType(32, 'utf16le'),
+    name_size: bin.UINT16_LE,
+    type: bin.UINT8,
+    colour: bin.UINT8,
+    left: bin.INT32_LE,
+    right: bin.INT32_LE,
+    root: bin.INT32_LE,
+    guid: bin.Buffer(16),
+    flags: bin.UINT32_LE,
+    creation: bin.UINT64_LE,
+    modification: bin.UINT64_LE,
+    sec_id: bin.INT32_LE,
+    size: bin.UINT32_LE,
+    unused: bin.UINT32_LE
 }) {
     index;
     constructor(index, r) {
@@ -187,14 +189,14 @@ class Master {
         let num = header.num_difat;
         let m_size = 109 + (num << (shift - 2));
         this.difat = new Int32Array(m_size);
-        binary.utils.to8(this.difat).set(header.difat, 0);
+        bin.utils.to8(this.difat).set(header.difat, 0);
         let sect = header.first_difat;
         let p = 109 * 4;
         while (num--) {
             const data = sectors.subarray(sect << shift, (sect + 1) << shift);
             const end = data.length - 4;
             sect = new DataView(data.buffer).getUint32(end);
-            binary.utils.to8(this.difat).set(data.subarray(0, end), p);
+            bin.utils.to8(this.difat).set(data.subarray(0, end), p);
             p += end;
         }
         while (this.difat[m_size - 1] == -1 /* SecID.FREE */)
@@ -202,12 +204,12 @@ class Master {
         this.fat = new FAT(m_size << (shift - 2), shift, sectors);
         Array.from(this.difat.subarray(0, m_size)).forEach((id, index) => {
             const data = sectors.subarray(id << shift, (id + 1) << shift);
-            binary.utils.to8(this.fat.fat).set(data, index << shift);
+            bin.utils.to8(this.fat.fat).set(data, index << shift);
         });
-        const root = new DirEntry(0, new binary.stream(sectors.subarray(header.first_directory << shift)));
+        const root = new DirEntry(0, new bin.stream(sectors.subarray(header.first_directory << shift)));
         this.mini_chain = this.fat.get_chain(root.sec_id);
         this.mini_fat = new FAT(header.num_mini << (shift - 2), header.mini_shift, root.load(this.fat));
-        this.fat.read(header.first_mini, binary.utils.to8(this.mini_fat.fat));
+        this.fat.read(header.first_mini, bin.utils.to8(this.mini_fat.fat));
     }
     get_fat(mini) {
         return mini ? this.mini_fat : this.fat;
@@ -251,7 +253,7 @@ class Reader extends Master {
         super(sectors, header);
         this.entry_chain = this.fat.get_chain(header.first_directory);
         const dir_buff = this.fat.read_chain_alloc(this.entry_chain);
-        const r2 = new binary.stream(dir_buff);
+        const r2 = new bin.stream(dir_buff);
         for (let i = 0; i < dir_buff.length / 128; i++)
             this.entries[i] = new DirEntry(i, r2.seek(i * 128));
     }
@@ -292,7 +294,7 @@ class Reader extends Master {
             e.size = data.length;
             e.sec_id = chain[0];
             const dest = this.fat.dirty_chain_part(this.entry_chain, e.index * 128);
-            e.write(new binary.stream(dest));
+            e.write(new bin.stream(dest));
         }
         fat2.write_chain(chain, data);
     }

package/dist/arch.js

@@ -58,7 +58,7 @@ class ArchFile {
         while (s.remaining() > 0) {
             const member = binary.read(s, _HEADER);
             const data = s.read_buffer(member.size);
-            s.align(2);
+            binary.AlignType(2).get(s); //.align(2);
             if (member.name == '/') {
                 long_names = binary.utils.decodeText(data, 'utf8');
                 continue;
@@ -80,7 +80,7 @@ class ArchFile {
                         break;
                     }
                     case 2: { // microsoft symbols
-                        const member_offsets = binary.ArrayType(binary.INT32_LE, binary.INT32_LE).get(s2);
+                        const _offsets = binary.ArrayType(binary.INT32_LE, binary.INT32_LE).get(s2);
                         const indices = binary.ArrayType(binary.INT32_LE, binary.INT16_LE).get(s2);
                         member.name = 'Symbols2';
                         member.contents = indices.map(i => [

package/dist/clr.d.ts

@@ -1,4 +1,4 @@
-import * as binary from '@isopodlabs/binary';
+import * as bin from '@isopodlabs/binary';
 import * as pe from './pe';
 declare enum TABLE {
     Module = 0,
@@ -40,7 +40,7 @@ declare enum TABLE {
     MethodSpec = 43,
     GenericParamConstraint = 44
 }
-declare class clr_stream extends binary.stream {
+declare class clr_stream extends bin.stream {
     heaps: Uint8Array[];
     heap_sizes: number;
     table_counts: number[];
@@ -55,7 +55,7 @@ declare class clr_stream extends binary.stream {
 }
 declare const TableReaders: {
     0: {
-        generation: binary.TypeT<number>;
+        generation: bin.TypeT<number>;
         name: {
             get(s: clr_stream): string;
             put(_s: clr_stream, _v: number): void;
@@ -87,7 +87,7 @@ declare const TableReaders: {
         };
     };
     2: {
-        flags: binary.TypeT<number>;
+        flags: bin.TypeT<number>;
         name: {
             get(s: clr_stream): string;
             put(_s: clr_stream, _v: number): void;
@@ -107,7 +107,7 @@ declare const TableReaders: {
         };
     };
     4: {
-        flags: binary.TypeT<number>;
+        flags: bin.TypeT<number>;
         name: {
             get(s: clr_stream): string;
             put(_s: clr_stream, _v: number): void;
@@ -118,9 +118,9 @@ declare const TableReaders: {
         };
     };
     6: {
-        code: binary.TypeT<number>;
-        implflags: binary.TypeT<number>;
-        flags: binary.TypeT<number>;
+        code: bin.TypeT<number>;
+        implflags: bin.TypeT<number>;
+        flags: bin.TypeT<number>;
         name: {
             get(s: clr_stream): string;
             put(_s: clr_stream, _v: number): void;
@@ -134,8 +134,8 @@ declare const TableReaders: {
         };
     };
     8: {
-        flags: binary.TypeT<number>;
-        sequence: binary.TypeT<number>;
+        flags: bin.TypeT<number>;
+        sequence: bin.TypeT<number>;
         name: {
             get(s: clr_stream): string;
             put(_s: clr_stream, _v: number): void;
@@ -163,7 +163,7 @@ declare const TableReaders: {
         };
     };
     11: {
-        type: binary.TypeT<number>;
+        type: bin.TypeT<number>;
         parent: {
             get(s: clr_stream): number;
         };
@@ -194,7 +194,7 @@ declare const TableReaders: {
         };
     };
     14: {
-        action: binary.TypeT<number>;
+        action: bin.TypeT<number>;
         parent: {
             get(s: clr_stream): number;
         };
@@ -204,14 +204,14 @@ declare const TableReaders: {
         };
     };
     15: {
-        packing_size: binary.TypeT<number>;
-        class_size: binary.TypeT<number>;
+        packing_size: bin.TypeT<number>;
+        class_size: bin.TypeT<number>;
         parent: {
             get(s: clr_stream): number;
         };
     };
     16: {
-        offset: binary.TypeT<number>;
+        offset: bin.TypeT<number>;
         field: {
             get(s: clr_stream): number;
         };
@@ -231,7 +231,7 @@ declare const TableReaders: {
         };
     };
     20: {
-        flags: binary.TypeT<number>;
+        flags: bin.TypeT<number>;
         name: {
             get(s: clr_stream): string;
             put(_s: clr_stream, _v: number): void;
@@ -249,7 +249,7 @@ declare const TableReaders: {
         };
     };
     23: {
-        flags: binary.TypeT<number>;
+        flags: bin.TypeT<number>;
         name: {
             get(s: clr_stream): string;
             put(_s: clr_stream, _v: number): void;
@@ -260,7 +260,7 @@ declare const TableReaders: {
         };
     };
     24: {
-        flags: binary.TypeT<number>;
+        flags: bin.TypeT<number>;
         method: {
             get(s: clr_stream): number;
         };
@@ -292,7 +292,7 @@ declare const TableReaders: {
         };
     };
     28: {
-        flags: binary.TypeT<number>;
+        flags: bin.TypeT<number>;
         member_forwarded: {
             get(s: clr_stream): number;
         };
@@ -305,18 +305,18 @@ declare const TableReaders: {
         };
     };
     29: {
-        rva: binary.TypeT<number>;
+        rva: bin.TypeT<number>;
         field: {
             get(s: clr_stream): number;
         };
     };
     32: {
-        hashalg: binary.TypeT<number>;
-        major: binary.TypeT<number>;
-        minor: binary.TypeT<number>;
-        build: binary.TypeT<number>;
-        rev: binary.TypeT<number>;
-        flags: binary.TypeT<number>;
+        hashalg: bin.TypeT<number>;
+        major: bin.TypeT<number>;
+        minor: bin.TypeT<number>;
+        build: bin.TypeT<number>;
+        rev: bin.TypeT<number>;
+        flags: bin.TypeT<number>;
         publickey: {
             get(s: clr_stream): Uint8Array;
             put(_s: clr_stream, _v: number): void;
@@ -331,19 +331,19 @@ declare const TableReaders: {
         };
     };
     33: {
-        processor: binary.TypeT<number>;
+        processor: bin.TypeT<number>;
     };
     34: {
-        platform: binary.TypeT<number>;
-        minor: binary.TypeT<number>;
-        major: binary.TypeT<number>;
+        platform: bin.TypeT<number>;
+        minor: bin.TypeT<number>;
+        major: bin.TypeT<number>;
     };
     35: {
-        major: binary.TypeT<number>;
-        minor: binary.TypeT<number>;
-        build: binary.TypeT<number>;
-        rev: binary.TypeT<number>;
-        flags: binary.TypeT<number>;
+        major: bin.TypeT<number>;
+        minor: bin.TypeT<number>;
+        build: bin.TypeT<number>;
+        rev: bin.TypeT<number>;
+        flags: bin.TypeT<number>;
         publickey: {
             get(s: clr_stream): Uint8Array;
             put(_s: clr_stream, _v: number): void;
@@ -362,21 +362,21 @@ declare const TableReaders: {
         };
     };
     36: {
-        processor: binary.TypeT<number>;
+        processor: bin.TypeT<number>;
         assembly: {
             get(s: clr_stream): number;
         };
     };
     37: {
-        platform: binary.TypeT<number>;
-        major: binary.TypeT<number>;
-        minor: binary.TypeT<number>;
+        platform: bin.TypeT<number>;
+        major: bin.TypeT<number>;
+        minor: bin.TypeT<number>;
         assembly: {
             get(s: clr_stream): number;
         };
     };
     38: {
-        flags: binary.TypeT<number>;
+        flags: bin.TypeT<number>;
         name: {
             get(s: clr_stream): string;
             put(_s: clr_stream, _v: number): void;
@@ -387,8 +387,8 @@ declare const TableReaders: {
         };
     };
     39: {
-        flags: binary.TypeT<number>;
-        typedef_id: binary.TypeT<number>;
+        flags: bin.TypeT<number>;
+        typedef_id: bin.TypeT<number>;
         name: {
             get(s: clr_stream): string;
             put(_s: clr_stream, _v: number): void;
@@ -402,8 +402,8 @@ declare const TableReaders: {
         };
     };
     40: {
-        data: binary.TypeT<number>;
-        flags: binary.TypeT<number>;
+        data: bin.TypeT<number>;
+        flags: bin.TypeT<number>;
         name: {
             get(s: clr_stream): string;
             put(_s: clr_stream, _v: number): void;
@@ -421,8 +421,8 @@ declare const TableReaders: {
         };
     };
     42: {
-        number: binary.TypeT<number>;
-        flags: binary.TypeT<number>;
+        number: bin.TypeT<number>;
+        flags: bin.TypeT<number>;
         owner: {
             get(s: clr_stream): number;
         };
@@ -460,14 +460,32 @@ export declare class CLR {
         cb: number;
         MajorRuntimeVersion: number;
         MinorRuntimeVersion: number;
-        MetaData: never;
+        MetaData: {
+            VirtualAddress: number;
+            Size: number;
+        };
         Flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
         EntryPoint: number;
-        Resources: never;
-        StrongNameSignature: never;
-        CodeManagerTable: never;
-        VTableFixups: never;
-        ExportAddressTableJumps: never;
+        Resources: {
+            VirtualAddress: number;
+            Size: number;
+        };
+        StrongNameSignature: {
+            VirtualAddress: number;
+            Size: number;
+        };
+        CodeManagerTable: {
+            VirtualAddress: number;
+            Size: number;
+        };
+        VTableFixups: {
+            VirtualAddress: number;
+            Size: number;
+        };
+        ExportAddressTableJumps: {
+            VirtualAddress: number;
+            Size: number;
+        };
     };
     table_info: {
         Reserved: number;
@@ -482,12 +500,15 @@ export declare class CLR {
     tables: Record<TABLE, Table>;
     Resources?: Uint8Array;
     constructor(pe: pe.PE, clr_data: Uint8Array);
-    getEntry<T extends TABLE>(t: T, i: number): binary.ReadType<typeof TableReaders[T]>;
+    getEntry<T extends TABLE>(t: T, i: number): bin.ReadType<typeof TableReaders[T]>;
     getEntry(t: TABLE, i: number): any;
-    getTable<T extends TABLE>(t: T): binary.ReadType<typeof TableReaders[T]>[];
+    getTable<T extends TABLE>(t: T): bin.ReadType<typeof TableReaders[T]>[];
     getTable(t: TABLE): any;
     getResources(block: string): Record<string, any> | undefined;
     getResource(block: string, name: string): any;
     allResources(): any;
 }
+export declare function ReadCLR(pe: pe.PE, data: bin.MappedMemory): {
+    [k: string]: any;
+};
 export {};