@isopodlabs/binary_libs 0.1.1 → 0.1.2

package/dist/CompoundDocument.d.ts

@@ -0,0 +1,129 @@
+import * as binary from '@isopodlabs/binary';
+declare class FAT {
+    shift: number;
+    sectors: Uint8Array;
+    fat: Int32Array;
+    freed: number[];
+    dirty_fat: Set<number>;
+    dirty_sec: Set<number>;
+    constructor(size: number, shift: number, sectors: Uint8Array);
+    private free;
+    private alloc;
+    get_chain(id: number): number[];
+    resize_chain(chain: number[], data_size: number): void;
+    clear_dirty(): void;
+    read_chain(chain: number[], dest: Uint8Array): void;
+    read_chain_alloc(chain: number[]): Uint8Array;
+    read(id: number, dest: Uint8Array): void;
+    write_chain(chain: number[], source: Uint8Array): void;
+    dirty_chain_part(chain: number[], offset: number): Uint8Array;
+}
+declare const Header_base: (new (s: binary._stream) => {
+    magic: bigint;
+    id: Uint8Array;
+    revision: number;
+    version: number;
+    byteorder: number;
+    sector_shift: number;
+    mini_shift: number;
+    unused1: void;
+    num_directory: number;
+    num_fat: number;
+    first_directory: number;
+    transaction: void;
+    mini_cutoff: number;
+    first_mini: number;
+    num_mini: number;
+    first_difat: number;
+    num_difat: number;
+    difat: Uint8Array;
+} & {
+    write(w: binary._stream): void;
+}) & {
+    get: (s: binary._stream) => {
+        magic: bigint;
+        id: Uint8Array;
+        revision: number;
+        version: number;
+        byteorder: number;
+        sector_shift: number;
+        mini_shift: number;
+        unused1: void;
+        num_directory: number;
+        num_fat: number;
+        first_directory: number;
+        transaction: void;
+        mini_cutoff: number;
+        first_mini: number;
+        num_mini: number;
+        first_difat: number;
+        num_difat: number;
+        difat: Uint8Array;
+    };
+    put: (s: binary._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) => {
+    name: string;
+    name_size: number;
+    type: number;
+    colour: number;
+    left: number;
+    right: number;
+    root: number;
+    guid: Uint8Array;
+    flags: number;
+    creation: bigint;
+    modification: bigint;
+    sec_id: number;
+    size: number;
+    unused: number;
+} & {
+    write(w: binary._stream): void;
+}) & {
+    get: (s: binary._stream) => {
+        name: string;
+        name_size: number;
+        type: number;
+        colour: number;
+        left: number;
+        right: number;
+        root: number;
+        guid: Uint8Array;
+        flags: number;
+        creation: bigint;
+        modification: bigint;
+        sec_id: number;
+        size: number;
+        unused: number;
+    };
+    put: (s: binary._stream, v: any) => void;
+};
+declare class DirEntry extends DirEntry_base {
+    index: number;
+    constructor(index: number, r: binary.stream);
+    load(fat: FAT): Uint8Array;
+}
+declare class Master {
+    header: Header;
+    difat: Int32Array;
+    fat: FAT;
+    mini_fat: FAT;
+    mini_chain: number[];
+    constructor(sectors: Uint8Array, header: Header);
+    get_fat(mini: boolean): FAT;
+    flush(filename: string): Promise<void>;
+}
+export declare class Reader extends Master {
+    entries: DirEntry[];
+    private entry_chain;
+    constructor(sectors: Uint8Array, header: Header);
+    find(name: string, i?: number): DirEntry | undefined;
+    read(e: DirEntry): Uint8Array;
+    write(e: DirEntry, data: Uint8Array): void;
+}
+export {};

package/dist/CompoundDocument.js

@@ -0,0 +1,300 @@
+"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.Reader = exports.Header = void 0;
+const binary = __importStar(require("@isopodlabs/binary"));
+const fs_1 = require("fs");
+class FAT {
+    shift;
+    sectors;
+    fat;
+    freed = [];
+    dirty_fat = new Set();
+    dirty_sec = new Set();
+    constructor(size, shift, sectors) {
+        this.shift = shift;
+        this.sectors = sectors;
+        this.fat = new Int32Array(size);
+    }
+    free(id) {
+        this.freed.push(id);
+        this.fat[id] = -1 /* SecID.FREE */;
+        this.dirty_fat.add(id >> (this.shift - 2));
+    }
+    alloc(prev) {
+        if (!this.freed.length) {
+            this.fat.forEach((v, i) => {
+                if (v === -1 /* SecID.FREE */)
+                    this.freed.push(i);
+            });
+        }
+        const id = this.freed.length ? this.freed.pop() : this.fat.length;
+        this.fat[prev] = id;
+        this.dirty_fat.add(id >> (this.shift - 2));
+        return id;
+    }
+    get_chain(id) {
+        const chain = [];
+        while (id != -2 /* SecID.ENDOFCHAIN */) {
+            chain.push(id);
+            id = this.fat[id];
+        }
+        return chain;
+    }
+    resize_chain(chain, data_size) {
+        const size = (data_size + (1 << this.shift) - 1) >> this.shift;
+        while (chain.length > size)
+            this.free(chain.pop());
+        if (size) {
+            let last = chain[size - 1];
+            while (chain.length < size)
+                chain.push(last = this.alloc(last));
+            if (this.fat[last] !== -2 /* SecID.ENDOFCHAIN */) {
+                this.fat[last] = -2 /* SecID.ENDOFCHAIN */;
+                this.dirty_fat.add(last >> (this.shift - 2));
+            }
+        }
+        else {
+            chain.push(-2 /* SecID.ENDOFCHAIN */);
+        }
+    }
+    clear_dirty() {
+        this.dirty_fat.clear();
+        this.dirty_sec.clear();
+    }
+    read_chain(chain, dest) {
+        chain.forEach((id, index) => {
+            const id2 = id << this.shift;
+            const index2 = index << this.shift;
+            dest.set(this.sectors.subarray(id2, id2 + Math.min(dest.length - index2)), index2);
+        });
+    }
+    read_chain_alloc(chain) {
+        const dest = new Uint8Array(chain.length << this.shift);
+        this.read_chain(chain, dest);
+        return dest;
+    }
+    read(id, dest) {
+        this.read_chain(this.get_chain(id), dest);
+    }
+    write_chain(chain, source) {
+        chain.forEach((id, index) => {
+            this.sectors.set(source.subarray(index << this.shift, (index + 1) << this.shift), id << this.shift);
+            this.dirty_sec.add(id);
+        });
+    }
+    dirty_chain_part(chain, offset) {
+        const sector = chain[offset >> this.shift];
+        this.dirty_sec.add(sector);
+        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),
+}) {
+    sector_size() { return 1 << this.sector_shift; }
+    use_mini(size) { return size < this.mini_cutoff; }
+    valid() { return this.magic == 0xd0cf11e0a1b11ae1n; }
+}
+exports.Header = Header;
+const TYPE = {
+    Empty: 0,
+    UserStorage: 1,
+    UserStream: 2,
+    LockBytes: 3,
+    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
+}) {
+    index;
+    constructor(index, r) {
+        super(r);
+        this.index = index;
+        this.name = this.name.substring(0, this.name_size / 2 - 1);
+    }
+    load(fat) {
+        const data = new Uint8Array(this.size);
+        fat.read(this.sec_id, data);
+        return data;
+    }
+}
+class Master {
+    header;
+    difat;
+    fat;
+    mini_fat;
+    mini_chain;
+    constructor(sectors, header) {
+        this.header = header;
+        const shift = header.sector_shift;
+        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);
+        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);
+            p += end;
+        }
+        while (this.difat[m_size - 1] == -1 /* SecID.FREE */)
+            --m_size;
+        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);
+        });
+        const root = new DirEntry(0, new binary.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));
+    }
+    get_fat(mini) {
+        return mini ? this.mini_fat : this.fat;
+    }
+    async flush(filename) {
+        const dirty = new Set(this.fat.dirty_sec);
+        function mark_dirty_shift(entries, translate, shift) {
+            for (const i of entries)
+                dirty.add(translate[i >> shift]);
+        }
+        const mini_extra = this.fat.shift - this.header.mini_shift;
+        mark_dirty_shift(this.fat.dirty_fat.keys(), Array.from(this.difat), 0);
+        mark_dirty_shift(this.mini_fat.dirty_sec, this.mini_chain, mini_extra);
+        mark_dirty_shift(this.mini_fat.dirty_fat.keys(), this.fat.get_chain(this.header.first_mini), mini_extra);
+        if (!dirty.size)
+            return;
+        let fileHandle;
+        try {
+            fileHandle = await fs_1.promises.open(filename, 'r+');
+            const ss = 1 << this.fat.shift;
+            for (const i of dirty.keys()) {
+                const position = i * ss;
+                await fileHandle.write(this.fat.sectors, position, ss, position + ss);
+            }
+            this.fat.clear_dirty();
+            this.mini_fat.clear_dirty();
+        }
+        catch (error) {
+            console.error('An error occurred:', error);
+        }
+        finally {
+            if (fileHandle)
+                await fileHandle.close();
+        }
+    }
+}
+class Reader extends Master {
+    entries = [];
+    entry_chain;
+    constructor(sectors, header) {
+        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);
+        for (let i = 0; i < dir_buff.length / 128; i++)
+            this.entries[i] = new DirEntry(i, r2.seek(i * 128));
+    }
+    find(name, i = 0) {
+        const stack = [];
+        let sp = 0;
+        for (;;) {
+            const e = this.entries[i];
+            if (e.name == name)
+                return e;
+            if (e.type == TYPE.RootStorage)
+                stack[sp++] = e.root;
+            if (e.right != -1)
+                stack[sp++] = e.right;
+            i = e.left;
+            if (i == -1) {
+                if (sp === 0)
+                    return undefined;
+                i = stack[--sp];
+            }
+        }
+    }
+    read(e) {
+        const mini = this.header.use_mini(e.size);
+        const fat = this.get_fat(mini);
+        return e.load(fat);
+    }
+    write(e, data) {
+        const mini1 = this.header.use_mini(e.size);
+        const fat1 = this.get_fat(mini1);
+        const chain = fat1.get_chain(e.sec_id);
+        const mini2 = this.header.use_mini(data.length);
+        const fat2 = this.get_fat(mini2);
+        if (data.length != e.size) {
+            if (mini1 != mini2)
+                fat1.resize_chain(chain, 0);
+            fat2.resize_chain(chain, data.length);
+            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));
+        }
+        fat2.write_chain(chain, data);
+    }
+}
+exports.Reader = Reader;

package/dist/arch.d.ts

@@ -0,0 +1,26 @@
+import * as binary from '@isopodlabs/binary';
+export type HEADER = {
+    name: string;
+    date: number;
+    uid: number;
+    gid: number;
+    mode: number;
+    size: number;
+    fmag: string;
+    contents: any;
+};
+export declare class ArchFile {
+    members: {
+        name: string;
+        date: number;
+        uid: number;
+        gid: number;
+        mode: number;
+        size: number;
+        fmag: string;
+        contents: any;
+    }[];
+    static check(data: Uint8Array): boolean;
+    constructor(data: Uint8Array);
+}
+export {};

package/dist/arch.js

@@ -0,0 +1,96 @@
+"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.ArchFile = void 0;
+const binary = __importStar(require("@isopodlabs/binary"));
+const _HEADER = {
+    name: binary.as(binary.StringType(16), x => {
+        x = x.trim();
+        return x.endsWith('/') ? x.slice(0, -1) : x;
+    }),
+    date: binary.asInt(binary.StringType(12)),
+    uid: binary.asInt(binary.StringType(6)),
+    gid: binary.asInt(binary.StringType(6)),
+    mode: binary.asInt(binary.StringType(8), 8),
+    size: binary.asInt(binary.StringType(10)),
+    fmag: binary.as(binary.StringType(2), x => x.trim() == '`' ? '' : x),
+    contents: binary.DontRead()
+};
+const SYM64 = {
+    name: binary.StringType(12),
+    offset: binary.asInt(binary.StringType(4))
+};
+class ArchFile {
+    members = [];
+    static check(data) {
+        return binary.utils.decodeText(data.subarray(0, 8), 'utf8') == '!<arch>\n';
+    }
+    constructor(data) {
+        const s = new binary.stream(data);
+        const header = binary.read(s, binary.StringType(8));
+        if (header !== '!<arch>\n')
+            throw new Error('Invalid archive file format');
+        let long_names;
+        while (s.remaining() > 0) {
+            const member = binary.read(s, _HEADER);
+            const data = s.read_buffer(member.size);
+            s.align(2);
+            if (member.name == '/') {
+                long_names = binary.utils.decodeText(data, 'utf8');
+                continue;
+            }
+            if (member.name[0] == '/' && long_names) {
+                const offset = +member.name.substring(1);
+                member.name = long_names.substring(offset, long_names.indexOf('/', offset));
+            }
+            if (member.name == '') {
+                const s2 = new binary.stream(data);
+                const offsets = binary.ArrayType(binary.INT32_BE, binary.INT32_BE).get(s2);
+                member.name = 'Symbols';
+                member.contents = offsets.map(offset => [
+                    binary.NullTerminatedStringType.get(s2),
+                    offset
+                ]);
+            }
+            else if (member.name == '/SYM') {
+                const s2 = new binary.stream(data);
+                const syms = binary.ArrayType(binary.INT32_BE, binary.NullTerminatedStringType).get(s2);
+                member.contents = syms.map(name => ({
+                    name,
+                    offset: binary.INT32_BE.get(s2)
+                }));
+            }
+            else if (member.name == '/SYM64') {
+                const s2 = new binary.stream(data);
+                member.contents = binary.RemainingArrayType(SYM64).get(s2);
+            }
+            else {
+                member.contents = data;
+            }
+            this.members.push(member);
+        }
+    }
+}
+exports.ArchFile = ArchFile;