@li0ard/wsq 0.1.0

package/dist/index.js

@@ -0,0 +1,879 @@
+import { BitmapWithMetadata } from "./bitmap";
+import { ANY_WSQ, BITMASK, buildWSQTrees, COM_WSQ, DHT_WSQ, DQT_WSQ, DTT_WSQ, EOI_WSQ, HeaderFrm, HuffCode, HuffmanTable, MAX_HUFFBITS, MAX_HUFFCOUNTS_WSQ, NCM_COLORSPACE, NCM_COMPRESSION, NCM_HEADER, NCM_LOSSY, NCM_PIX_DEPTH, NCM_PIX_HEIGHT, NCM_PIX_WIDTH, NCM_PPI, NUM_SUBBANDS, Ref, SOB_WSQ, SOF_WSQ, SOI_WSQ, Table_DQT, TBLS_N_SOB, TBLS_N_SOF, Token, W_TREELEN } from "./const";
+import UPNG from "@pdf-lib/upng";
+class WSQDecoder {
+    offset = 0;
+    decode(data) {
+        const token = new Token();
+        const dataInput = new DataView(data.buffer, data.byteOffset);
+        this.getCMarkerWSQ(dataInput, SOI_WSQ);
+        let marker = this.getCMarkerWSQ(dataInput, TBLS_N_SOF);
+        while (marker != SOF_WSQ) {
+            this.getCTableWSQ(dataInput, token, marker);
+            marker = this.getCMarkerWSQ(dataInput, TBLS_N_SOF);
+        }
+        let frmHeaderWSQ = this.getCFrameHeaderWSQ(dataInput);
+        let width = frmHeaderWSQ.width;
+        let height = frmHeaderWSQ.height;
+        buildWSQTrees(token, width, height);
+        let qdata = this.huffmanDecodeDataMem(dataInput, token, width * height);
+        let fdata = this.unquantize(token, qdata, width, height);
+        this.wsqReconstruct(token, fdata, width, height);
+        let cdata = this.convertImageToByte(fdata, width, height, frmHeaderWSQ.mShift, frmHeaderWSQ.rScale);
+        const nistcom = new Map();
+        const comments = [];
+        for (const comment of token.comments) {
+            try {
+                const parsed = this.stringToFet(comment);
+                for (const [k, v] of parsed) {
+                    nistcom.set(k, v);
+                }
+            }
+            catch (e) {
+                comments.push(comment);
+            }
+        }
+        nistcom.delete(NCM_HEADER);
+        nistcom.set(NCM_PIX_WIDTH, width.toString());
+        nistcom.set(NCM_PIX_HEIGHT, height.toString());
+        nistcom.set(NCM_PIX_DEPTH, "8");
+        nistcom.set(NCM_LOSSY, "1");
+        nistcom.set(NCM_COLORSPACE, "GRAY");
+        nistcom.set(NCM_COMPRESSION, "WSQ");
+        let ppiOk = false;
+        try {
+            const ppi = parseInt(nistcom.get(NCM_PPI) ?? "");
+            if (ppi > 0)
+                ppiOk = true;
+        }
+        catch { }
+        if (!ppiOk)
+            nistcom.set(NCM_PPI, "-1");
+        return new BitmapWithMetadata(cdata, width, height, parseInt(nistcom.get(NCM_PPI)), 8, 1, nistcom, comments.join(", "));
+    }
+    stringToFet(comment) {
+        if (!comment.startsWith(NCM_HEADER))
+            throw new Error("Not a NISTCOM header");
+        const result = new Map();
+        const lines = comment.split(/\r?\n/);
+        for (const line of lines) {
+            const split = line.indexOf(" ");
+            if (split < 0) {
+                console.warn(`Illegal NISTCOM header: Missing separator on line '${line}'`);
+                continue;
+            }
+            const key = decodeURIComponent(line.substring(0, split));
+            const value = decodeURIComponent(line.substring(split + 1));
+            result.set(key, value);
+        }
+        return result;
+    }
+    convertImageToByte(img, width, height, mShift, rScale) {
+        let data = new Uint8Array(width * height);
+        let idx = 0;
+        for (let r = 0; r < height; r++) {
+            for (let c = 0; c < width; c++) {
+                let pixel = (img[idx] * rScale) + mShift;
+                pixel += 0.5;
+                if (pixel < 0.0) {
+                    data[idx] = 0;
+                }
+                else if (pixel > 255.0) {
+                    data[idx] = 255;
+                }
+                else {
+                    data[idx] = pixel;
+                }
+                idx++;
+            }
+        }
+        return data;
+    }
+    wsqReconstruct(token, fdata, width, height) {
+        if (token.tableDTT.lodef != 1)
+            throw new Error("ERROR: wsq_reconstruct : Lopass filter coefficients not defined");
+        if (token.tableDTT.hidef != 1)
+            throw new Error("ERROR: wsq_reconstruct : Hipass filter coefficients not defined");
+        let numPix = width * height;
+        let fdataTemp = new Float32Array(numPix);
+        for (let node = W_TREELEN - 1; node >= 0; node--) {
+            let fdataBse = (token.wtree[node].y * width) + token.wtree[node].x;
+            this.joinLets(fdataTemp, fdata, 0, fdataBse, token.wtree[node].lenx, token.wtree[node].leny, 1, width, token.tableDTT.hifilt, token.tableDTT.hisz, token.tableDTT.lofilt, token.tableDTT.losz, token.wtree[node].invcl);
+            this.joinLets(fdata, fdataTemp, fdataBse, 0, token.wtree[node].leny, token.wtree[node].lenx, width, 1, token.tableDTT.hifilt, token.tableDTT.hisz, token.tableDTT.lofilt, token.tableDTT.losz, token.wtree[node].invrw);
+        }
+    }
+    joinLets(newdata, olddata, newIndex, oldIndex, len1, len2, pitch, stride, hi, hsz, lo, lsz, inv) {
+        const da_ev = len2 % 2;
+        const fi_ev = lsz % 2;
+        const pstr = stride;
+        const nstr = -pstr;
+        let llen, hlen;
+        if (da_ev !== 0) {
+            llen = Math.floor((len2 + 1) / 2);
+            hlen = llen - 1;
+        }
+        else {
+            llen = Math.floor(len2 / 2);
+            hlen = llen;
+        }
+        let asym, ssfac, ofhre;
+        let loc, hoc;
+        let lotap, hotap;
+        let olle, olre, ohle, ohre;
+        if (fi_ev !== 0) {
+            asym = 0;
+            ssfac = 1.0;
+            ofhre = 0;
+            loc = Math.floor((lsz - 1) / 4);
+            hoc = Math.floor((hsz + 1) / 4) - 1;
+            lotap = ((lsz - 1) / 2) % 2;
+            hotap = ((hsz + 1) / 2) % 2;
+            if (da_ev !== 0) {
+                olle = 0;
+                olre = 0;
+                ohle = 1;
+                ohre = 1;
+            }
+            else {
+                olle = 0;
+                olre = 1;
+                ohle = 1;
+                ohre = 0;
+            }
+        }
+        else {
+            asym = 1;
+            ssfac = -1.0;
+            ofhre = 2;
+            loc = Math.floor(lsz / 4) - 1;
+            hoc = Math.floor(hsz / 4) - 1;
+            lotap = Math.floor(lsz / 2) % 2;
+            hotap = Math.floor(hsz / 2) % 2;
+            if (da_ev !== 0) {
+                olle = 1;
+                olre = 0;
+                ohle = 1;
+                ohre = 1;
+            }
+            else {
+                olle = 1;
+                olre = 1;
+                ohle = 1;
+                ohre = 1;
+            }
+            if (loc === -1) {
+                loc = 0;
+                olle = 0;
+            }
+            if (hoc === -1) {
+                hoc = 0;
+                ohle = 0;
+            }
+            for (let i = 0; i < hsz; i++)
+                hi[i] = hi[i] * -1.0;
+        }
+        let lp0, lp1;
+        let hp0, hp1;
+        let lopass, hipass;
+        let limg, himg;
+        let pix, cl_rw;
+        let i;
+        let lstap, lspx, lspxstr, lpx, lpxstr;
+        let lle, lle2, lre, lre2;
+        let hspx, hspxstr, hpx, hpxstr;
+        let hle, hle2, hre, hre2;
+        let hstap, fhre = 0, ofhre_local = ofhre;
+        let osfac = ssfac, sfac;
+        for (cl_rw = 0; cl_rw < len1; cl_rw++) {
+            limg = newIndex + cl_rw * pitch;
+            himg = limg;
+            newdata[himg] = 0.0;
+            newdata[himg + stride] = 0.0;
+            if (inv !== 0) {
+                hipass = oldIndex + cl_rw * pitch;
+                lopass = hipass + stride * hlen;
+            }
+            else {
+                lopass = oldIndex + cl_rw * pitch;
+                hipass = lopass + stride * llen;
+            }
+            lp0 = lopass;
+            lp1 = lp0 + (llen - 1) * stride;
+            lspx = lp0 + (loc * stride);
+            lspxstr = nstr;
+            lstap = lotap;
+            lle2 = olle;
+            lre2 = olre;
+            hp0 = hipass;
+            hp1 = hp0 + (hlen - 1) * stride;
+            hspx = hp0 + (hoc * stride);
+            hspxstr = nstr;
+            hstap = hotap;
+            hle2 = ohle;
+            hre2 = ohre;
+            osfac = ssfac;
+            for (pix = 0; pix < hlen; pix++) {
+                for (let tap = lstap; tap >= 0; tap--) {
+                    lle = lle2;
+                    lre = lre2;
+                    lpx = lspx;
+                    lpxstr = lspxstr;
+                    let acc = olddata[lpx] * lo[tap];
+                    for (i = tap + 2; i < lsz; i += 2) {
+                        if (lpx === lp0) {
+                            if (lle !== 0) {
+                                lpxstr = 0;
+                                lle = 0;
+                            }
+                            else {
+                                lpxstr = pstr;
+                            }
+                        }
+                        if (lpx === lp1) {
+                            if (lre !== 0) {
+                                lpxstr = 0;
+                                lre = 0;
+                            }
+                            else {
+                                lpxstr = nstr;
+                            }
+                        }
+                        lpx += lpxstr;
+                        acc += olddata[lpx] * lo[i];
+                    }
+                    newdata[limg] = acc;
+                    limg += stride;
+                }
+                if (lspx === lp0) {
+                    if (lle2 !== 0) {
+                        lspxstr = 0;
+                        lle2 = 0;
+                    }
+                    else {
+                        lspxstr = pstr;
+                    }
+                }
+                lspx += lspxstr;
+                lstap = 1;
+                for (let tap = hstap; tap >= 0; tap--) {
+                    hle = hle2;
+                    hre = hre2;
+                    hpx = hspx;
+                    hpxstr = hspxstr;
+                    fhre = ofhre_local;
+                    sfac = osfac;
+                    let accH = 0.0;
+                    for (i = tap; i < hsz; i += 2) {
+                        if (hpx === hp0) {
+                            if (hle !== 0) {
+                                hpxstr = 0;
+                                hle = 0;
+                            }
+                            else {
+                                hpxstr = pstr;
+                                sfac = 1.0;
+                            }
+                        }
+                        if (hpx === hp1) {
+                            if (hre !== 0) {
+                                hpxstr = 0;
+                                hre = 0;
+                                if (asym !== 0 && da_ev !== 0) {
+                                    hre = 1;
+                                    fhre--;
+                                    sfac = fhre;
+                                    if (sfac === 0.0)
+                                        hre = 0;
+                                }
+                            }
+                            else {
+                                hpxstr = nstr;
+                                if (asym !== 0)
+                                    sfac = -1.0;
+                            }
+                        }
+                        accH += olddata[hpx] * hi[i] * sfac;
+                        hpx += hpxstr;
+                    }
+                    newdata[himg] += accH;
+                    himg += stride;
+                }
+                if (hspx === hp0) {
+                    if (hle2 !== 0) {
+                        hspxstr = 0;
+                        hle2 = 0;
+                    }
+                    else {
+                        hspxstr = pstr;
+                        osfac = 1.0;
+                    }
+                }
+                hspx += hspxstr;
+                hstap = 1;
+            }
+            if (da_ev !== 0) {
+                lstap = lotap !== 0 ? 1 : 0;
+            }
+            else {
+                lstap = lotap !== 0 ? 2 : 1;
+            }
+            for (let tap = 1; tap >= lstap; tap--) {
+                lle = lle2;
+                lre = lre2;
+                lpx = lspx;
+                lpxstr = lspxstr;
+                let acc = olddata[lpx] * lo[tap];
+                for (i = tap + 2; i < lsz; i += 2) {
+                    if (lpx === lp0) {
+                        if (lle !== 0) {
+                            lpxstr = 0;
+                            lle = 0;
+                        }
+                        else {
+                            lpxstr = pstr;
+                        }
+                    }
+                    if (lpx === lp1) {
+                        if (lre !== 0) {
+                            lpxstr = 0;
+                            lre = 0;
+                        }
+                        else {
+                            lpxstr = nstr;
+                        }
+                    }
+                    lpx += lpxstr;
+                    acc += olddata[lpx] * lo[i];
+                }
+                newdata[limg] = acc;
+                limg += stride;
+            }
+            if (da_ev !== 0) {
+                hstap = hotap !== 0 ? 1 : 0;
+                if (hsz === 2) {
+                    hspx -= hspxstr;
+                    fhre = 1;
+                }
+            }
+            else {
+                hstap = hotap !== 0 ? 2 : 1;
+            }
+            for (let tap = 1; tap >= hstap; tap--) {
+                hle = hle2;
+                hre = hre2;
+                hpx = hspx;
+                hpxstr = hspxstr;
+                sfac = osfac;
+                if (hsz !== 2)
+                    fhre = ofhre_local;
+                let accHbase = 0.0;
+                for (i = tap; i < hsz; i += 2) {
+                    if (hpx === hp0) {
+                        if (hle !== 0) {
+                            hpxstr = 0;
+                            hle = 0;
+                        }
+                        else {
+                            hpxstr = pstr;
+                            sfac = 1.0;
+                        }
+                    }
+                    if (hpx === hp1) {
+                        if (hre !== 0) {
+                            hpxstr = 0;
+                            hre = 0;
+                            if (asym !== 0 && da_ev !== 0) {
+                                hre = 1;
+                                fhre--;
+                                sfac = fhre;
+                                if (sfac === 0.0)
+                                    hre = 0;
+                            }
+                        }
+                        else {
+                            hpxstr = nstr;
+                            if (asym !== 0)
+                                sfac = -1.0;
+                        }
+                    }
+                    accHbase += olddata[hpx] * hi[i] * sfac;
+                    hpx += hpxstr;
+                }
+                newdata[himg] += accHbase;
+                himg += stride;
+            }
+        }
+        if (fi_ev === 0) {
+            for (i = 0; i < hsz; i++)
+                hi[i] = hi[i] * -1.0;
+        }
+    }
+    unquantize(token, sip, width, height) {
+        let fip = new Float32Array(width * height);
+        if (token.tableDQT.dqtDef != 1)
+            throw new Error("ERROR: unquantize : quantization table parameters not defined!");
+        let binCenter = token.tableDQT.binCenter;
+        let sptr = 0;
+        for (let cnt = 0; cnt < NUM_SUBBANDS; cnt++) {
+            if (token.tableDQT.qBin[cnt] == 0.0)
+                continue;
+            let fptr = (token.qtree[cnt].y * width) + token.qtree[cnt].x;
+            for (let row = 0; row < token.qtree[cnt].leny; row++, fptr += width - token.qtree[cnt].lenx) {
+                for (let col = 0; col < token.qtree[cnt].lenx; col++) {
+                    if (sip[sptr] == 0)
+                        fip[fptr] = 0.0;
+                    else if (sip[sptr] > 0)
+                        fip[fptr] = (token.tableDQT.qBin[cnt] * (sip[sptr] - binCenter)) + (token.tableDQT.zBin[cnt] / 2.0);
+                    else if (sip[sptr] < 0)
+                        fip[fptr] = (token.tableDQT.qBin[cnt] * (sip[sptr] + binCenter)) - (token.tableDQT.zBin[cnt] / 2.0);
+                    else
+                        throw new Error("ERROR : unquantize : invalid quantization pixel value");
+                    fptr++;
+                    sptr++;
+                }
+            }
+        }
+        return fip;
+    }
+    huffmanDecodeDataMem(dataInput, token, size) {
+        let qdata = new Array(size);
+        let maxcode = new Array(MAX_HUFFBITS + 1);
+        let mincode = new Array(MAX_HUFFBITS + 1);
+        let valptr = new Array(MAX_HUFFBITS + 1);
+        let marker = new Ref(this.getCMarkerWSQ(dataInput, TBLS_N_SOB));
+        let bitCount = new Ref(0);
+        let nextByte = new Ref(0);
+        let hufftableId = 0;
+        let ip = 0;
+        let isPrematureEOF = false;
+        while (!isPrematureEOF && (marker.value != EOI_WSQ)) {
+            if (marker.value != 0) {
+                while (marker.value != SOB_WSQ) {
+                    this.getCTableWSQ(dataInput, token, marker.value);
+                    marker.value = this.getCMarkerWSQ(dataInput, TBLS_N_SOB);
+                }
+                hufftableId = this.getCBlockHeader(dataInput);
+                if (token.tableDHT[hufftableId].tabdef != 1)
+                    throw new Error("ERROR : huffmanDecodeDataMem : huffman table undefined.");
+                let hufftable = this.buildHuffsizes(token.tableDHT[hufftableId].huffbits, MAX_HUFFCOUNTS_WSQ);
+                this.buildHuffcodes(hufftable);
+                this.genDecodeTable(hufftable, maxcode, mincode, valptr, token.tableDHT[hufftableId].huffbits);
+                bitCount.value = 0;
+                marker.value = 0;
+            }
+            try {
+                let nodeptr = this.decodeDataMem(dataInput, mincode, maxcode, valptr, token.tableDHT[hufftableId].huffvalues, bitCount, marker, nextByte);
+                if (nodeptr == -1)
+                    continue;
+                if (nodeptr > 0 && nodeptr <= 100) {
+                    for (let n = 0; n < nodeptr; n++)
+                        qdata[ip++] = 0;
+                }
+                else if (nodeptr > 106 && nodeptr < 0xff)
+                    qdata[ip++] = nodeptr - 180;
+                else if (nodeptr == 101)
+                    qdata[ip++] = this.getCNextbitsWSQ(dataInput, marker, bitCount, 8, nextByte);
+                else if (nodeptr == 102)
+                    qdata[ip++] = -this.getCNextbitsWSQ(dataInput, marker, bitCount, 8, nextByte);
+                else if (nodeptr == 103)
+                    qdata[ip++] = this.getCNextbitsWSQ(dataInput, marker, bitCount, 16, nextByte);
+                else if (nodeptr == 104)
+                    qdata[ip++] = -this.getCNextbitsWSQ(dataInput, marker, bitCount, 16, nextByte);
+                else if (nodeptr == 105) {
+                    let n = this.getCNextbitsWSQ(dataInput, marker, bitCount, 8, nextByte);
+                    while (n-- > 0)
+                        qdata[ip++] = 0;
+                }
+                else if (nodeptr == 106) {
+                    let n = this.getCNextbitsWSQ(dataInput, marker, bitCount, 16, nextByte);
+                    while (n-- > 0)
+                        qdata[ip++] = 0;
+                }
+                else
+                    throw new Error("ERROR: huffman_decode_data_mem : Invalid code (" + nodeptr + ")");
+            }
+            catch (e) {
+                console.warn("DEBUG: MO - ignoring EOF in WSQDecoder");
+                isPrematureEOF = true;
+            }
+        }
+        return qdata;
+    }
+    decodeDataMem(dataInput, mincode, maxcode, valptr, huffvalues, bitCount, marker, nextByte) {
+        let code = this.getCNextbitsWSQ(dataInput, marker, bitCount, 1, nextByte);
+        if (marker.value != 0)
+            return -1;
+        let inx;
+        for (inx = 1; code > maxcode[inx]; inx++) {
+            let tbits = this.getCNextbitsWSQ(dataInput, marker, bitCount, 1, nextByte); /* becomes a huffman code word  (one bit at a time)*/
+            code = ((code << 1) + tbits);
+            if (marker.value != 0)
+                return -1;
+        }
+        let inx2 = valptr[inx] + code - mincode[inx];
+        return huffvalues[inx2];
+    }
+    getCNextbitsWSQ(dataInput, marker, bitCount, bitsReq, nextByte) {
+        if (bitCount.value == 0) {
+            nextByte.value = dataInput.getUint8(this.offset);
+            this.offset += 1;
+            bitCount.value = 8;
+            if (nextByte.value == 0xFF) {
+                let code2 = dataInput.getUint8(this.offset);
+                this.offset += 1;
+                if (code2 != 0x00 && bitsReq == 1) {
+                    marker.value = (nextByte.value << 8) | code2;
+                    return 1;
+                }
+                if (code2 != 0x00)
+                    throw new Error("ERROR: getCNextbitsWSQ : No stuffed zeros.");
+            }
+        }
+        let bits, tbits;
+        let bitsNeeded;
+        if (bitsReq <= bitCount.value) {
+            bits = (nextByte.value >> (bitCount.value - bitsReq)) & (BITMASK[bitsReq]);
+            bitCount.value -= bitsReq;
+            nextByte.value &= BITMASK[bitCount.value];
+        }
+        else {
+            bitsNeeded = bitsReq - bitCount.value;
+            bits = nextByte.value << bitsNeeded;
+            bitCount.value = 0;
+            tbits = this.getCNextbitsWSQ(dataInput, marker, bitCount, bitsNeeded, nextByte);
+            bits |= tbits;
+        }
+        return bits;
+    }
+    genDecodeTable(huffcodeTable, maxcode, mincode, valptr, huffbits) {
+        for (let i = 0; i <= MAX_HUFFBITS; i++) {
+            maxcode[i] = 0;
+            mincode[i] = 0;
+            valptr[i] = 0;
+        }
+        let i2 = 0;
+        for (let i = 1; i <= MAX_HUFFBITS; i++) {
+            if (huffbits[i - 1] == 0) {
+                maxcode[i] = -1;
+                continue;
+            }
+            valptr[i] = i2;
+            mincode[i] = huffcodeTable[i2].code;
+            i2 = i2 + huffbits[i - 1] - 1;
+            maxcode[i] = huffcodeTable[i2].code;
+            i2++;
+        }
+    }
+    buildHuffsizes(huffbits, maxHuffcounts) {
+        let numberOfCodes = 1;
+        let huffcodeTable = new Array(maxHuffcounts + 1);
+        let tempSize = 0;
+        for (let codeSize = 1; codeSize <= MAX_HUFFBITS; codeSize++) {
+            while (numberOfCodes <= huffbits[codeSize - 1]) {
+                huffcodeTable[tempSize] = new HuffCode();
+                huffcodeTable[tempSize].size = codeSize;
+                tempSize++;
+                numberOfCodes++;
+            }
+            numberOfCodes = 1;
+        }
+        huffcodeTable[tempSize] = new HuffCode();
+        huffcodeTable[tempSize].size = 0;
+        return huffcodeTable;
+    }
+    buildHuffcodes(huffcodeTable) {
+        let tempCode = 0;
+        let pointer = 0;
+        let tempSize = huffcodeTable[0].size;
+        if (huffcodeTable[pointer].size == 0)
+            return;
+        do {
+            do {
+                huffcodeTable[pointer].code = tempCode;
+                tempCode++;
+                pointer++;
+            } while (huffcodeTable[pointer].size == tempSize);
+            if (huffcodeTable[pointer].size == 0)
+                return;
+            do {
+                tempCode <<= 1;
+                tempSize++;
+            } while (huffcodeTable[pointer].size != tempSize);
+        } while (huffcodeTable[pointer].size == tempSize);
+    }
+    getCBlockHeader(dataInput) {
+        dataInput.getUint16(this.offset);
+        this.offset += 2;
+        let value = dataInput.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+    getCFrameHeaderWSQ(dataInput) {
+        let headerFrm = new HeaderFrm();
+        dataInput.getUint16(this.offset);
+        this.offset += 2;
+        headerFrm.black = dataInput.getUint8(this.offset);
+        this.offset += 1;
+        headerFrm.white = dataInput.getUint8(this.offset);
+        this.offset += 1;
+        headerFrm.height = dataInput.getUint16(this.offset);
+        this.offset += 2;
+        headerFrm.width = dataInput.getUint16(this.offset);
+        this.offset += 2;
+        let scale = dataInput.getUint8(this.offset);
+        this.offset += 1;
+        let shrtDat = dataInput.getUint16(this.offset);
+        this.offset += 2;
+        headerFrm.mShift = shrtDat;
+        while (scale > 0) {
+            headerFrm.mShift /= 10.0;
+            scale--;
+        }
+        scale = dataInput.getUint8(this.offset);
+        this.offset += 1;
+        shrtDat = dataInput.getUint16(this.offset);
+        this.offset += 2;
+        headerFrm.rScale = shrtDat;
+        while (scale > 0) {
+            headerFrm.rScale /= 10.0;
+            scale--;
+        }
+        headerFrm.wsqEncoder = dataInput.getUint8(this.offset);
+        this.offset += 1;
+        headerFrm.software = dataInput.getUint16(this.offset);
+        this.offset += 2;
+        return headerFrm;
+    }
+    getCMarkerWSQ(dataInput, type) {
+        const marker = dataInput.getUint16(this.offset);
+        this.offset += 2;
+        switch (type) {
+            case SOI_WSQ:
+                if (marker != SOI_WSQ)
+                    throw new Error("ERROR : getCMarkerWSQ : No SOI marker : " + marker);
+                return marker;
+            case TBLS_N_SOF:
+                if (marker != DTT_WSQ && marker != DQT_WSQ && marker != DHT_WSQ && marker != SOF_WSQ && marker != COM_WSQ)
+                    throw new Error("ERROR : getc_marker_wsq : No SOF, Table, or comment markers : " + marker);
+                return marker;
+            case TBLS_N_SOB:
+                if (marker != DTT_WSQ && marker != DQT_WSQ && marker != DHT_WSQ && marker != SOB_WSQ && marker != COM_WSQ)
+                    throw new Error("ERROR : getc_marker_wsq : No SOB, Table, or comment markers : " + marker);
+                return marker;
+            case ANY_WSQ:
+                if ((marker & 0xff00) != 0xff00)
+                    throw new Error("ERROR : getc_marker_wsq : no marker found : " + marker);
+                if ((marker < SOI_WSQ) || (marker > COM_WSQ))
+                    throw new Error("ERROR : getc_marker_wsq : not a valid marker : " + marker);
+                return marker;
+            default:
+                throw new Error("ERROR : getc_marker_wsq : Invalid marker : " + marker);
+        }
+    }
+    getCTableWSQ(dataInput, token, marker) {
+        switch (marker) {
+            case DTT_WSQ:
+                this.getCTransformTable(dataInput, token);
+                return;
+            case DQT_WSQ:
+                this.getCQuantizationTable(dataInput, token);
+                return;
+            case DHT_WSQ:
+                this.getCHuffmanTableWSQ(dataInput, token);
+                return;
+            case COM_WSQ:
+                token.comments.push(this.getCComment(dataInput));
+                return;
+            default:
+                throw new Error("ERROR: getCTableWSQ : Invalid table defined : " + marker.toString(16));
+        }
+    }
+    getCHuffmanTableWSQ(dataInput, token) {
+        let firstHuffmanTable = this.getCHuffmanTable(dataInput, token, MAX_HUFFCOUNTS_WSQ, 0, true);
+        let tableId = firstHuffmanTable.tableId;
+        token.tableDHT[tableId].huffbits = firstHuffmanTable.huffbits.slice();
+        token.tableDHT[tableId].huffvalues = firstHuffmanTable.huffvalues.slice();
+        token.tableDHT[tableId].tabdef = 1;
+        let bytesLeft = firstHuffmanTable.bytesLeft;
+        while (bytesLeft != 0) {
+            let huffmantable = this.getCHuffmanTable(dataInput, token, MAX_HUFFCOUNTS_WSQ, bytesLeft, false);
+            tableId = huffmantable.tableId;
+            if (token.tableDHT[tableId].tabdef != 0)
+                throw new Error("ERROR : getCHuffmanTableWSQ : huffman table already defined.");
+            token.tableDHT[tableId].huffbits = huffmantable.huffbits.slice();
+            token.tableDHT[tableId].huffvalues = huffmantable.huffvalues.slice();
+            token.tableDHT[tableId].tabdef = 1;
+            bytesLeft = huffmantable.bytesLeft;
+        }
+    }
+    getCHuffmanTable(dataInput, token, maxHuffcounts, bytesLeft, readTableLen) {
+        let huffmanTable = new HuffmanTable();
+        if (readTableLen) {
+            huffmanTable.tableLen = dataInput.getUint16(this.offset);
+            this.offset += 2;
+            huffmanTable.bytesLeft = huffmanTable.tableLen - 2;
+            bytesLeft = huffmanTable.bytesLeft;
+        }
+        else
+            huffmanTable.bytesLeft = bytesLeft;
+        if (bytesLeft <= 0)
+            throw new Error("ERROR : getCHuffmanTable : no huffman table bytes remaining");
+        huffmanTable.tableId = dataInput.getUint8(this.offset);
+        this.offset += 1;
+        huffmanTable.bytesLeft--;
+        huffmanTable.huffbits = new Array(MAX_HUFFBITS);
+        let numHufvals = 0;
+        for (let i = 0; i < MAX_HUFFBITS; i++) {
+            huffmanTable.huffbits[i] = dataInput.getUint8(this.offset);
+            this.offset += 1;
+            numHufvals += huffmanTable.huffbits[i];
+        }
+        huffmanTable.bytesLeft -= MAX_HUFFBITS;
+        if (numHufvals > maxHuffcounts + 1)
+            throw new Error("ERROR : getCHuffmanTable : numHufvals is larger than MAX_HUFFCOUNTS");
+        huffmanTable.huffvalues = new Array(maxHuffcounts + 1);
+        for (let i = 0; i < numHufvals; i++) {
+            huffmanTable.huffvalues[i] = dataInput.getUint8(this.offset);
+            this.offset += 1;
+        }
+        huffmanTable.bytesLeft -= numHufvals;
+        return huffmanTable;
+    }
+    getCQuantizationTable(dataInput, token) {
+        dataInput.getUint16(this.offset);
+        this.offset += 2;
+        let scale = dataInput.getUint8(this.offset);
+        this.offset += 1;
+        let shrtDat = dataInput.getUint16(this.offset);
+        this.offset += 2;
+        token.tableDQT.binCenter = shrtDat;
+        while (scale > 0) {
+            token.tableDQT.binCenter /= 10.0;
+            scale--;
+        }
+        for (let cnt = 0; cnt < Table_DQT.MAX_SUBBANDS; cnt++) {
+            scale = dataInput.getUint8(this.offset);
+            this.offset += 1;
+            shrtDat = dataInput.getUint16(this.offset);
+            this.offset += 2;
+            token.tableDQT.qBin[cnt] = shrtDat;
+            while (scale > 0) {
+                token.tableDQT.qBin[cnt] /= 10.0;
+                scale--;
+            }
+            scale = dataInput.getUint8(this.offset);
+            this.offset += 1;
+            shrtDat = dataInput.getUint16(this.offset);
+            this.offset += 2;
+            token.tableDQT.zBin[cnt] = shrtDat;
+            while (scale > 0) {
+                token.tableDQT.zBin[cnt] /= 10.0;
+                scale--;
+            }
+        }
+        token.tableDQT.dqtDef = 1;
+    }
+    getCComment(dataInput) {
+        const size = dataInput.getUint16(this.offset, false) - 2;
+        this.offset += 2;
+        const bytes = new Uint8Array(dataInput.buffer, dataInput.byteOffset + this.offset, size);
+        this.offset += size;
+        return new TextDecoder("utf-8").decode(bytes);
+    }
+    getCTransformTable(dataInput, token) {
+        dataInput.getUint16(this.offset, false);
+        this.offset += 2;
+        token.tableDTT.hisz = dataInput.getUint8(this.offset);
+        this.offset += 1;
+        token.tableDTT.losz = dataInput.getUint8(this.offset);
+        this.offset += 1;
+        token.tableDTT.hifilt = new Float32Array(token.tableDTT.hisz);
+        token.tableDTT.lofilt = new Float32Array(token.tableDTT.losz);
+        let aSize;
+        if (token.tableDTT.hisz % 2 != 0)
+            aSize = (token.tableDTT.hisz + 1) / 2;
+        else
+            aSize = token.tableDTT.hisz / 2;
+        const aLofilt = new Float32Array(aSize);
+        aSize--;
+        for (let cnt = 0; cnt <= aSize; cnt++) {
+            let sign = dataInput.getUint8(this.offset);
+            this.offset += 1;
+            let scale = dataInput.getUint8(this.offset);
+            this.offset += 1;
+            let shrtDat = (dataInput.getInt32(this.offset) & 0xFFFFFFFF) >>> 0;
+            this.offset += 4;
+            aLofilt[cnt] = shrtDat;
+            while (scale > 0) {
+                aLofilt[cnt] /= 10.0;
+                scale--;
+            }
+            if (sign != 0)
+                aLofilt[cnt] *= -1.0;
+            if (token.tableDTT.hisz % 2 != 0) {
+                token.tableDTT.hifilt[cnt + aSize] = this.intSign(cnt) * aLofilt[cnt];
+                if (cnt > 0)
+                    token.tableDTT.hifilt[aSize - cnt] = token.tableDTT.hifilt[cnt + aSize];
+            }
+            else {
+                token.tableDTT.hifilt[cnt + aSize + 1] = this.intSign(cnt) * aLofilt[cnt];
+                token.tableDTT.hifilt[aSize - cnt] = -1 * token.tableDTT.hifilt[cnt + aSize + 1];
+            }
+        }
+        if (token.tableDTT.losz % 2 != 0)
+            aSize = (token.tableDTT.losz + 1) / 2;
+        else
+            aSize = token.tableDTT.losz / 2;
+        const aHifilt = new Float32Array(aSize);
+        aSize--;
+        for (let cnt = 0; cnt <= aSize; cnt++) {
+            let sign = dataInput.getUint8(this.offset);
+            this.offset += 1;
+            let scale = dataInput.getUint8(this.offset);
+            this.offset += 1;
+            let shrtDat = (dataInput.getInt32(this.offset) & 0xFFFFFFFF) >>> 0;
+            this.offset += 4;
+            aHifilt[cnt] = shrtDat;
+            while (scale > 0) {
+                aHifilt[cnt] /= 10.0;
+                scale--;
+            }
+            if (sign != 0)
+                aHifilt[cnt] *= -1.0;
+            if (token.tableDTT.losz % 2 != 0) {
+                token.tableDTT.lofilt[cnt + aSize] = this.intSign(cnt) * aHifilt[cnt];
+                if (cnt > 0)
+                    token.tableDTT.lofilt[aSize - cnt] = token.tableDTT.lofilt[cnt + aSize];
+            }
+            else {
+                token.tableDTT.lofilt[cnt + aSize + 1] = this.intSign(cnt + 1) * aHifilt[cnt];
+                token.tableDTT.lofilt[aSize - cnt] = token.tableDTT.lofilt[cnt + aSize + 1];
+            }
+        }
+        token.tableDTT.lodef = 1;
+        token.tableDTT.hidef = 1;
+    }
+    intSign(power) {
+        let num = -1;
+        if (power == 0)
+            return 1;
+        for (let cnt = 1; cnt < power; cnt++)
+            num *= -1;
+        return num;
+    }
+}
+/**
+ * Convert Wavelet Scalar Quantization (`.wsq`) to PNG
+ * @param data WSQ buffer
+ */
+export const wsqToPNG = (data) => {
+    const grayscale = new WSQDecoder().decode(data);
+    const rgba = new Uint8Array(grayscale.width * grayscale.height * 4);
+    for (let i = 0; i < grayscale.width * grayscale.height; i++) {
+        rgba[i * 4 + 0] = grayscale.pixels[i];
+        rgba[i * 4 + 1] = grayscale.pixels[i];
+        rgba[i * 4 + 2] = grayscale.pixels[i];
+        rgba[i * 4 + 3] = 255;
+    }
+    return new Uint8Array(UPNG.encode([rgba.buffer], grayscale.width, grayscale.height, 0));
+};