@isopodlabs/binary_libs 0.0.1

package/dist/binary_helpers.d.ts

@@ -0,0 +1,69 @@
+export declare const isLittleEndian: boolean;
+export declare function isPow2(n: number): boolean;
+export declare function lowestSet(n: number): number;
+export declare function lowestSet(n: bigint): bigint;
+export declare function contiguousBits(n: number): boolean;
+export declare function highestSetIndex32(n: number): number;
+export declare function highestSetIndex(n: number | bigint): number;
+export declare function lowestSetIndex32(n: number): number;
+export declare function lowestSetIndex(n: number | bigint): number;
+export declare function clearLowest(n: number | bigint): number | bigint;
+export declare function bitCount(n: number | bigint): number;
+export declare function splitBinary(n: number | bigint, splits: number[]): number[] | bigint[];
+export interface memory {
+    length?: bigint;
+    get(address: bigint, len: number): Uint8Array | Promise<Uint8Array>;
+}
+interface arrayBuffer {
+    length: number;
+    buffer: ArrayBuffer;
+    byteLength: number;
+    byteOffset: number;
+    slice(begin: number, end?: number): arrayBuffer;
+    [n: number]: number;
+}
+export declare const enum MEM {
+    NONE = 0,
+    READ = 1,
+    WRITE = 2,
+    EXECUTE = 4,
+    RELATIVE = 8
+}
+export declare class MappedMemory {
+    data: Uint8Array;
+    address: number;
+    flags: number;
+    constructor(data: Uint8Array, address: number, flags: number);
+    resolveAddress(base: number): number;
+    slice(begin: number, end?: number): MappedMemory;
+    at(begin: number, length?: number): MappedMemory;
+}
+export declare function to8(arg: arrayBuffer): Uint8Array;
+export declare function to8(arg?: arrayBuffer): Uint8Array | undefined;
+export declare function to16(arg: arrayBuffer, be?: boolean): Uint16Array;
+export declare function to16(arg?: arrayBuffer, be?: boolean): Uint16Array | undefined;
+export declare function to16s(arg: arrayBuffer, be?: boolean): Int16Array;
+export declare function to16s(arg?: arrayBuffer, be?: boolean): Int16Array | undefined;
+export declare function to32(arg: arrayBuffer, be?: boolean): Uint32Array;
+export declare function to32(arg?: arrayBuffer, be?: boolean): Uint32Array | undefined;
+export declare function to32s(arg: arrayBuffer, be?: boolean): Int32Array;
+export declare function to32s(arg?: arrayBuffer, be?: boolean): Int32Array | undefined;
+export declare function to64(arg: arrayBuffer, be?: boolean): BigUint64Array;
+export declare function to64(arg?: arrayBuffer, be?: boolean): BigUint64Array | undefined;
+export declare function to64s(arg: arrayBuffer, be?: boolean): BigInt64Array;
+export declare function to64s(arg?: arrayBuffer, be?: boolean): BigInt64Array | undefined;
+export declare function getBigUint(dv: DataView, len: number, littleEndian?: boolean): bigint;
+export declare function getBigInt(dv: DataView, len: number, littleEndian?: boolean): bigint;
+export declare function putBigUint(dv: DataView, v: bigint, len: number, littleEndian?: boolean): void;
+export declare function getUint(dv: DataView, len: number, littleEndian?: boolean): number;
+export declare function getInt(dv: DataView, len: number, littleEndian?: boolean): number;
+export declare function putUint(dv: DataView, v: number, len: number, littleEndian?: boolean): void;
+export declare function stringCode(s: string): number;
+export declare function stringCodeBig(s: string): bigint;
+export type TextEncoding = 'utf8' | 'utf16le' | 'utf16be';
+export declare function encodeTextInto(str: string, into: Uint8Array, encoding: TextEncoding, bom?: boolean): void;
+export declare function encodeText(str: string, encoding?: TextEncoding, bom?: boolean): Uint8Array;
+export declare function decodeText(buf: Uint8Array, encoding?: TextEncoding): string;
+export declare function decodeTextTo0(buf: Uint8Array | undefined, encoding?: TextEncoding): string;
+export declare function getTextEncoding(bytes: Uint8Array): TextEncoding;
+export {};

package/dist/binary_helpers.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTextEncoding = exports.decodeTextTo0 = exports.decodeText = exports.encodeText = exports.encodeTextInto = exports.stringCodeBig = exports.stringCode = exports.putUint = exports.getInt = exports.getUint = exports.putBigUint = exports.getBigInt = exports.getBigUint = exports.to64s = exports.to64 = exports.to32s = exports.to32 = exports.to16s = exports.to16 = exports.to8 = exports.MappedMemory = exports.splitBinary = exports.bitCount = exports.clearLowest = exports.lowestSetIndex = exports.lowestSetIndex32 = exports.highestSetIndex = exports.highestSetIndex32 = exports.contiguousBits = exports.lowestSet = exports.isPow2 = exports.isLittleEndian = void 0;
+//-----------------------------------------------------------------------------
+//	bit stuff
+//-----------------------------------------------------------------------------
+exports.isLittleEndian = (new Uint8Array(new Uint16Array([0x1234]).buffer))[0] === 0x34;
+function isPow2(n) {
+    return (n & (n - 1)) === 0;
+}
+exports.isPow2 = isPow2;
+function lowestSet(n) {
+    return typeof n === 'bigint' ? n & -n : n & -n;
+}
+exports.lowestSet = lowestSet;
+function contiguousBits(n) {
+    return isPow2(n + lowestSet(n));
+}
+exports.contiguousBits = contiguousBits;
+function highestSetIndex32(n) {
+    return 31 - Math.clz32(n);
+}
+exports.highestSetIndex32 = highestSetIndex32;
+function highestSetIndex(n) {
+    return typeof n === 'bigint' || n > 2 ** 32
+        ? n.toString(2).length - 1
+        : highestSetIndex32(n);
+}
+exports.highestSetIndex = highestSetIndex;
+function lowestSetIndex32(n) {
+    return n ? 31 - Math.clz32(n & -n) : 32;
+}
+exports.lowestSetIndex32 = lowestSetIndex32;
+function lowestSetIndex(n) {
+    if (typeof n === 'bigint') {
+        const i = Number(n & 0xffffffffn);
+        return i ? lowestSetIndex32(i) : 32 + lowestSetIndex(n >> 32n);
+    }
+    return lowestSetIndex32(n);
+}
+exports.lowestSetIndex = lowestSetIndex;
+function clearLowest(n) {
+    return typeof n === 'bigint'
+        ? n & (n - 1n)
+        : n & (n - 1);
+}
+exports.clearLowest = clearLowest;
+function bitCount32(n) {
+    n = n - ((n >> 1) & 0x55555555);
+    n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
+    return ((n + (n >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
+}
+function bitCount(n) {
+    return typeof n === 'bigint'
+        ? bitCount32(Number(n & 0xffffffffn)) + bitCount(n >> 32n)
+        : bitCount32(n);
+}
+exports.bitCount = bitCount;
+function splitBinary(n, splits) {
+    let b = 0;
+    return typeof n === 'bigint'
+        ? splits.map(s => {
+            const r = (n >> BigInt(b)) & ((1n << BigInt(s)) - 1n);
+            b += s;
+            return r;
+        })
+        : splits.map(s => {
+            const r = (n >> b) & ((1 << s) - 1);
+            b += s;
+            return r;
+        });
+}
+exports.splitBinary = splitBinary;
+class MappedMemory {
+    data;
+    address;
+    flags;
+    constructor(data, address, flags) {
+        this.data = data;
+        this.address = address;
+        this.flags = flags;
+    }
+    resolveAddress(base) { return this.address; }
+    slice(begin, end) { return new MappedMemory(this.data.subarray(begin, end), this.address + begin, this.flags); }
+    at(begin, length) { return this.slice(begin - this.address, length && (begin - this.address + length)); }
+}
+exports.MappedMemory = MappedMemory;
+function pairSwap(a) {
+    for (let i = 0; i < a.length; i += 2)
+        [a[i], a[i + 1]] = [a[i + 1], a[i]];
+}
+function fixEndian16(a, be) {
+    if (be === exports.isLittleEndian) {
+        pairSwap(new Uint8Array(a));
+    }
+    return a;
+}
+function fixEndian32(a, be) {
+    if (be === exports.isLittleEndian) {
+        pairSwap(new Uint8Array(a));
+        pairSwap(new Uint16Array(a));
+    }
+    return a;
+}
+function fixEndian64(a, be) {
+    if (be === exports.isLittleEndian) {
+        pairSwap(new Uint8Array(a));
+        pairSwap(new Uint16Array(a));
+        pairSwap(new Uint32Array(a));
+    }
+    return a;
+}
+function to8(arg) {
+    return arg && new Uint8Array(arg.buffer, arg.byteOffset, arg.byteLength);
+}
+exports.to8 = to8;
+function dupBuffer(arg) {
+    const buffer = new ArrayBuffer(arg.byteLength);
+    (new Uint8Array(buffer)).set(new Uint8Array(arg.buffer, arg.byteOffset, arg.byteLength));
+    return buffer;
+}
+function to16(arg, be) { return arg && new Uint16Array(fixEndian16(dupBuffer(arg), be)); }
+exports.to16 = to16;
+function to16s(arg, be) { return arg && new Int16Array(fixEndian16(dupBuffer(arg), be)); }
+exports.to16s = to16s;
+function to32(arg, be) { return arg && new Uint32Array(fixEndian32(dupBuffer(arg), be)); }
+exports.to32 = to32;
+function to32s(arg, be) { return arg && new Int32Array(fixEndian32(dupBuffer(arg), be)); }
+exports.to32s = to32s;
+function to64(arg, be) { return arg && new BigUint64Array(fixEndian64(dupBuffer(arg), be)); }
+exports.to64 = to64;
+function to64s(arg, be) { return arg && new BigInt64Array(fixEndian64(dupBuffer(arg), be)); }
+exports.to64s = to64s;
+//-----------------------------------------------------------------------------
+//	numbers
+//-----------------------------------------------------------------------------
+function getBigUint(dv, len, littleEndian) {
+    let result = 0n;
+    if (littleEndian) {
+        let offset = len;
+        while (offset >= 4) {
+            offset -= 4;
+            result = (result << 32n) | BigInt(dv.getUint32(offset, true));
+        }
+        if (len & 2) {
+            offset -= 2;
+            result = (result << 16n) | BigInt(dv.getUint16(offset, true));
+        }
+        if (len & 1)
+            result = (result << 8n) | BigInt(dv.getUint8(--offset));
+    }
+    else {
+        let offset = 0;
+        while (offset + 4 <= len) {
+            result = (result << 32n) | BigInt(dv.getUint32(offset));
+            offset += 4;
+        }
+        if (len & 2) {
+            result = (result << 16n) | BigInt(dv.getUint16(offset));
+            offset += 2;
+        }
+        if (len & 1)
+            result = (result << 8n) | BigInt(dv.getUint8(offset));
+    }
+    return result;
+}
+exports.getBigUint = getBigUint;
+function getBigInt(dv, len, littleEndian) {
+    const v = getBigUint(dv, len, littleEndian);
+    const s = 1n << BigInt(len * 8 - 1);
+    return v < s ? v : v - s - s;
+}
+exports.getBigInt = getBigInt;
+function putBigUint(dv, v, len, littleEndian) {
+    if (littleEndian) {
+        let offset = 0;
+        while (offset + 4 <= len) {
+            dv.setUint32(offset, Number(v & 0xffffffffn), true);
+            v >>= 32n;
+            offset += 4;
+        }
+        if (len & 2) {
+            dv.setUint16(offset, Number(v & 0xffffn), true);
+            v >>= 16n;
+            offset += 2;
+        }
+        if (len & 1)
+            dv.setUint8(offset, Number(v & 0xffn));
+    }
+    else {
+        let offset = len;
+        while (offset >= 4) {
+            offset -= 4;
+            dv.setUint32(offset, Number(v & 0xffffffffn));
+            v >>= 32n;
+        }
+        if (len & 2) {
+            offset -= 2;
+            dv.setUint16(offset, Number(v & 0xffffn));
+            v >>= 16n;
+        }
+        if (len & 1)
+            dv.setUint8(--offset, Number(v & 0xffn));
+    }
+}
+exports.putBigUint = putBigUint;
+// get/put 1-7 byte integers from/to DavaView (7 bytes will lose precision)
+function getUint(dv, len, littleEndian) {
+    let result = 0;
+    if (littleEndian) {
+        if (len & 1)
+            result = dv.getUint8(len & 6);
+        if (len & 2)
+            result = (result << 16) | dv.getUint16(len & 4, true);
+        if (len & 4)
+            result = result * (2 ** 32) + dv.getUint32(0, true);
+    }
+    else {
+        if (len & 1)
+            result = dv.getUint8(0);
+        if (len & 2)
+            result = (result << 16) | dv.getUint16(len & 1);
+        if (len & 4)
+            result = result * (2 ** 32) + dv.getUint32(len & 3);
+    }
+    return result;
+}
+exports.getUint = getUint;
+function getInt(dv, len, littleEndian) {
+    const v = getUint(dv, len, littleEndian);
+    const s = 1 << len * 8 - 1;
+    return v < s ? v : v - s - s;
+}
+exports.getInt = getInt;
+function putUint(dv, v, len, littleEndian) {
+    if (littleEndian) {
+        if (len & 4) {
+            dv.setUint32(0, v & 0xffffffff, true);
+            v /= 2 ** 32;
+        }
+        if (len & 2) {
+            dv.setUint16(len & 4, v & 0xffff, true);
+            v >>= 16;
+        }
+        if (len & 1)
+            dv.setUint8(len & 6, v & 0xff);
+    }
+    else {
+        if (len & 4) {
+            dv.setUint32(len & 3, v & 0xffffffff);
+            v /= 2 ** 32;
+        }
+        if (len & 2) {
+            dv.setUint16(len & 1, v & 0xffff);
+            v >>= 16;
+        }
+        if (len & 1)
+            dv.setUint8(0, v & 0xff);
+    }
+}
+exports.putUint = putUint;
+//-----------------------------------------------------------------------------
+//	text
+//-----------------------------------------------------------------------------
+function stringCode(s) {
+    let r = 0;
+    for (let i = 0; i < s.length; i++)
+        r += s.charCodeAt(i) << (i * 8);
+    return r;
+}
+exports.stringCode = stringCode;
+function stringCodeBig(s) {
+    let r = 0n;
+    for (let i = 0; i < s.length; i++)
+        r += BigInt(s.charCodeAt(i)) << BigInt(i * 8);
+    return r;
+}
+exports.stringCodeBig = stringCodeBig;
+function encodeText16Into(str, into, be) {
+    const len = str.length;
+    const view = new Uint16Array(into);
+    for (let i = 0; i < len; i++)
+        view[i] = str.charCodeAt(i);
+    if (be === exports.isLittleEndian)
+        pairSwap(into);
+}
+function encodeTextInto(str, into, encoding, bom = false) {
+    if (bom)
+        str = String.fromCharCode(0xfeff) + str;
+    if (encoding === 'utf8')
+        into.set(Buffer.from(str, encoding));
+    else
+        encodeText16Into(str, into, encoding === 'utf16be');
+}
+exports.encodeTextInto = encodeTextInto;
+function encodeText(str, encoding = 'utf8', bom = false) {
+    if (bom)
+        str = String.fromCharCode(0xfeff) + str;
+    if (encoding === 'utf8')
+        return Buffer.from(str, encoding);
+    const buf = new Uint8Array(str.length * 2);
+    encodeText16Into(str, buf, encoding === 'utf16be');
+    return buf;
+}
+exports.encodeText = encodeText;
+function decodeText(buf, encoding = 'utf8') {
+    if (encoding === 'utf8')
+        return new TextDecoder(encoding).decode(buf);
+    const view = to16(buf, encoding === 'utf16be');
+    let result = '';
+    for (let i = view[0] === 0xfeff ? 1 : 0; i < view.length; i += 1024)
+        result += String.fromCharCode(...view.subarray(i, i + 1024));
+    return result;
+}
+exports.decodeText = decodeText;
+function decodeTextTo0(buf, encoding = 'utf8') {
+    return buf ? decodeText(buf.subarray(0, encoding === 'utf8' ? buf.indexOf(0) : to16(buf).indexOf(0) * 2), encoding) : '';
+}
+exports.decodeTextTo0 = decodeTextTo0;
+function getTextEncoding(bytes) {
+    return bytes.length >= 3 && bytes[0] === 0xEF && bytes[1] === 0xBB && bytes[2] === 0xBF ? 'utf8'
+        : bytes.length >= 2 && bytes[0] === 0xFE && bytes[1] === 0xFF ? 'utf16be'
+            : bytes.length >= 2 && bytes[0] === 0xFF && bytes[1] === 0xFE ? 'utf16le'
+                : bytes.length >= 2 && bytes[0] === 0 && bytes[1] !== 0 ? 'utf16be'
+                    : bytes.length >= 2 && bytes[0] !== 0 && bytes[1] === 0 ? 'utf16le'
+                        : 'utf8';
+}
+exports.getTextEncoding = getTextEncoding;

package/dist/clr.d.ts

@@ -0,0 +1,63 @@
+import * as pe from './pe';
+declare enum TABLE {
+    Module = 0,
+    TypeRef = 1,
+    TypeDef = 2,
+    Field = 4,
+    MethodDef = 6,
+    Param = 8,
+    InterfaceImpl = 9,
+    MemberRef = 10,
+    Constant = 11,
+    CustomAttribute = 12,
+    FieldMarshal = 13,
+    DeclSecurity = 14,
+    ClassLayout = 15,
+    FieldLayout = 16,
+    StandAloneSig = 17,
+    EventMap = 18,
+    Event = 20,
+    PropertyMap = 21,
+    Property = 23,
+    MethodSemantics = 24,
+    MethodImpl = 25,
+    ModuleRef = 26,
+    TypeSpec = 27,
+    ImplMap = 28,
+    FieldRVA = 29,
+    Assembly = 32,
+    AssemblyProcessor = 33,
+    AssemblyOS = 34,
+    AssemblyRef = 35,
+    AssemblyRefProcessor = 36,
+    AssemblyRefOS = 37,
+    File = 38,
+    ExportedType = 39,
+    ManifestResource = 40,
+    NestedClass = 41,
+    GenericParam = 42,
+    MethodSpec = 43,
+    GenericParamConstraint = 44
+}
+interface Table {
+    count: number;
+    size: number;
+    offset: number;
+}
+export declare class CLR {
+    header: any;
+    table_info: any;
+    heaps: Uint8Array[];
+    tables: {
+        [K in TABLE]?: Table;
+    };
+    raw?: Uint8Array;
+    Resources?: Uint8Array;
+    constructor(pe: pe.PE, clr_data: Uint8Array);
+    getEntry(t: TABLE, i: number): any;
+    getTable(t: TABLE): any[] | undefined;
+    getResources(block: string): Record<string, any> | undefined;
+    getResource(block: string, name: string): any;
+    allResources(): {} | undefined;
+}
+export {};