@isopodlabs/binary_libs 0.0.1 → 0.1.0

package/dist/CompoundDocument.js

@@ -1,301 +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.Reader = exports.Master = 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.ReadWriteStruct({
-    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),
-    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.ReadWriteStruct({
-    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();
-        }
-    }
-}
-exports.Master = Master;
-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

@@ -1,41 +0,0 @@
-import * as binary from '@isopodlabs/binary';
-declare const AR_MEMBER_HEADER: {
-    name: {
-        get(s: binary._stream, obj: any): string;
-        put(s: binary._stream, v: string): void;
-    };
-    date: {
-        get(s: binary._stream, obj: any): number;
-        put(s: binary._stream, v: number): void;
-    };
-    uid: {
-        get(s: binary._stream, obj: any): number;
-        put(s: binary._stream, v: number): void;
-    };
-    gid: {
-        get(s: binary._stream, obj: any): number;
-        put(s: binary._stream, v: number): void;
-    };
-    mode: {
-        get(s: binary._stream, obj: any): number;
-        put(s: binary._stream, v: number): void;
-    };
-    size: {
-        get(s: binary._stream, obj: any): number;
-        put(s: binary._stream, v: number): void;
-    };
-    fmag: {
-        get(s: binary._stream, obj: any): string;
-        put(s: binary._stream, v: string): void;
-    };
-    contents: {
-        get(s: binary._stream): any;
-        put(s: binary._stream, v: any): void;
-    };
-};
-export declare class ArchFile {
-    members: binary.ReadType<typeof AR_MEMBER_HEADER>[];
-    static check(data: Uint8Array): boolean;
-    constructor(data: Uint8Array);
-}
-export {};

package/dist/arch.js

@@ -1,94 +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.ArchFile = void 0;
-const binary = __importStar(require("@isopodlabs/binary"));
-const AR_MEMBER_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 AR_SYM64 = {
-    name: binary.StringType(12),
-    offset: binary.asInt(binary.StringType(4))
-};
-class ArchFile {
-    members = [];
-    static check(data) {
-        const x = binary.utils.decodeText(data.subarray(0, 8), 'utf8');
-        return x == '!<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, AR_MEMBER_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(AR_SYM64).get(s2);
-            }
-            else {
-                member.contents = data;
-            }
-            this.members.push(member);
-        }
-    }
-}
-exports.ArchFile = ArchFile;