@li0ard/wsq 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nikolai Konovalov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# @li0ard/wsq
+
+Convert Wavelet Scalar Quantization (WSQ) to PNG
+
+### Example
+
+```ts
+import { wsqToPNG } from "@li0ard/wsq";
+
+const wsq = new Uint8Array([ /* ... */]);
+
+console.log(wsqToPNG(wsq));
+```

package/dist/bitmap.d.ts

@@ -0,0 +1,11 @@
+export declare class BitmapWithMetadata {
+    readonly pixels: Uint8Array;
+    readonly width: number;
+    readonly height: number;
+    readonly ppi: number;
+    readonly depth: number;
+    readonly lossyflag: number;
+    readonly metadata: Map<string, string>;
+    readonly comments: string[];
+    constructor(pixels: Uint8Array, width: number, height: number, ppi: number, depth: number, lossyflag: number, metadata?: Map<string, string> | null, ...comments: (string | null | undefined)[]);
+}

package/dist/bitmap.js

@@ -0,0 +1,30 @@
+export class BitmapWithMetadata {
+    pixels;
+    width;
+    height;
+    ppi;
+    depth;
+    lossyflag;
+    metadata;
+    comments;
+    constructor(pixels, width, height, ppi, depth, lossyflag, metadata, ...comments) {
+        this.pixels = pixels;
+        this.width = width;
+        this.height = height;
+        this.ppi = ppi;
+        this.depth = depth;
+        this.lossyflag = lossyflag;
+        this.metadata = new Map();
+        this.comments = [];
+        if (metadata) {
+            for (const [k, v] of metadata.entries())
+                this.metadata.set(k, v);
+        }
+        if (comments) {
+            for (const c of comments) {
+                if (c != null)
+                    this.comments.push(c);
+            }
+        }
+    }
+}

package/dist/const.d.ts

@@ -0,0 +1,114 @@
+export declare const NCM_HEADER = "NIST_COM";
+export declare const NCM_PIX_WIDTH = "PIX_WIDTH";
+export declare const NCM_PIX_HEIGHT = "PIX_HEIGHT";
+export declare const NCM_PIX_DEPTH = "PIX_DEPTH";
+export declare const NCM_PPI = "PPI";
+export declare const NCM_COLORSPACE = "COLORSPACE";
+export declare const NCM_COMPRESSION = "COMPRESSION";
+export declare const NCM_LOSSY = "LOSSY";
+export declare const BITMASK: Uint8Array;
+export declare const MAX_HUFFBITS = 16;
+export declare const MAX_HUFFCOUNTS_WSQ = 256;
+export declare const W_TREELEN = 20;
+export declare const Q_TREELEN = 64;
+export declare const SOI_WSQ = 65440;
+export declare const EOI_WSQ = 65441;
+export declare const SOF_WSQ = 65442;
+export declare const SOB_WSQ = 65443;
+export declare const DTT_WSQ = 65444;
+export declare const DQT_WSQ = 65445;
+export declare const DHT_WSQ = 65446;
+export declare const DRT_WSQ = 65447;
+export declare const COM_WSQ = 65448;
+export declare const MAX_SUBBANDS = 64;
+export declare const NUM_SUBBANDS = 60;
+export declare const ANY_WSQ = 65535;
+export declare const TBLS_N_SOF = 2;
+export declare const TBLS_N_SOB: number;
+export declare class WavletTree {
+    x: number;
+    y: number;
+    lenx: number;
+    leny: number;
+    invrw: number;
+    invcl: number;
+}
+export declare class TableDTT {
+    static HI_FILT_EVEN_8X8_1: Float32Array<ArrayBuffer>;
+    static LO_FILT_EVEN_8X8_1: Float32Array<ArrayBuffer>;
+    static HI_FILT_NOT_EVEN_8X8_1: Float32Array<ArrayBuffer>;
+    static LO_FILT_NOT_EVEN_8X8_1: Float32Array<ArrayBuffer>;
+    lofilt: Float32Array<ArrayBuffer>;
+    hifilt: Float32Array<ArrayBuffer>;
+    losz: number;
+    hisz: number;
+    lodef: number;
+    hidef: number;
+}
+export declare class HuffCode {
+    size: number;
+    code: number;
+}
+export declare class HeaderFrm {
+    black: number;
+    white: number;
+    width: number;
+    height: number;
+    mShift: number;
+    rScale: number;
+    wsqEncoder: number;
+    software: number;
+}
+export declare class HuffmanTable {
+    tableLen: number;
+    bytesLeft: number;
+    tableId: number;
+    huffbits: number[];
+    huffvalues: number[];
+}
+export declare class TableDHT {
+    private static readonly MAX_HUFFBITS;
+    private static readonly MAX_HUFFCOUNTS_WSQ;
+    tabdef: number;
+    huffbits: number[];
+    huffvalues: number[];
+}
+export declare class Table_DQT {
+    static readonly MAX_SUBBANDS = 64;
+    binCenter: number;
+    qBin: Float32Array<ArrayBuffer>;
+    zBin: Float32Array<ArrayBuffer>;
+    dqtDef: number;
+}
+export declare class QuantTree {
+    x: number;
+    y: number;
+    lenx: number;
+    leny: number;
+}
+export declare class Quantization {
+    static readonly MAX_SUBBANDS = 64;
+    q: number;
+    cr: number;
+    r: number;
+    qbss_t: Float32Array<ArrayBuffer>;
+    qbss: Float32Array<ArrayBuffer>;
+    qzbs: Float32Array<ArrayBuffer>;
+    var: Float32Array<ArrayBuffer>;
+}
+export declare class Ref<T> {
+    value: T | null;
+    constructor(value?: T | null);
+}
+export declare class Token {
+    static readonly MAX_DHT_TABLES = 8;
+    tableDHT: TableDHT[];
+    tableDTT: TableDTT;
+    tableDQT: Table_DQT;
+    wtree?: WavletTree[];
+    qtree?: QuantTree[];
+    quant_vals: Quantization;
+    comments: string[];
+    constructor();
+}
+export declare const buildWSQTrees: (token: Token, width: number, height: number) => void;

package/dist/const.js

@@ -0,0 +1,446 @@
+export const NCM_HEADER = "NIST_COM"; /* mandatory */
+export const NCM_PIX_WIDTH = "PIX_WIDTH"; /* mandatory */
+export const NCM_PIX_HEIGHT = "PIX_HEIGHT"; /* mandatory */
+export const NCM_PIX_DEPTH = "PIX_DEPTH"; /* 1,8,24 (mandatory)*/
+export const NCM_PPI = "PPI"; /* -1 if unknown (mandatory)*/
+export const NCM_COLORSPACE = "COLORSPACE"; /* RGB,YCbCr,GRAY */
+export const NCM_COMPRESSION = "COMPRESSION"; /* NONE,JPEGB,JPEGL,WSQ */
+export const NCM_LOSSY = "LOSSY"; /* 0,1 */
+export const BITMASK = new Uint8Array([0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff]);
+export const MAX_HUFFBITS = 16;
+export const MAX_HUFFCOUNTS_WSQ = 256;
+export const W_TREELEN = 20;
+export const Q_TREELEN = 64;
+/* WSQ Marker Definitions */
+export const SOI_WSQ = 0xffa0;
+export const EOI_WSQ = 0xffa1;
+export const SOF_WSQ = 0xffa2;
+export const SOB_WSQ = 0xffa3;
+export const DTT_WSQ = 0xffa4;
+export const DQT_WSQ = 0xffa5;
+export const DHT_WSQ = 0xffa6;
+export const DRT_WSQ = 0xffa7;
+export const COM_WSQ = 0xffa8;
+export const MAX_SUBBANDS = 64;
+export const NUM_SUBBANDS = 60;
+/* Case for getting ANY marker. */
+export const ANY_WSQ = 0xffff;
+export const TBLS_N_SOF = 2;
+export const TBLS_N_SOB = TBLS_N_SOF + 2;
+export class WavletTree {
+    x = 0;
+    y = 0;
+    lenx = 0;
+    leny = 0;
+    invrw = 0;
+    invcl = 0;
+}
+export class TableDTT {
+    static HI_FILT_EVEN_8X8_1 = new Float32Array([0.03226944131446922,
+        -0.05261415011924844,
+        -0.18870142780632693,
+        0.60328894481393847,
+        -0.60328894481393847,
+        0.18870142780632693,
+        0.05261415011924844,
+        -0.03226944131446922]);
+    static LO_FILT_EVEN_8X8_1 = new Float32Array([0.07565691101399093,
+        -0.12335584105275092,
+        -0.09789296778409587,
+        0.85269867900940344,
+        0.85269867900940344,
+        -0.09789296778409587,
+        -0.12335584105275092,
+        0.07565691101399093]);
+    static HI_FILT_NOT_EVEN_8X8_1 = new Float32Array([0.06453888262893845,
+        -0.04068941760955844,
+        -0.41809227322221221,
+        0.78848561640566439,
+        -0.41809227322221221,
+        -0.04068941760955844,
+        0.06453888262893845]);
+    static LO_FILT_NOT_EVEN_8X8_1 = new Float32Array([0.03782845550699546,
+        -0.02384946501938000,
+        -0.11062440441842342,
+        0.37740285561265380,
+        0.85269867900940344,
+        0.37740285561265380,
+        -0.11062440441842342,
+        -0.02384946501938000,
+        0.03782845550699546]);
+    lofilt = TableDTT.LO_FILT_NOT_EVEN_8X8_1;
+    hifilt = TableDTT.HI_FILT_NOT_EVEN_8X8_1;
+    losz = 0;
+    hisz = 0;
+    lodef = 0;
+    hidef = 0;
+}
+export class HuffCode {
+    size = 0;
+    code = 0;
+}
+export class HeaderFrm {
+    black = 0;
+    white = 0;
+    width = 0;
+    height = 0;
+    mShift = 0;
+    rScale = 0;
+    wsqEncoder = 0;
+    software = 0;
+}
+export class HuffmanTable {
+    tableLen = 0;
+    bytesLeft = 0;
+    tableId = 0;
+    huffbits = [];
+    huffvalues = [];
+}
+export class TableDHT {
+    static MAX_HUFFBITS = MAX_HUFFBITS;
+    static MAX_HUFFCOUNTS_WSQ = MAX_HUFFCOUNTS_WSQ;
+    tabdef = 0;
+    huffbits = new Array(TableDHT.MAX_HUFFBITS).fill(0);
+    huffvalues = new Array(TableDHT.MAX_HUFFCOUNTS_WSQ + 1).fill(0);
+}
+export class Table_DQT {
+    static MAX_SUBBANDS = 64;
+    binCenter = 0;
+    qBin = new Float32Array(Table_DQT.MAX_SUBBANDS);
+    zBin = new Float32Array(Table_DQT.MAX_SUBBANDS);
+    dqtDef = 0;
+}
+export class QuantTree {
+    x = 0;
+    y = 0;
+    lenx = 0;
+    leny = 0;
+}
+export class Quantization {
+    static MAX_SUBBANDS = 64;
+    q = 0;
+    cr = 0;
+    r = 0;
+    qbss_t = new Float32Array(Quantization.MAX_SUBBANDS);
+    qbss = new Float32Array(Quantization.MAX_SUBBANDS);
+    qzbs = new Float32Array(Quantization.MAX_SUBBANDS);
+    var = new Float32Array(Quantization.MAX_SUBBANDS);
+}
+export class Ref {
+    value;
+    constructor(value = null) {
+        this.value = value;
+    }
+}
+export class Token {
+    static MAX_DHT_TABLES = 8;
+    tableDHT = new Array(Token.MAX_DHT_TABLES);
+    tableDTT = new TableDTT();
+    tableDQT = new Table_DQT();
+    wtree;
+    qtree;
+    quant_vals = new Quantization();
+    comments = [];
+    constructor() {
+        for (let i = 0; i < Token.MAX_DHT_TABLES; i++) {
+            this.tableDHT[i] = new TableDHT();
+            this.tableDHT[i].tabdef = 0;
+        }
+    }
+}
+export const buildWSQTrees = (token, width, height) => {
+    buildWTree(token, W_TREELEN, width, height);
+    buildQTree(token, Q_TREELEN);
+};
+const buildWTree = (token, wtreelen, width, height) => {
+    let lenx, lenx2, leny, leny2;
+    token.wtree = new Array(wtreelen);
+    for (let i = 0; i < wtreelen; i++) {
+        token.wtree[i] = new WavletTree();
+        token.wtree[i].invrw = 0;
+        token.wtree[i].invcl = 0;
+    }
+    token.wtree[2].invrw = 1;
+    token.wtree[4].invrw = 1;
+    token.wtree[7].invrw = 1;
+    token.wtree[9].invrw = 1;
+    token.wtree[11].invrw = 1;
+    token.wtree[13].invrw = 1;
+    token.wtree[16].invrw = 1;
+    token.wtree[18].invrw = 1;
+    token.wtree[3].invcl = 1;
+    token.wtree[5].invcl = 1;
+    token.wtree[8].invcl = 1;
+    token.wtree[9].invcl = 1;
+    token.wtree[12].invcl = 1;
+    token.wtree[13].invcl = 1;
+    token.wtree[17].invcl = 1;
+    token.wtree[18].invcl = 1;
+    wtree4(token, 0, 1, width, height, 0, 0, 1);
+    if ((token.wtree[1].lenx % 2) == 0) {
+        lenx = token.wtree[1].lenx / 2;
+        lenx2 = lenx;
+    }
+    else {
+        lenx = (token.wtree[1].lenx + 1) / 2;
+        lenx2 = lenx - 1;
+    }
+    if ((token.wtree[1].leny % 2) == 0) {
+        leny = token.wtree[1].leny / 2;
+        leny2 = leny;
+    }
+    else {
+        leny = (token.wtree[1].leny + 1) / 2;
+        leny2 = leny - 1;
+    }
+    wtree4(token, 4, 6, lenx2, leny, lenx, 0, 0);
+    wtree4(token, 5, 10, lenx, leny2, 0, leny, 0);
+    wtree4(token, 14, 15, lenx, leny, 0, 0, 0);
+    token.wtree[19].x = 0;
+    token.wtree[19].y = 0;
+    if ((token.wtree[15].lenx % 2) == 0)
+        token.wtree[19].lenx = token.wtree[15].lenx / 2;
+    else
+        token.wtree[19].lenx = (token.wtree[15].lenx + 1) / 2;
+    if ((token.wtree[15].leny % 2) == 0)
+        token.wtree[19].leny = token.wtree[15].leny / 2;
+    else
+        token.wtree[19].leny = (token.wtree[15].leny + 1) / 2;
+};
+const wtree4 = (token, start1, start2, lenx, leny, x, y, stop1) => {
+    let p1 = start1, p2 = start2;
+    let evenx = lenx % 2, eveny = leny % 2;
+    if (!token.wtree)
+        return;
+    token.wtree[p1].x = x;
+    token.wtree[p1].y = y;
+    token.wtree[p1].lenx = lenx;
+    token.wtree[p1].leny = leny;
+    token.wtree[p2].x = x;
+    token.wtree[p2 + 2].x = x;
+    token.wtree[p2].y = y;
+    token.wtree[p2 + 1].y = y;
+    if (evenx == 0) {
+        token.wtree[p2].lenx = lenx / 2;
+        token.wtree[p2 + 1].lenx = token.wtree[p2].lenx;
+    }
+    else {
+        if (p1 == 4) {
+            token.wtree[p2].lenx = (lenx - 1) / 2;
+            token.wtree[p2 + 1].lenx = token.wtree[p2].lenx + 1;
+        }
+        else {
+            token.wtree[p2].lenx = (lenx + 1) / 2;
+            token.wtree[p2 + 1].lenx = token.wtree[p2].lenx - 1;
+        }
+    }
+    token.wtree[p2 + 1].x = token.wtree[p2].lenx + x;
+    if (stop1 == 0) {
+        token.wtree[p2 + 3].lenx = token.wtree[p2 + 1].lenx;
+        token.wtree[p2 + 3].x = token.wtree[p2 + 1].x;
+    }
+    token.wtree[p2 + 2].lenx = token.wtree[p2].lenx;
+    if (eveny == 0) {
+        token.wtree[p2].leny = leny / 2;
+        token.wtree[p2 + 2].leny = token.wtree[p2].leny;
+    }
+    else {
+        if (p1 == 5) {
+            token.wtree[p2].leny = (leny - 1) / 2;
+            token.wtree[p2 + 2].leny = token.wtree[p2].leny + 1;
+        }
+        else {
+            token.wtree[p2].leny = (leny + 1) / 2;
+            token.wtree[p2 + 2].leny = token.wtree[p2].leny - 1;
+        }
+    }
+    token.wtree[p2 + 2].y = token.wtree[p2].leny + y;
+    if (stop1 == 0) {
+        token.wtree[p2 + 3].leny = token.wtree[p2 + 2].leny;
+        token.wtree[p2 + 3].y = token.wtree[p2 + 2].y;
+    }
+    token.wtree[p2 + 1].leny = token.wtree[p2].leny;
+};
+const buildQTree = (token, qtreelen) => {
+    token.qtree = new Array(qtreelen);
+    for (let i = 0; i < token.qtree.length; i++)
+        token.qtree[i] = new QuantTree();
+    if (!token.wtree)
+        return;
+    qtree16(token, 3, token.wtree[14].lenx, token.wtree[14].leny, token.wtree[14].x, token.wtree[14].y, 0, 0);
+    qtree16(token, 19, token.wtree[4].lenx, token.wtree[4].leny, token.wtree[4].x, token.wtree[4].y, 0, 1);
+    qtree16(token, 48, token.wtree[0].lenx, token.wtree[0].leny, token.wtree[0].x, token.wtree[0].y, 0, 0);
+    qtree16(token, 35, token.wtree[5].lenx, token.wtree[5].leny, token.wtree[5].x, token.wtree[5].y, 1, 0);
+    qtree4(token, 0, token.wtree[19].lenx, token.wtree[19].leny, token.wtree[19].x, token.wtree[19].y);
+};
+const qtree16 = (token, start, lenx, leny, x, y, rw, cl) => {
+    let tempx, temp2x, tempy, temp2y;
+    if (!token.qtree)
+        return;
+    let p = start, evenx = lenx % 2, eveny = leny % 2;
+    if (evenx == 0) {
+        tempx = lenx / 2;
+        temp2x = tempx;
+    }
+    else {
+        if (cl != 0) {
+            temp2x = (lenx + 1) / 2;
+            tempx = temp2x - 1;
+        }
+        else {
+            tempx = (lenx + 1) / 2;
+            temp2x = tempx - 1;
+        }
+    }
+    if (eveny == 0) {
+        tempy = leny / 2;
+        temp2y = tempy;
+    }
+    else {
+        if (rw != 0) {
+            temp2y = (leny + 1) / 2;
+            tempy = temp2y - 1;
+        }
+        else {
+            tempy = (leny + 1) / 2;
+            temp2y = tempy - 1;
+        }
+    }
+    evenx = tempx % 2;
+    eveny = tempy % 2;
+    token.qtree[p].x = x;
+    token.qtree[p + 2].x = x;
+    token.qtree[p].y = y;
+    token.qtree[p + 1].y = y;
+    if (evenx == 0) {
+        token.qtree[p].lenx = tempx / 2;
+        token.qtree[p + 1].lenx = token.qtree[p].lenx;
+        token.qtree[p + 2].lenx = token.qtree[p].lenx;
+        token.qtree[p + 3].lenx = token.qtree[p].lenx;
+    }
+    else {
+        token.qtree[p].lenx = (tempx + 1) / 2;
+        token.qtree[p + 1].lenx = token.qtree[p].lenx - 1;
+        token.qtree[p + 2].lenx = token.qtree[p].lenx;
+        token.qtree[p + 3].lenx = token.qtree[p + 1].lenx;
+    }
+    token.qtree[p + 1].x = x + token.qtree[p].lenx;
+    token.qtree[p + 3].x = token.qtree[p + 1].x;
+    if (eveny == 0) {
+        token.qtree[p].leny = tempy / 2;
+        token.qtree[p + 1].leny = token.qtree[p].leny;
+        token.qtree[p + 2].leny = token.qtree[p].leny;
+        token.qtree[p + 3].leny = token.qtree[p].leny;
+    }
+    else {
+        token.qtree[p].leny = (tempy + 1) / 2;
+        token.qtree[p + 1].leny = token.qtree[p].leny;
+        token.qtree[p + 2].leny = token.qtree[p].leny - 1;
+        token.qtree[p + 3].leny = token.qtree[p + 2].leny;
+    }
+    token.qtree[p + 2].y = y + token.qtree[p].leny;
+    token.qtree[p + 3].y = token.qtree[p + 2].y;
+    evenx = temp2x % 2;
+    token.qtree[p + 4].x = x + tempx;
+    token.qtree[p + 6].x = token.qtree[p + 4].x;
+    token.qtree[p + 4].y = y;
+    token.qtree[p + 5].y = y;
+    token.qtree[p + 6].y = token.qtree[p + 2].y;
+    token.qtree[p + 7].y = token.qtree[p + 2].y;
+    token.qtree[p + 4].leny = token.qtree[p].leny;
+    token.qtree[p + 5].leny = token.qtree[p].leny;
+    token.qtree[p + 6].leny = token.qtree[p + 2].leny;
+    token.qtree[p + 7].leny = token.qtree[p + 2].leny;
+    if (evenx == 0) {
+        token.qtree[p + 4].lenx = temp2x / 2;
+        token.qtree[p + 5].lenx = token.qtree[p + 4].lenx;
+        token.qtree[p + 6].lenx = token.qtree[p + 4].lenx;
+        token.qtree[p + 7].lenx = token.qtree[p + 4].lenx;
+    }
+    else {
+        token.qtree[p + 5].lenx = (temp2x + 1) / 2;
+        token.qtree[p + 4].lenx = token.qtree[p + 5].lenx - 1;
+        token.qtree[p + 6].lenx = token.qtree[p + 4].lenx;
+        token.qtree[p + 7].lenx = token.qtree[p + 5].lenx;
+    }
+    token.qtree[p + 5].x = token.qtree[p + 4].x + token.qtree[p + 4].lenx;
+    token.qtree[p + 7].x = token.qtree[p + 5].x;
+    eveny = temp2y % 2;
+    token.qtree[p + 8].x = x;
+    token.qtree[p + 9].x = token.qtree[p + 1].x;
+    token.qtree[p + 10].x = x;
+    token.qtree[p + 11].x = token.qtree[p + 1].x;
+    token.qtree[p + 8].y = y + tempy;
+    token.qtree[p + 9].y = token.qtree[p + 8].y;
+    token.qtree[p + 8].lenx = token.qtree[p].lenx;
+    token.qtree[p + 9].lenx = token.qtree[p + 1].lenx;
+    token.qtree[p + 10].lenx = token.qtree[p].lenx;
+    token.qtree[p + 11].lenx = token.qtree[p + 1].lenx;
+    if (eveny == 0) {
+        token.qtree[p + 8].leny = temp2y / 2;
+        token.qtree[p + 9].leny = token.qtree[p + 8].leny;
+        token.qtree[p + 10].leny = token.qtree[p + 8].leny;
+        token.qtree[p + 11].leny = token.qtree[p + 8].leny;
+    }
+    else {
+        token.qtree[p + 10].leny = (temp2y + 1) / 2;
+        token.qtree[p + 11].leny = token.qtree[p + 10].leny;
+        token.qtree[p + 8].leny = token.qtree[p + 10].leny - 1;
+        token.qtree[p + 9].leny = token.qtree[p + 8].leny;
+    }
+    token.qtree[p + 10].y = token.qtree[p + 8].y + token.qtree[p + 8].leny;
+    token.qtree[p + 11].y = token.qtree[p + 10].y;
+    token.qtree[p + 12].x = token.qtree[p + 4].x;
+    token.qtree[p + 13].x = token.qtree[p + 5].x;
+    token.qtree[p + 14].x = token.qtree[p + 4].x;
+    token.qtree[p + 15].x = token.qtree[p + 5].x;
+    token.qtree[p + 12].y = token.qtree[p + 8].y;
+    token.qtree[p + 13].y = token.qtree[p + 8].y;
+    token.qtree[p + 14].y = token.qtree[p + 10].y;
+    token.qtree[p + 15].y = token.qtree[p + 10].y;
+    token.qtree[p + 12].lenx = token.qtree[p + 4].lenx;
+    token.qtree[p + 13].lenx = token.qtree[p + 5].lenx;
+    token.qtree[p + 14].lenx = token.qtree[p + 4].lenx;
+    token.qtree[p + 15].lenx = token.qtree[p + 5].lenx;
+    token.qtree[p + 12].leny = token.qtree[p + 8].leny;
+    token.qtree[p + 13].leny = token.qtree[p + 8].leny;
+    token.qtree[p + 14].leny = token.qtree[p + 10].leny;
+    token.qtree[p + 15].leny = token.qtree[p + 10].leny;
+};
+const qtree4 = (token, start, lenx, leny, x, y) => {
+    let p = start, evenx = lenx % 2, eveny = leny % 2;
+    if (!token.qtree)
+        return;
+    token.qtree[p].x = x;
+    token.qtree[p + 2].x = x;
+    token.qtree[p].y = y;
+    token.qtree[p + 1].y = y;
+    if (evenx == 0) {
+        token.qtree[p].lenx = lenx / 2;
+        token.qtree[p + 1].lenx = token.qtree[p].lenx;
+        token.qtree[p + 2].lenx = token.qtree[p].lenx;
+        token.qtree[p + 3].lenx = token.qtree[p].lenx;
+    }
+    else {
+        token.qtree[p].lenx = (lenx + 1) / 2;
+        token.qtree[p + 1].lenx = token.qtree[p].lenx - 1;
+        token.qtree[p + 2].lenx = token.qtree[p].lenx;
+        token.qtree[p + 3].lenx = token.qtree[p + 1].lenx;
+    }
+    token.qtree[p + 1].x = x + token.qtree[p].lenx;
+    token.qtree[p + 3].x = token.qtree[p + 1].x;
+    if (eveny == 0) {
+        token.qtree[p].leny = leny / 2;
+        token.qtree[p + 1].leny = token.qtree[p].leny;
+        token.qtree[p + 2].leny = token.qtree[p].leny;
+        token.qtree[p + 3].leny = token.qtree[p].leny;
+    }
+    else {
+        token.qtree[p].leny = (leny + 1) / 2;
+        token.qtree[p + 1].leny = token.qtree[p].leny;
+        token.qtree[p + 2].leny = token.qtree[p].leny - 1;
+        token.qtree[p + 3].leny = token.qtree[p + 2].leny;
+    }
+    token.qtree[p + 2].y = y + token.qtree[p].leny;
+    token.qtree[p + 3].y = token.qtree[p + 2].y;
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert Wavelet Scalar Quantization (`.wsq`) to PNG
+ * @param data WSQ buffer
+ */
+export declare const wsqToPNG: (data: Uint8Array) => Uint8Array;