@peter.prib/renderengine 0.0.0-stage → 0.1.0

package/src/zip/ZipArchive.js

@@ -0,0 +1,160 @@
+import { crc32 } from './crc32.js';
+import { inflate } from './inflate.js';
+
+const LOCAL_HEADER = 0x04034b50;
+const CENTRAL_HEADER = 0x02014b50;
+const END_OF_CENTRAL = 0x06054b50;
+const STORED = 0;
+const DEFLATED = 8;
+const UTF8_NAMES = 0x0800;
+
+/**
+ * A zip archive held in memory: named entries of bytes. Reads stored and
+ * deflated entries (what Java's ZipOutputStream, and so Archi, writes); writes
+ * stored ones, which every zip reader accepts. No ZIP64, encryption or
+ * multi-disk archives.
+ *
+ *   const zip = ZipArchive.read(bytes);
+ *   zip.get('model.xml');                       // Uint8Array, or undefined
+ *   new ZipArchive().add('a.txt', bytes).toBytes();
+ */
+export class ZipArchive {
+    constructor() {
+        /** name -> Uint8Array, in the order added */
+        this._entries = new Map();
+    }
+
+    /** Whether bytes start like a zip archive ("PK\3\4"). */
+    static isZip(bytes) {
+        return bytes instanceof Uint8Array && bytes.length >= 4
+            && bytes[0] === 0x50 && bytes[1] === 0x4B && bytes[2] === 0x03 && bytes[3] === 0x04;
+    }
+
+    /**
+     * Read an archive. Entry sizes come from the central directory, since a
+     * streamed entry's local header leaves them zero.
+     * @param {Uint8Array} bytes
+     * @returns {ZipArchive}
+     */
+    static read(bytes) {
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        const eocd = ZipArchive._findEndOfCentral(view);
+        const count = view.getUint16(eocd + 10, true);
+        let at = view.getUint32(eocd + 16, true);
+        const names = new TextDecoder();
+        const zip = new ZipArchive();
+        for (let i = 0; i < count; i++) {
+            if (view.getUint32(at, true) !== CENTRAL_HEADER) throw new Error('zip: bad central directory');
+            const method = view.getUint16(at + 10, true);
+            const crc = view.getUint32(at + 16, true);
+            const compressed = view.getUint32(at + 20, true);
+            const size = view.getUint32(at + 24, true);
+            const nameLen = view.getUint16(at + 28, true);
+            const extraLen = view.getUint16(at + 30, true);
+            const commentLen = view.getUint16(at + 32, true);
+            const local = view.getUint32(at + 42, true);
+            const name = names.decode(bytes.subarray(at + 46, at + 46 + nameLen));
+            at += 46 + nameLen + extraLen + commentLen;
+            if (compressed === 0xFFFFFFFF || size === 0xFFFFFFFF || local === 0xFFFFFFFF) throw new Error('zip: ZIP64 archives are not supported');
+            if (name.endsWith('/')) continue;   // a directory
+
+            if (view.getUint32(local, true) !== LOCAL_HEADER) throw new Error(`zip: bad local header for ${name}`);
+            const start = local + 30 + view.getUint16(local + 26, true) + view.getUint16(local + 28, true);
+            const raw = bytes.subarray(start, start + compressed);
+            let data;
+            if (method === STORED) data = raw.slice();
+            else if (method === DEFLATED) data = inflate(raw, size);
+            else throw new Error(`zip: ${name} uses compression method ${method}, which is not supported`);
+            if (data.length !== size || crc32(data) !== crc) throw new Error(`zip: ${name} is damaged (size or checksum)`);
+            zip._entries.set(name, data);
+        }
+        return zip;
+    }
+
+    /** @private */
+    static _findEndOfCentral(view) {
+        // The record is 22 bytes plus a comment of up to 65535.
+        const lowest = Math.max(0, view.byteLength - 22 - 0xFFFF);
+        for (let at = view.byteLength - 22; at >= lowest; at--) {
+            if (view.getUint32(at, true) === END_OF_CENTRAL) return at;
+        }
+        throw new Error('zip: not a zip archive (no end of central directory)');
+    }
+
+    /** Entry names, in archive order. */
+    names() {
+        return [...this._entries.keys()];
+    }
+
+    /** An entry's bytes, or undefined. */
+    get(name) {
+        return this._entries.get(name);
+    }
+
+    /** Add (or replace) an entry. Strings are written as UTF-8. Returns this. */
+    add(name, data) {
+        this._entries.set(name, typeof data === 'string' ? new TextEncoder().encode(data) : data);
+        return this;
+    }
+
+    /**
+     * The archive's bytes, every entry stored (uncompressed).
+     * @param {Date} [date] - modification time recorded for every entry
+     * @returns {Uint8Array}
+     */
+    toBytes(date = new Date()) {
+        const encoder = new TextEncoder();
+        const time = (date.getHours() << 11) | (date.getMinutes() << 5) | (date.getSeconds() >> 1);
+        const day = ((Math.max(date.getFullYear(), 1980) - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate();
+        const entries = [...this._entries].map(([name, data]) => ({ name: encoder.encode(name), data, crc: crc32(data) }));
+        const localSize = entries.reduce((n, e) => n + 30 + e.name.length + e.data.length, 0);
+        const centralSize = entries.reduce((n, e) => n + 46 + e.name.length, 0);
+        const out = new Uint8Array(localSize + centralSize + 22);
+        const view = new DataView(out.buffer);
+        let at = 0;
+
+        /** The fields a local and a central header share, from "version needed" on. */
+        const common = (e) => {
+            view.setUint16(at, 20, true);           // version needed: 2.0
+            view.setUint16(at + 2, UTF8_NAMES, true);
+            view.setUint16(at + 4, STORED, true);
+            view.setUint16(at + 6, time, true);
+            view.setUint16(at + 8, day, true);
+            view.setUint32(at + 10, e.crc, true);
+            view.setUint32(at + 14, e.data.length, true);
+            view.setUint32(at + 18, e.data.length, true);
+            view.setUint16(at + 22, e.name.length, true);
+            view.setUint16(at + 24, 0, true);       // extra length
+            at += 26;
+        };
+
+        for (const e of entries) {
+            e.offset = at;
+            view.setUint32(at, LOCAL_HEADER, true);
+            at += 4;
+            common(e);
+            out.set(e.name, at); at += e.name.length;
+            out.set(e.data, at); at += e.data.length;
+        }
+        const centralStart = at;
+        for (const e of entries) {
+            view.setUint32(at, CENTRAL_HEADER, true);
+            view.setUint16(at + 4, 20, true);       // version made by
+            at += 6;
+            common(e);
+            view.setUint16(at, 0, true);            // comment length
+            view.setUint16(at + 2, 0, true);        // disk
+            view.setUint16(at + 4, 0, true);        // internal attributes
+            view.setUint32(at + 6, 0, true);        // external attributes
+            view.setUint32(at + 10, e.offset, true);
+            at += 14;
+            out.set(e.name, at); at += e.name.length;
+        }
+        view.setUint32(at, END_OF_CENTRAL, true);
+        view.setUint16(at + 8, entries.length, true);
+        view.setUint16(at + 10, entries.length, true);
+        view.setUint32(at + 12, at - centralStart, true);
+        view.setUint32(at + 16, centralStart, true);
+        return out;
+    }
+}

package/src/zip/crc32.js

@@ -0,0 +1,25 @@
+/** CRC-32 (the zip/PNG polynomial, 0xEDB88320), one table built on first use. */
+let TABLE = null;
+
+function table() {
+    if (TABLE) return TABLE;
+    TABLE = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) c = c & 1 ? 0xEDB88320 ^ (c >>> 1) : c >>> 1;
+        TABLE[n] = c >>> 0;
+    }
+    return TABLE;
+}
+
+/**
+ * The CRC-32 of some bytes.
+ * @param {Uint8Array} bytes
+ * @returns {number} unsigned 32-bit checksum
+ */
+export function crc32(bytes) {
+    const t = table();
+    let c = 0xFFFFFFFF;
+    for (let i = 0; i < bytes.length; i++) c = t[(c ^ bytes[i]) & 0xFF] ^ (c >>> 8);
+    return (c ^ 0xFFFFFFFF) >>> 0;
+}

package/src/zip/inflate.js

@@ -0,0 +1,159 @@
+/**
+ * Raw DEFLATE decoder (RFC 1951): stored, fixed-Huffman and dynamic-Huffman
+ * blocks. Dependency-free, after Mark Adler's puff.c: canonical Huffman codes
+ * are decoded bit by bit from per-length counts, which is short and plenty fast
+ * for a model file and its images.
+ */
+
+const MAX_BITS = 15;
+const LENGTH_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+const LENGTH_EXTRA = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+const DIST_BASE = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+const DIST_EXTRA = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+/** The order code-length code lengths are sent in (dynamic blocks). */
+const CL_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+
+/** A canonical Huffman code: how many codes of each length, and the symbols in code order. */
+function huffman(lengths) {
+    const count = new Uint16Array(MAX_BITS + 1);
+    for (const len of lengths) count[len]++;
+    count[0] = 0;
+    const offs = new Uint16Array(MAX_BITS + 1);
+    for (let len = 1; len < MAX_BITS; len++) offs[len + 1] = offs[len] + count[len];
+    const symbol = new Uint16Array(lengths.length);
+    lengths.forEach((len, sym) => { if (len) symbol[offs[len]++] = sym; });
+    return { count, symbol };
+}
+
+let FIXED = null;
+function fixedCodes() {
+    if (FIXED) return FIXED;
+    const lit = new Array(288);
+    lit.fill(8, 0, 144); lit.fill(9, 144, 256); lit.fill(7, 256, 280); lit.fill(8, 280, 288);
+    FIXED = { lencode: huffman(lit), distcode: huffman(new Array(30).fill(5)) };
+    return FIXED;
+}
+
+class Inflater {
+    constructor(input, sizeHint) {
+        this.input = input;
+        this.pos = 0;
+        this.bitBuf = 0;
+        this.bitCount = 0;
+        this.out = new Uint8Array(Math.max(sizeHint || 0, input.length * 4, 1024));
+        this.outLen = 0;
+    }
+
+    bits(need) {
+        let val = this.bitBuf;
+        while (this.bitCount < need) {
+            if (this.pos >= this.input.length) throw new Error('inflate: unexpected end of data');
+            val |= this.input[this.pos++] << this.bitCount;
+            this.bitCount += 8;
+        }
+        this.bitBuf = val >>> need;
+        this.bitCount -= need;
+        return val & ((1 << need) - 1);
+    }
+
+    put(byte) {
+        if (this.outLen === this.out.length) {
+            const bigger = new Uint8Array(this.out.length * 2);
+            bigger.set(this.out);
+            this.out = bigger;
+        }
+        this.out[this.outLen++] = byte;
+    }
+
+    decode({ count, symbol }) {
+        let code = 0, first = 0, index = 0;
+        for (let len = 1; len <= MAX_BITS; len++) {
+            code |= this.bits(1);
+            const n = count[len];
+            if (code - n < first) return symbol[index + (code - first)];
+            index += n;
+            first = (first + n) << 1;
+            code <<= 1;
+        }
+        throw new Error('inflate: bad Huffman code');
+    }
+
+    stored() {
+        this.bitBuf = 0;
+        this.bitCount = 0;   // to a byte boundary
+        if (this.pos + 4 > this.input.length) throw new Error('inflate: unexpected end of data');
+        const len = this.input[this.pos] | (this.input[this.pos + 1] << 8);
+        const nlen = this.input[this.pos + 2] | (this.input[this.pos + 3] << 8);
+        if (len !== (~nlen & 0xFFFF)) throw new Error('inflate: stored block length check failed');
+        this.pos += 4;
+        if (this.pos + len > this.input.length) throw new Error('inflate: unexpected end of data');
+        for (let i = 0; i < len; i++) this.put(this.input[this.pos++]);
+    }
+
+    codes({ lencode, distcode }) {
+        for (;;) {
+            const sym = this.decode(lencode);
+            if (sym < 256) { this.put(sym); continue; }
+            if (sym === 256) return;
+            const li = sym - 257;
+            if (li >= 29) throw new Error('inflate: bad length symbol');
+            const len = LENGTH_BASE[li] + this.bits(LENGTH_EXTRA[li]);
+            const di = this.decode(distcode);
+            if (di >= 30) throw new Error('inflate: bad distance symbol');
+            const dist = DIST_BASE[di] + this.bits(DIST_EXTRA[di]);
+            if (dist > this.outLen) throw new Error('inflate: distance too far back');
+            for (let i = 0; i < len; i++) this.put(this.out[this.outLen - dist]);
+        }
+    }
+
+    dynamic() {
+        const nlen = this.bits(5) + 257;
+        const ndist = this.bits(5) + 1;
+        const ncode = this.bits(4) + 4;
+        const clLengths = new Array(19).fill(0);
+        for (let i = 0; i < ncode; i++) clLengths[CL_ORDER[i]] = this.bits(3);
+        const clCode = huffman(clLengths);
+        const lengths = [];
+        while (lengths.length < nlen + ndist) {
+            const sym = this.decode(clCode);
+            if (sym < 16) { lengths.push(sym); continue; }
+            let repeat, value = 0;
+            if (sym === 16) {
+                if (!lengths.length) throw new Error('inflate: repeat with no previous length');
+                value = lengths[lengths.length - 1];
+                repeat = 3 + this.bits(2);
+            } else if (sym === 17) {
+                repeat = 3 + this.bits(3);
+            } else {
+                repeat = 11 + this.bits(7);
+            }
+            if (lengths.length + repeat > nlen + ndist) throw new Error('inflate: too many code lengths');
+            for (let i = 0; i < repeat; i++) lengths.push(value);
+        }
+        if (!lengths[256]) throw new Error('inflate: no end-of-block code');
+        this.codes({ lencode: huffman(lengths.slice(0, nlen)), distcode: huffman(lengths.slice(nlen)) });
+    }
+
+    run() {
+        let last;
+        do {
+            last = this.bits(1);
+            const type = this.bits(2);
+            if (type === 0) this.stored();
+            else if (type === 1) this.codes(fixedCodes());
+            else if (type === 2) this.dynamic();
+            else throw new Error('inflate: bad block type');
+        } while (!last);
+        return this.out.slice(0, this.outLen);
+    }
+}
+
+/**
+ * Decompress raw DEFLATE data (no zlib or gzip header), as zip entries hold it.
+ * @param {Uint8Array} data
+ * @param {number} [sizeHint] - expected output size, if known (zip records it)
+ * @returns {Uint8Array}
+ */
+export function inflate(data, sizeHint = 0) {
+    return new Inflater(data, sizeHint).run();
+}