@yft-design/psd-lib 1.0.1

package/dist/jpeg.js

@@ -0,0 +1,1017 @@
+// based on https://github.com/jpeg-js/jpeg-js
+/*
+   Copyright 2011 notmasteryet
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+const dctZigZag = new Int32Array([
+    0,
+    1, 8,
+    16, 9, 2,
+    3, 10, 17, 24,
+    32, 25, 18, 11, 4,
+    5, 12, 19, 26, 33, 40,
+    48, 41, 34, 27, 20, 13, 6,
+    7, 14, 21, 28, 35, 42, 49, 56,
+    57, 50, 43, 36, 29, 22, 15,
+    23, 30, 37, 44, 51, 58,
+    59, 52, 45, 38, 31,
+    39, 46, 53, 60,
+    61, 54, 47,
+    55, 62,
+    63
+]);
+const dctCos1 = 4017; // cos(pi/16)
+const dctSin1 = 799; // sin(pi/16)
+const dctCos3 = 3406; // cos(3*pi/16)
+const dctSin3 = 2276; // sin(3*pi/16)
+const dctCos6 = 1567; // cos(6*pi/16)
+const dctSin6 = 3784; // sin(6*pi/16)
+const dctSqrt2 = 5793; // sqrt(2)
+const dctSqrt1d2 = 2896; // sqrt(2) / 2
+const maxResolutionInMP = 100; // Don't decode more than 100 megapixels
+const maxMemoryUsageBytes = 64 * 1024 * 1024; // Don't decode if memory footprint is more than 64MB
+let totalBytesAllocated = 0; // avoid unexpected OOMs from untrusted content.
+function requestMemoryAllocation(increaseAmount) {
+    const totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;
+    if (totalMemoryImpactBytes > maxMemoryUsageBytes) {
+        const exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);
+        throw new Error(`Max memory limit exceeded by at least ${exceededAmount}MB`);
+    }
+    totalBytesAllocated = totalMemoryImpactBytes;
+}
+function buildHuffmanTable(codeLengths, values) {
+    let length = 16;
+    while (length > 0 && !codeLengths[length - 1])
+        length--;
+    const code = [{ children: [], index: 0 }];
+    let k = 0;
+    let p = code[0];
+    for (let i = 0; i < length; i++) {
+        for (let j = 0; j < codeLengths[i]; j++) {
+            p = code.pop();
+            p.children[p.index] = values[k];
+            while (p.index > 0) {
+                if (code.length === 0)
+                    throw new Error('Could not recreate Huffman Table');
+                p = code.pop();
+            }
+            p.index++;
+            code.push(p);
+            while (code.length <= i) {
+                const q = { children: [], index: 0 };
+                code.push(q);
+                p.children[p.index] = q.children;
+                p = q;
+            }
+            k++;
+        }
+        if (i + 1 < length) {
+            // p here points to last code
+            const q = { children: [], index: 0 };
+            code.push(q);
+            p.children[p.index] = q.children;
+            p = q;
+        }
+    }
+    return code[0].children;
+}
+function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive) {
+    const mcusPerLine = frame.mcusPerLine;
+    const progressive = frame.progressive;
+    const startOffset = offset;
+    let bitsData = 0;
+    let bitsCount = 0;
+    function readBit() {
+        if (bitsCount > 0) {
+            bitsCount--;
+            return (bitsData >> bitsCount) & 1;
+        }
+        bitsData = data[offset++];
+        if (bitsData == 0xFF) {
+            const nextByte = data[offset++];
+            if (nextByte)
+                throw new Error(`unexpected marker: ${((bitsData << 8) | nextByte).toString(16)}`);
+            // unstuff 0
+        }
+        bitsCount = 7;
+        return bitsData >>> 7;
+    }
+    function decodeHuffman(tree) {
+        let node = tree;
+        while (true) {
+            node = node[readBit()];
+            if (typeof node === 'number')
+                return node;
+            if (node === undefined)
+                throw new Error('invalid huffman sequence');
+        }
+    }
+    function receive(length) {
+        let n = 0;
+        while (length > 0) {
+            n = (n << 1) | readBit();
+            length--;
+        }
+        return n;
+    }
+    function receiveAndExtend(length) {
+        let n = receive(length);
+        if (n >= 1 << (length - 1))
+            return n;
+        return n + (-1 << length) + 1;
+    }
+    function decodeBaseline(component, zz) {
+        const t = decodeHuffman(component.huffmanTableDC);
+        const diff = t === 0 ? 0 : receiveAndExtend(t);
+        zz[0] = (component.pred += diff);
+        let k = 1;
+        while (k < 64) {
+            const rs = decodeHuffman(component.huffmanTableAC);
+            const s = rs & 15;
+            const r = rs >> 4;
+            if (s === 0) {
+                if (r < 15)
+                    break;
+                k += 16;
+                continue;
+            }
+            k += r;
+            const z = dctZigZag[k];
+            zz[z] = receiveAndExtend(s);
+            k++;
+        }
+    }
+    function decodeDCFirst(component, zz) {
+        const t = decodeHuffman(component.huffmanTableDC);
+        const diff = t === 0 ? 0 : (receiveAndExtend(t) << successive);
+        zz[0] = (component.pred += diff);
+    }
+    function decodeDCSuccessive(_component, zz) {
+        zz[0] |= readBit() << successive;
+    }
+    let eobrun = 0;
+    function decodeACFirst(component, zz) {
+        if (eobrun > 0) {
+            eobrun--;
+            return;
+        }
+        let k = spectralStart, e = spectralEnd;
+        while (k <= e) {
+            const rs = decodeHuffman(component.huffmanTableAC);
+            const s = rs & 15;
+            const r = rs >> 4;
+            if (s === 0) {
+                if (r < 15) {
+                    eobrun = receive(r) + (1 << r) - 1;
+                    break;
+                }
+                k += 16;
+                continue;
+            }
+            k += r;
+            const z = dctZigZag[k];
+            zz[z] = receiveAndExtend(s) * (1 << successive);
+            k++;
+        }
+    }
+    let successiveACState = 0;
+    let successiveACNextValue = 0;
+    function decodeACSuccessive(component, zz) {
+        let k = spectralStart;
+        let e = spectralEnd;
+        let r = 0;
+        while (k <= e) {
+            const z = dctZigZag[k];
+            const direction = zz[z] < 0 ? -1 : 1;
+            switch (successiveACState) {
+                case 0: // initial state
+                    const rs = decodeHuffman(component.huffmanTableAC);
+                    const s = rs & 15;
+                    r = rs >> 4; // this was new variable in old code
+                    if (s === 0) {
+                        if (r < 15) {
+                            eobrun = receive(r) + (1 << r);
+                            successiveACState = 4;
+                        }
+                        else {
+                            r = 16;
+                            successiveACState = 1;
+                        }
+                    }
+                    else {
+                        if (s !== 1)
+                            throw new Error('invalid ACn encoding');
+                        successiveACNextValue = receiveAndExtend(s);
+                        successiveACState = r ? 2 : 3;
+                    }
+                    continue;
+                case 1: // skipping r zero items
+                case 2:
+                    if (zz[z]) {
+                        zz[z] += (readBit() << successive) * direction;
+                    }
+                    else {
+                        r--;
+                        if (r === 0)
+                            successiveACState = successiveACState == 2 ? 3 : 0;
+                    }
+                    break;
+                case 3: // set value for a zero item
+                    if (zz[z]) {
+                        zz[z] += (readBit() << successive) * direction;
+                    }
+                    else {
+                        zz[z] = successiveACNextValue << successive;
+                        successiveACState = 0;
+                    }
+                    break;
+                case 4: // eob
+                    if (zz[z]) {
+                        zz[z] += (readBit() << successive) * direction;
+                    }
+                    break;
+            }
+            k++;
+        }
+        if (successiveACState === 4) {
+            eobrun--;
+            if (eobrun === 0)
+                successiveACState = 0;
+        }
+    }
+    function decodeMcu(component, decode, mcu, row, col) {
+        const mcuRow = (mcu / mcusPerLine) | 0;
+        const mcuCol = mcu % mcusPerLine;
+        const blockRow = mcuRow * component.v + row;
+        const blockCol = mcuCol * component.h + col;
+        // If the block is missing, just skip it.
+        if (component.blocks[blockRow] === undefined)
+            return;
+        decode(component, component.blocks[blockRow][blockCol]);
+    }
+    function decodeBlock(component, decode, mcu) {
+        const blockRow = (mcu / component.blocksPerLine) | 0;
+        const blockCol = mcu % component.blocksPerLine;
+        // If the block is missing, just skip it.
+        if (component.blocks[blockRow] === undefined)
+            return;
+        decode(component, component.blocks[blockRow][blockCol]);
+    }
+    const componentsLength = components.length;
+    let component;
+    let decodeFn;
+    if (progressive) {
+        if (spectralStart === 0) {
+            decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
+        }
+        else {
+            decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
+        }
+    }
+    else {
+        decodeFn = decodeBaseline;
+    }
+    let mcu = 0;
+    let mcuExpected;
+    if (componentsLength == 1) {
+        mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
+    }
+    else {
+        mcuExpected = mcusPerLine * frame.mcusPerColumn;
+    }
+    if (!resetInterval)
+        resetInterval = mcuExpected;
+    let h;
+    let v;
+    let marker;
+    while (mcu < mcuExpected) {
+        // reset interval stuff
+        for (let i = 0; i < componentsLength; i++)
+            components[i].pred = 0;
+        eobrun = 0;
+        if (componentsLength == 1) {
+            component = components[0];
+            for (let n = 0; n < resetInterval; n++) {
+                decodeBlock(component, decodeFn, mcu);
+                mcu++;
+            }
+        }
+        else {
+            for (let n = 0; n < resetInterval; n++) {
+                for (let i = 0; i < componentsLength; i++) {
+                    component = components[i];
+                    h = component.h;
+                    v = component.v;
+                    for (let j = 0; j < v; j++) {
+                        for (let k = 0; k < h; k++) {
+                            decodeMcu(component, decodeFn, mcu, j, k);
+                        }
+                    }
+                }
+                mcu++;
+                // If we've reached our expected MCU's, stop decoding
+                if (mcu === mcuExpected)
+                    break;
+            }
+        }
+        if (mcu === mcuExpected) {
+            // Skip trailing bytes at the end of the scan - until we reach the next marker
+            do {
+                if (data[offset] === 0xFF) {
+                    if (data[offset + 1] !== 0x00) {
+                        break;
+                    }
+                }
+                offset += 1;
+            } while (offset < data.length - 2);
+        }
+        // find marker
+        bitsCount = 0;
+        marker = (data[offset] << 8) | data[offset + 1];
+        if (marker < 0xFF00)
+            throw new Error('marker was not found');
+        if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx
+            offset += 2;
+        }
+        else {
+            break;
+        }
+    }
+    return offset - startOffset;
+}
+function buildComponentData(component) {
+    const lines = [];
+    const blocksPerLine = component.blocksPerLine;
+    const blocksPerColumn = component.blocksPerColumn;
+    const samplesPerLine = blocksPerLine << 3;
+    // Only 1 used per invocation of this function and garbage collected after invocation, so no need to account for its memory footprint.
+    const R = new Int32Array(64);
+    const r = new Uint8Array(64);
+    // A port of poppler's IDCT method which in turn is taken from:
+    //   Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz,
+    //   "Practical Fast 1-D DCT Algorithms with 11 Multiplications",
+    //   IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,
+    //   988-991.
+    function quantizeAndInverse(zz, dataOut, dataIn) {
+        const qt = component.quantizationTable;
+        const p = dataIn;
+        // dequant
+        for (let i = 0; i < 64; i++) {
+            p[i] = zz[i] * qt[i];
+        }
+        // inverse DCT on rows
+        for (let i = 0; i < 8; ++i) {
+            const row = 8 * i;
+            // check for all-zero AC coefficients
+            if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 &&
+                p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 &&
+                p[7 + row] == 0) {
+                const t = (dctSqrt2 * p[0 + row] + 512) >> 10;
+                p[0 + row] = t;
+                p[1 + row] = t;
+                p[2 + row] = t;
+                p[3 + row] = t;
+                p[4 + row] = t;
+                p[5 + row] = t;
+                p[6 + row] = t;
+                p[7 + row] = t;
+                continue;
+            }
+            // stage 4
+            let v0 = (dctSqrt2 * p[0 + row] + 128) >> 8;
+            let v1 = (dctSqrt2 * p[4 + row] + 128) >> 8;
+            let v2 = p[2 + row];
+            let v3 = p[6 + row];
+            let v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8;
+            let v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8;
+            let v5 = p[3 + row] << 4;
+            let v6 = p[5 + row] << 4;
+            // stage 3
+            let t = (v0 - v1 + 1) >> 1;
+            v0 = (v0 + v1 + 1) >> 1;
+            v1 = t;
+            t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8;
+            v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8;
+            v3 = t;
+            t = (v4 - v6 + 1) >> 1;
+            v4 = (v4 + v6 + 1) >> 1;
+            v6 = t;
+            t = (v7 + v5 + 1) >> 1;
+            v5 = (v7 - v5 + 1) >> 1;
+            v7 = t;
+            // stage 2
+            t = (v0 - v3 + 1) >> 1;
+            v0 = (v0 + v3 + 1) >> 1;
+            v3 = t;
+            t = (v1 - v2 + 1) >> 1;
+            v1 = (v1 + v2 + 1) >> 1;
+            v2 = t;
+            t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
+            v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
+            v7 = t;
+            t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
+            v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
+            v6 = t;
+            // stage 1
+            p[0 + row] = v0 + v7;
+            p[7 + row] = v0 - v7;
+            p[1 + row] = v1 + v6;
+            p[6 + row] = v1 - v6;
+            p[2 + row] = v2 + v5;
+            p[5 + row] = v2 - v5;
+            p[3 + row] = v3 + v4;
+            p[4 + row] = v3 - v4;
+        }
+        // inverse DCT on columns
+        for (let i = 0; i < 8; ++i) {
+            const col = i;
+            // check for all-zero AC coefficients
+            if (p[1 * 8 + col] == 0 && p[2 * 8 + col] == 0 && p[3 * 8 + col] == 0 &&
+                p[4 * 8 + col] == 0 && p[5 * 8 + col] == 0 && p[6 * 8 + col] == 0 &&
+                p[7 * 8 + col] == 0) {
+                const t = (dctSqrt2 * dataIn[i + 0] + 8192) >> 14;
+                p[0 * 8 + col] = t;
+                p[1 * 8 + col] = t;
+                p[2 * 8 + col] = t;
+                p[3 * 8 + col] = t;
+                p[4 * 8 + col] = t;
+                p[5 * 8 + col] = t;
+                p[6 * 8 + col] = t;
+                p[7 * 8 + col] = t;
+                continue;
+            }
+            // stage 4
+            let v0 = (dctSqrt2 * p[0 * 8 + col] + 2048) >> 12;
+            let v1 = (dctSqrt2 * p[4 * 8 + col] + 2048) >> 12;
+            let v2 = p[2 * 8 + col];
+            let v3 = p[6 * 8 + col];
+            let v4 = (dctSqrt1d2 * (p[1 * 8 + col] - p[7 * 8 + col]) + 2048) >> 12;
+            let v7 = (dctSqrt1d2 * (p[1 * 8 + col] + p[7 * 8 + col]) + 2048) >> 12;
+            let v5 = p[3 * 8 + col];
+            let v6 = p[5 * 8 + col];
+            // stage 3
+            let t = (v0 - v1 + 1) >> 1;
+            v0 = (v0 + v1 + 1) >> 1;
+            v1 = t;
+            t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12;
+            v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12;
+            v3 = t;
+            t = (v4 - v6 + 1) >> 1;
+            v4 = (v4 + v6 + 1) >> 1;
+            v6 = t;
+            t = (v7 + v5 + 1) >> 1;
+            v5 = (v7 - v5 + 1) >> 1;
+            v7 = t;
+            // stage 2
+            t = (v0 - v3 + 1) >> 1;
+            v0 = (v0 + v3 + 1) >> 1;
+            v3 = t;
+            t = (v1 - v2 + 1) >> 1;
+            v1 = (v1 + v2 + 1) >> 1;
+            v2 = t;
+            t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
+            v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
+            v7 = t;
+            t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
+            v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
+            v6 = t;
+            // stage 1
+            p[0 * 8 + col] = v0 + v7;
+            p[7 * 8 + col] = v0 - v7;
+            p[1 * 8 + col] = v1 + v6;
+            p[6 * 8 + col] = v1 - v6;
+            p[2 * 8 + col] = v2 + v5;
+            p[5 * 8 + col] = v2 - v5;
+            p[3 * 8 + col] = v3 + v4;
+            p[4 * 8 + col] = v3 - v4;
+        }
+        // convert to 8-bit integers
+        for (let i = 0; i < 64; ++i) {
+            const sample = 128 + ((p[i] + 8) >> 4);
+            dataOut[i] = sample < 0 ? 0 : sample > 0xFF ? 0xFF : sample;
+        }
+    }
+    requestMemoryAllocation(samplesPerLine * blocksPerColumn * 8);
+    for (let blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
+        const scanLine = blockRow << 3;
+        for (let i = 0; i < 8; i++)
+            lines.push(new Uint8Array(samplesPerLine));
+        for (let blockCol = 0; blockCol < blocksPerLine; blockCol++) {
+            quantizeAndInverse(component.blocks[blockRow][blockCol], r, R);
+            let offset = 0;
+            const sample = blockCol << 3;
+            for (let j = 0; j < 8; j++) {
+                const line = lines[scanLine + j];
+                for (let i = 0; i < 8; i++)
+                    line[sample + i] = r[offset++];
+            }
+        }
+    }
+    return lines;
+}
+function clampTo8bit(a) {
+    return a < 0 ? 0 : a > 255 ? 255 : a;
+}
+function parse(data) {
+    const self = {
+        width: 0,
+        height: 0,
+        comments: [],
+        adobe: undefined,
+        components: [],
+        exifBuffer: undefined,
+        jfif: undefined,
+    };
+    const maxResolutionInPixels = maxResolutionInMP * 1000 * 1000;
+    let offset = 0;
+    function readUint16() {
+        const value = (data[offset] << 8) | data[offset + 1];
+        offset += 2;
+        return value;
+    }
+    function readDataBlock() {
+        const length = readUint16();
+        const array = data.subarray(offset, offset + length - 2);
+        offset += array.length;
+        return array;
+    }
+    function prepareComponents(frame) {
+        let maxH = 0, maxV = 0;
+        for (let componentId in frame.components) {
+            if (frame.components.hasOwnProperty(componentId)) {
+                const component = frame.components[componentId];
+                if (maxH < component.h)
+                    maxH = component.h;
+                if (maxV < component.v)
+                    maxV = component.v;
+            }
+        }
+        const mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH);
+        const mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV);
+        for (let componentId in frame.components) {
+            if (frame.components.hasOwnProperty(componentId)) {
+                const component = frame.components[componentId];
+                const blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH);
+                const blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV);
+                const blocksPerLineForMcu = mcusPerLine * component.h;
+                const blocksPerColumnForMcu = mcusPerColumn * component.v;
+                const blocksToAllocate = blocksPerColumnForMcu * blocksPerLineForMcu;
+                const blocks = [];
+                // Each block is a Int32Array of length 64 (4 x 64 = 256 bytes)
+                requestMemoryAllocation(blocksToAllocate * 256);
+                for (let i = 0; i < blocksPerColumnForMcu; i++) {
+                    const row = [];
+                    for (let j = 0; j < blocksPerLineForMcu; j++) {
+                        row.push(new Int32Array(64));
+                    }
+                    blocks.push(row);
+                }
+                component.blocksPerLine = blocksPerLine;
+                component.blocksPerColumn = blocksPerColumn;
+                component.blocks = blocks;
+            }
+        }
+        frame.maxH = maxH;
+        frame.maxV = maxV;
+        frame.mcusPerLine = mcusPerLine;
+        frame.mcusPerColumn = mcusPerColumn;
+    }
+    let jfif = null;
+    let adobe = null;
+    let frame = undefined;
+    let resetInterval = 0;
+    let quantizationTables = [];
+    let frames = [];
+    let huffmanTablesAC = [];
+    let huffmanTablesDC = [];
+    let fileMarker = readUint16();
+    let malformedDataOffset = -1;
+    if (fileMarker != 0xFFD8) { // SOI (Start of Image)
+        throw new Error('SOI not found');
+    }
+    fileMarker = readUint16();
+    while (fileMarker != 0xFFD9) { // EOI (End of image)
+        switch (fileMarker) {
+            case 0xFF00: break;
+            case 0xFFE0: // APP0 (Application Specific)
+            case 0xFFE1: // APP1
+            case 0xFFE2: // APP2
+            case 0xFFE3: // APP3
+            case 0xFFE4: // APP4
+            case 0xFFE5: // APP5
+            case 0xFFE6: // APP6
+            case 0xFFE7: // APP7
+            case 0xFFE8: // APP8
+            case 0xFFE9: // APP9
+            case 0xFFEA: // APP10
+            case 0xFFEB: // APP11
+            case 0xFFEC: // APP12
+            case 0xFFED: // APP13
+            case 0xFFEE: // APP14
+            case 0xFFEF: // APP15
+            case 0xFFFE: { // COM (Comment)
+                const appData = readDataBlock();
+                if (fileMarker === 0xFFFE) {
+                    let comment = '';
+                    for (let ii = 0; ii < appData.byteLength; ii++) {
+                        comment += String.fromCharCode(appData[ii]);
+                    }
+                    self.comments.push(comment);
+                }
+                if (fileMarker === 0xFFE0) {
+                    if (appData[0] === 0x4A && appData[1] === 0x46 && appData[2] === 0x49 &&
+                        appData[3] === 0x46 && appData[4] === 0) { // 'JFIF\x00'
+                        jfif = {
+                            version: { major: appData[5], minor: appData[6] },
+                            densityUnits: appData[7],
+                            xDensity: (appData[8] << 8) | appData[9],
+                            yDensity: (appData[10] << 8) | appData[11],
+                            thumbWidth: appData[12],
+                            thumbHeight: appData[13],
+                            thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])
+                        };
+                    }
+                }
+                // TODO APP1 - Exif
+                if (fileMarker === 0xFFE1) {
+                    if (appData[0] === 0x45 &&
+                        appData[1] === 0x78 &&
+                        appData[2] === 0x69 &&
+                        appData[3] === 0x66 &&
+                        appData[4] === 0) { // 'EXIF\x00'
+                        self.exifBuffer = appData.subarray(5, appData.length);
+                    }
+                }
+                if (fileMarker === 0xFFEE) {
+                    if (appData[0] === 0x41 && appData[1] === 0x64 && appData[2] === 0x6F &&
+                        appData[3] === 0x62 && appData[4] === 0x65 && appData[5] === 0) { // 'Adobe\x00'
+                        adobe = {
+                            version: appData[6],
+                            flags0: (appData[7] << 8) | appData[8],
+                            flags1: (appData[9] << 8) | appData[10],
+                            transformCode: appData[11]
+                        };
+                    }
+                }
+                break;
+            }
+            case 0xFFDB: { // DQT (Define Quantization Tables)
+                const quantizationTablesLength = readUint16();
+                const quantizationTablesEnd = quantizationTablesLength + offset - 2;
+                while (offset < quantizationTablesEnd) {
+                    const quantizationTableSpec = data[offset++];
+                    requestMemoryAllocation(64 * 4);
+                    const tableData = new Int32Array(64);
+                    if ((quantizationTableSpec >> 4) === 0) { // 8 bit values
+                        for (let j = 0; j < 64; j++) {
+                            const z = dctZigZag[j];
+                            tableData[z] = data[offset++];
+                        }
+                    }
+                    else if ((quantizationTableSpec >> 4) === 1) { //16 bit
+                        for (let j = 0; j < 64; j++) {
+                            const z = dctZigZag[j];
+                            tableData[z] = readUint16();
+                        }
+                    }
+                    else
+                        throw new Error('DQT: invalid table spec');
+                    quantizationTables[quantizationTableSpec & 15] = tableData;
+                }
+                break;
+            }
+            case 0xFFC0: // SOF0 (Start of Frame, Baseline DCT)
+            case 0xFFC1: // SOF1 (Start of Frame, Extended DCT)
+            case 0xFFC2: { // SOF2 (Start of Frame, Progressive DCT)
+                readUint16(); // skip data length
+                frame = {
+                    extended: (fileMarker === 0xFFC1),
+                    progressive: (fileMarker === 0xFFC2),
+                    precision: data[offset++],
+                    scanLines: readUint16(),
+                    samplesPerLine: readUint16(),
+                    components: {},
+                    componentsOrder: [],
+                    maxH: 0,
+                    maxV: 0,
+                    mcusPerLine: 0,
+                    mcusPerColumn: 0,
+                };
+                const pixelsInFrame = frame.scanLines * frame.samplesPerLine;
+                if (pixelsInFrame > maxResolutionInPixels) {
+                    const exceededAmount = Math.ceil((pixelsInFrame - maxResolutionInPixels) / 1e6);
+                    throw new Error(`maxResolutionInMP limit exceeded by ${exceededAmount}MP`);
+                }
+                const componentsCount = data[offset++];
+                for (let i = 0; i < componentsCount; i++) {
+                    const componentId = data[offset];
+                    const h = data[offset + 1] >> 4;
+                    const v = data[offset + 1] & 15;
+                    const qId = data[offset + 2];
+                    frame.componentsOrder.push(componentId);
+                    frame.components[componentId] = {
+                        h: h,
+                        v: v,
+                        quantizationIdx: qId,
+                        blocksPerColumn: 0,
+                        blocksPerLine: 0,
+                        blocks: [],
+                        pred: 0,
+                    };
+                    offset += 3;
+                }
+                prepareComponents(frame);
+                frames.push(frame);
+                break;
+            }
+            case 0xFFC4: { // DHT (Define Huffman Tables)
+                const huffmanLength = readUint16();
+                for (let i = 2; i < huffmanLength;) {
+                    const huffmanTableSpec = data[offset++];
+                    const codeLengths = new Uint8Array(16);
+                    let codeLengthSum = 0;
+                    for (let j = 0; j < 16; j++, offset++) {
+                        codeLengthSum += (codeLengths[j] = data[offset]);
+                    }
+                    requestMemoryAllocation(16 + codeLengthSum);
+                    const huffmanValues = new Uint8Array(codeLengthSum);
+                    for (let j = 0; j < codeLengthSum; j++, offset++) {
+                        huffmanValues[j] = data[offset];
+                    }
+                    i += 17 + codeLengthSum;
+                    const index = huffmanTableSpec & 15;
+                    const table = (huffmanTableSpec >> 4) === 0 ? huffmanTablesDC : huffmanTablesAC;
+                    table[index] = buildHuffmanTable(codeLengths, huffmanValues);
+                }
+                break;
+            }
+            case 0xFFDD: // DRI (Define Restart Interval)
+                readUint16(); // skip data length
+                resetInterval = readUint16();
+                break;
+            case 0xFFDC: // Number of Lines marker
+                readUint16(); // skip data length
+                readUint16(); // Ignore this data since it represents the image height
+                break;
+            case 0xFFDA: { // SOS (Start of Scan)
+                readUint16(); // skip data length
+                const selectorsCount = data[offset++];
+                const components = [];
+                for (let i = 0; i < selectorsCount; i++) {
+                    const component = frame.components[data[offset++]];
+                    const tableSpec = data[offset++];
+                    component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
+                    component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
+                    components.push(component);
+                }
+                const spectralStart = data[offset++];
+                const spectralEnd = data[offset++];
+                const successiveApproximation = data[offset++];
+                const processed = decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15);
+                offset += processed;
+                break;
+            }
+            case 0xFFFF: // Fill bytes
+                if (data[offset] !== 0xFF) { // Avoid skipping a valid marker.
+                    offset--;
+                }
+                break;
+            default: {
+                if (data[offset - 3] == 0xFF && data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) {
+                    // could be incorrect encoding -- last 0xFF byte of the previous
+                    // block was eaten by the encoder
+                    offset -= 3;
+                    break;
+                }
+                else if (fileMarker === 0xE0 || fileMarker == 0xE1) {
+                    // Recover from malformed APP1 markers popular in some phone models.
+                    // See https://github.com/eugeneware/jpeg-js/issues/82
+                    if (malformedDataOffset !== -1) {
+                        throw new Error(`first unknown JPEG marker at offset ${malformedDataOffset.toString(16)}, second unknown JPEG marker ${fileMarker.toString(16)} at offset ${(offset - 1).toString(16)}`);
+                    }
+                    malformedDataOffset = offset - 1;
+                    const nextOffset = readUint16();
+                    if (data[offset + nextOffset - 2] === 0xFF) {
+                        offset += nextOffset - 2;
+                        break;
+                    }
+                }
+                throw new Error('unknown JPEG marker ' + fileMarker.toString(16));
+            }
+        }
+        fileMarker = readUint16();
+    }
+    if (frames.length != 1)
+        throw new Error('only single frame JPEGs supported');
+    // set each frame's components quantization table
+    for (let i = 0; i < frames.length; i++) {
+        const cp = frames[i].components;
+        for (let j in cp) { // TODO: don't use `in`
+            cp[j].quantizationTable = quantizationTables[cp[j].quantizationIdx];
+            delete cp[j].quantizationIdx; // TODO: why ???
+        }
+    }
+    self.width = frame.samplesPerLine;
+    self.height = frame.scanLines;
+    self.jfif = jfif;
+    self.adobe = adobe;
+    self.components = [];
+    for (let i = 0; i < frame.componentsOrder.length; i++) {
+        const component = frame.components[frame.componentsOrder[i]];
+        self.components.push({
+            lines: buildComponentData(component),
+            scaleX: component.h / frame.maxH,
+            scaleY: component.v / frame.maxV
+        });
+    }
+    return self;
+}
+function getData(decoded) {
+    let offset = 0;
+    let colorTransform = false;
+    const width = decoded.width;
+    const height = decoded.height;
+    const dataLength = width * height * decoded.components.length;
+    requestMemoryAllocation(dataLength);
+    const data = new Uint8Array(dataLength);
+    switch (decoded.components.length) {
+        case 1: {
+            const component1 = decoded.components[0];
+            for (let y = 0; y < height; y++) {
+                const component1Line = component1.lines[0 | (y * component1.scaleY)];
+                for (let x = 0; x < width; x++) {
+                    const Y = component1Line[0 | (x * component1.scaleX)];
+                    data[offset++] = Y;
+                }
+            }
+            break;
+        }
+        case 2: {
+            // PDF might compress two component data in custom colorspace
+            const component1 = decoded.components[0];
+            const component2 = decoded.components[1];
+            for (let y = 0; y < height; y++) {
+                const component1Line = component1.lines[0 | (y * component1.scaleY)];
+                const component2Line = component2.lines[0 | (y * component2.scaleY)];
+                for (let x = 0; x < width; x++) {
+                    const Y1 = component1Line[0 | (x * component1.scaleX)];
+                    data[offset++] = Y1;
+                    const Y2 = component2Line[0 | (x * component2.scaleX)];
+                    data[offset++] = Y2;
+                }
+            }
+            break;
+        }
+        case 3: {
+            // The default transform for three components is true
+            colorTransform = true;
+            // The adobe transform marker overrides any previous setting
+            if (decoded.adobe && decoded.adobe.transformCode)
+                colorTransform = true;
+            const component1 = decoded.components[0];
+            const component2 = decoded.components[1];
+            const component3 = decoded.components[2];
+            for (let y = 0; y < height; y++) {
+                const component1Line = component1.lines[0 | (y * component1.scaleY)];
+                const component2Line = component2.lines[0 | (y * component2.scaleY)];
+                const component3Line = component3.lines[0 | (y * component3.scaleY)];
+                for (let x = 0; x < width; x++) {
+                    let Y, Cb, Cr, R, G, B;
+                    if (!colorTransform) {
+                        R = component1Line[0 | (x * component1.scaleX)];
+                        G = component2Line[0 | (x * component2.scaleX)];
+                        B = component3Line[0 | (x * component3.scaleX)];
+                    }
+                    else {
+                        Y = component1Line[0 | (x * component1.scaleX)];
+                        Cb = component2Line[0 | (x * component2.scaleX)];
+                        Cr = component3Line[0 | (x * component3.scaleX)];
+                        R = clampTo8bit(Y + 1.402 * (Cr - 128));
+                        G = clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
+                        B = clampTo8bit(Y + 1.772 * (Cb - 128));
+                    }
+                    data[offset++] = R;
+                    data[offset++] = G;
+                    data[offset++] = B;
+                }
+            }
+            break;
+        }
+        case 4: {
+            if (!decoded.adobe)
+                throw new Error('Unsupported color mode (4 components)');
+            // The default transform for four components is false
+            colorTransform = false;
+            // The adobe transform marker overrides any previous setting
+            if (decoded.adobe && decoded.adobe.transformCode)
+                colorTransform = true;
+            const component1 = decoded.components[0];
+            const component2 = decoded.components[1];
+            const component3 = decoded.components[2];
+            const component4 = decoded.components[3];
+            for (let y = 0; y < height; y++) {
+                const component1Line = component1.lines[0 | (y * component1.scaleY)];
+                const component2Line = component2.lines[0 | (y * component2.scaleY)];
+                const component3Line = component3.lines[0 | (y * component3.scaleY)];
+                const component4Line = component4.lines[0 | (y * component4.scaleY)];
+                for (let x = 0; x < width; x++) {
+                    let Y, Cb, Cr, K, C, M, Ye;
+                    if (!colorTransform) {
+                        C = component1Line[0 | (x * component1.scaleX)];
+                        M = component2Line[0 | (x * component2.scaleX)];
+                        Ye = component3Line[0 | (x * component3.scaleX)];
+                        K = component4Line[0 | (x * component4.scaleX)];
+                    }
+                    else {
+                        Y = component1Line[0 | (x * component1.scaleX)];
+                        Cb = component2Line[0 | (x * component2.scaleX)];
+                        Cr = component3Line[0 | (x * component3.scaleX)];
+                        K = component4Line[0 | (x * component4.scaleX)];
+                        C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128));
+                        M = 255 - clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
+                        Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128));
+                    }
+                    data[offset++] = 255 - C;
+                    data[offset++] = 255 - M;
+                    data[offset++] = 255 - Ye;
+                    data[offset++] = 255 - K;
+                }
+            }
+            break;
+        }
+        default:
+            throw new Error('Unsupported color mode');
+    }
+    return data;
+}
+export function decodeJpeg(encoded, createImageData) {
+    totalBytesAllocated = 0;
+    if (encoded.length === 0)
+        throw new Error('Empty jpeg buffer');
+    const decoded = parse(encoded);
+    requestMemoryAllocation(decoded.width * decoded.height * 4);
+    const data = getData(decoded);
+    const imageData = createImageData(decoded.width, decoded.height);
+    const width = imageData.width;
+    const height = imageData.height;
+    const imageDataArray = imageData.data;
+    let i = 0;
+    let j = 0;
+    switch (decoded.components.length) {
+        case 1:
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const Y = data[i++];
+                    imageDataArray[j++] = Y;
+                    imageDataArray[j++] = Y;
+                    imageDataArray[j++] = Y;
+                    imageDataArray[j++] = 255;
+                }
+            }
+            break;
+        case 3:
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const R = data[i++];
+                    const G = data[i++];
+                    const B = data[i++];
+                    imageDataArray[j++] = R;
+                    imageDataArray[j++] = G;
+                    imageDataArray[j++] = B;
+                    imageDataArray[j++] = 255;
+                }
+            }
+            break;
+        case 4:
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const C = data[i++];
+                    const M = data[i++];
+                    const Y = data[i++];
+                    const K = data[i++];
+                    const R = 255 - clampTo8bit(C * (1 - K / 255) + K);
+                    const G = 255 - clampTo8bit(M * (1 - K / 255) + K);
+                    const B = 255 - clampTo8bit(Y * (1 - K / 255) + K);
+                    imageDataArray[j++] = R;
+                    imageDataArray[j++] = G;
+                    imageDataArray[j++] = B;
+                    imageDataArray[j++] = 255;
+                }
+            }
+            break;
+        default:
+            throw new Error('Unsupported color mode');
+    }
+    return imageData;
+}