ag-psd 28.5.0 → 29.0.0

package/dist/bundle.js

@@ -376,7 +376,7 @@ function readAbr(buffer, options) {
 }
 exports.readAbr = readAbr;
 
-},{"./descriptor":4,"./psdReader":12,"util":54}],2:[function(require,module,exports){
+},{"./descriptor":4,"./psdReader":13,"util":55}],2:[function(require,module,exports){
 "use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
@@ -706,7 +706,7 @@ addHandler('vogk', hasKey('vectorOrigination'), function (reader, target, left)
         }
         var trnf = i.Trnf;
         if (trnf) {
-            item.transform = [trnf.xx, trnf.xy, trnf.xy, trnf.yy, trnf.tx, trnf.ty];
+            item.transform = [trnf.xx, trnf.xy, trnf.yx, trnf.yy, trnf.tx, trnf.ty];
         }
         target.vectorOrigination.keyDescriptorList.push(item);
     }
@@ -3894,7 +3894,7 @@ addHandler('tsly', hasKey('transparencyShapesLayer'), function (reader, target)
     (0, psdWriter_1.writeZeros)(writer, 3);
 });
 
-},{"./descriptor":4,"./effectsHelpers":5,"./engineData":6,"./engineData2":7,"./helpers":8,"./psdReader":12,"./psdWriter":13,"./text":14,"base64-js":18,"util":54}],3:[function(require,module,exports){
+},{"./descriptor":4,"./effectsHelpers":5,"./engineData":6,"./engineData2":7,"./helpers":8,"./psdReader":13,"./psdWriter":14,"./text":15,"base64-js":19,"util":55}],3:[function(require,module,exports){
 "use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
@@ -3943,7 +3943,7 @@ function readCsh(buffer) {
 }
 exports.readCsh = readCsh;
 
-},{"./additionalInfo":2,"./psdReader":12}],4:[function(require,module,exports){
+},{"./additionalInfo":2,"./psdReader":13}],4:[function(require,module,exports){
 "use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
@@ -5983,7 +5983,7 @@ exports.presetKindType = (0, helpers_1.createEnum)('presetKindType', 'presetKind
     default: 'presetKindDefault',
 });
 
-},{"./helpers":8,"./psdReader":12,"./psdWriter":13}],5:[function(require,module,exports){
+},{"./helpers":8,"./psdReader":13,"./psdWriter":14}],5:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeEffects = exports.readEffects = void 0;
@@ -6293,7 +6293,7 @@ function writeEffects(writer, effects) {
 }
 exports.writeEffects = writeEffects;
 
-},{"./helpers":8,"./psdReader":12,"./psdWriter":13}],6:[function(require,module,exports){
+},{"./helpers":8,"./psdReader":13,"./psdWriter":14}],6:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializeEngineData = exports.parseEngineData = void 0;
@@ -7052,9 +7052,9 @@ exports.decodeEngineData2 = decodeEngineData2;
 },{}],8:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeCanvas = exports.createImageData = exports.createCanvasFromData = exports.createCanvas = exports.writeDataZipWithoutPrediction = exports.writeDataRLE = exports.writeDataRaw = exports.decodeBitmap = exports.imageDataToCanvas = exports.resetImageData = exports.hasAlpha = exports.clamp = exports.offsetForChannel = exports.Compression = exports.ChannelID = exports.MaskParams = exports.LayerMaskFlags = exports.ColorSpace = exports.createEnum = exports.revMap = exports.largeAdditionalInfoKeys = exports.layerColors = exports.toBlendMode = exports.fromBlendMode = exports.RAW_IMAGE_DATA = exports.MOCK_HANDLERS = void 0;
-var base64_js_1 = require("base64-js");
+exports.initializeCanvas = exports.createImageData = exports.createCanvas = exports.createCanvasFromData = exports.writeDataZipWithoutPrediction = exports.writeDataRLE = exports.writeDataRaw = exports.decodeBitmap = exports.imageDataToCanvas = exports.resetImageData = exports.hasAlpha = exports.clamp = exports.offsetForChannel = exports.Compression = exports.ChannelID = exports.MaskParams = exports.LayerMaskFlags = exports.ColorSpace = exports.createEnum = exports.revMap = exports.largeAdditionalInfoKeys = exports.layerColors = exports.toBlendMode = exports.fromBlendMode = exports.RAW_IMAGE_DATA = exports.MOCK_HANDLERS = void 0;
 var pako_1 = require("pako");
+var jpeg_1 = require("./jpeg");
 exports.MOCK_HANDLERS = false;
 exports.RAW_IMAGE_DATA = false;
 exports.fromBlendMode = {};
@@ -7376,14 +7376,25 @@ function writeDataZipWithoutPrediction(_a, offsets) {
     }
 }
 exports.writeDataZipWithoutPrediction = writeDataZipWithoutPrediction;
+function createCanvasFromData(data) {
+    var canvas = (0, exports.createCanvas)(100, 100);
+    try {
+        var context_1 = canvas.getContext('2d');
+        var imageData = (0, jpeg_1.decodeJpeg)(data, function (w, h) { return context_1.createImageData(w, h); });
+        canvas.width = imageData.width;
+        canvas.height = imageData.height;
+        context_1.putImageData(imageData, 0, 0);
+    }
+    catch (e) {
+        console.error('JPEG decompression error', e.message);
+    }
+    return canvas;
+}
+exports.createCanvasFromData = createCanvasFromData;
 var createCanvas = function () {
     throw new Error('Canvas not initialized, use initializeCanvas method to set up createCanvas method');
 };
 exports.createCanvas = createCanvas;
-var createCanvasFromData = function () {
-    throw new Error('Canvas not initialized, use initializeCanvas method to set up createCanvasFromData method');
-};
-exports.createCanvasFromData = createCanvasFromData;
 var tempCanvas = undefined;
 var createImageData = function (width, height) {
     if (!tempCanvas)
@@ -7398,24 +7409,14 @@ if (typeof document !== 'undefined') {
         canvas.height = height;
         return canvas;
     };
-    exports.createCanvasFromData = function (data) {
-        var image = new Image();
-        image.src = 'data:image/jpeg;base64,' + (0, base64_js_1.fromByteArray)(data);
-        var canvas = document.createElement('canvas');
-        canvas.width = image.width;
-        canvas.height = image.height;
-        canvas.getContext('2d').drawImage(image, 0, 0);
-        return canvas;
-    };
 }
-function initializeCanvas(createCanvasMethod, createCanvasFromDataMethod, createImageDataMethod) {
+function initializeCanvas(createCanvasMethod, createImageDataMethod) {
     exports.createCanvas = createCanvasMethod;
-    exports.createCanvasFromData = createCanvasFromDataMethod || exports.createCanvasFromData;
     exports.createImageData = createImageDataMethod || exports.createImageData;
 }
 exports.initializeCanvas = initializeCanvas;
 
-},{"base64-js":18,"pako":35}],9:[function(require,module,exports){
+},{"./jpeg":11,"pako":36}],9:[function(require,module,exports){
 "use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
@@ -8496,7 +8497,7 @@ target) { return target._ir4002 !== undefined; }, function (reader, target, left
     (0, psdWriter_1.writeBytes)(writer, target._ir4002);
 });
 
-},{"./descriptor":4,"./helpers":8,"./psdReader":12,"./psdWriter":13,"./utf8":15,"base64-js":18}],10:[function(require,module,exports){
+},{"./descriptor":4,"./helpers":8,"./psdReader":13,"./psdWriter":14,"./utf8":16,"base64-js":19}],10:[function(require,module,exports){
 (function (Buffer){(function (){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -8552,7 +8553,1030 @@ function writePsdBuffer(psd, options) {
 exports.writePsdBuffer = writePsdBuffer;
 
 }).call(this)}).call(this,require("buffer").Buffer)
-},{"./abr":1,"./csh":3,"./helpers":8,"./psd":11,"./psdReader":12,"./psdWriter":13,"base64-js":18,"buffer":19}],11:[function(require,module,exports){
+},{"./abr":1,"./csh":3,"./helpers":8,"./psd":12,"./psdReader":13,"./psdWriter":14,"base64-js":19,"buffer":20}],11:[function(require,module,exports){
+"use strict";
+// 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.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeJpeg = void 0;
+var 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
+]);
+var dctCos1 = 4017; // cos(pi/16)
+var dctSin1 = 799; // sin(pi/16)
+var dctCos3 = 3406; // cos(3*pi/16)
+var dctSin3 = 2276; // sin(3*pi/16)
+var dctCos6 = 1567; // cos(6*pi/16)
+var dctSin6 = 3784; // sin(6*pi/16)
+var dctSqrt2 = 5793; // sqrt(2)
+var dctSqrt1d2 = 2896; // sqrt(2) / 2
+var maxResolutionInMP = 100; // Don't decode more than 100 megapixels
+var maxMemoryUsageBytes = 64 * 1024 * 1024; // Don't decode if memory footprint is more than 64MB
+var totalBytesAllocated = 0; // avoid unexpected OOMs from untrusted content.
+function requestMemoryAllocation(increaseAmount) {
+    var totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;
+    if (totalMemoryImpactBytes > maxMemoryUsageBytes) {
+        var exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);
+        throw new Error("Max memory limit exceeded by at least ".concat(exceededAmount, "MB"));
+    }
+    totalBytesAllocated = totalMemoryImpactBytes;
+}
+function buildHuffmanTable(codeLengths, values) {
+    var length = 16;
+    while (length > 0 && !codeLengths[length - 1])
+        length--;
+    var code = [{ children: [], index: 0 }];
+    var k = 0;
+    var p = code[0];
+    for (var i = 0; i < length; i++) {
+        for (var 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) {
+                var 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
+            var 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) {
+    var mcusPerLine = frame.mcusPerLine;
+    var progressive = frame.progressive;
+    var startOffset = offset;
+    var bitsData = 0;
+    var bitsCount = 0;
+    function readBit() {
+        if (bitsCount > 0) {
+            bitsCount--;
+            return (bitsData >> bitsCount) & 1;
+        }
+        bitsData = data[offset++];
+        if (bitsData == 0xFF) {
+            var nextByte = data[offset++];
+            if (nextByte)
+                throw new Error("unexpected marker: ".concat(((bitsData << 8) | nextByte).toString(16)));
+            // unstuff 0
+        }
+        bitsCount = 7;
+        return bitsData >>> 7;
+    }
+    function decodeHuffman(tree) {
+        var 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) {
+        var n = 0;
+        while (length > 0) {
+            n = (n << 1) | readBit();
+            length--;
+        }
+        return n;
+    }
+    function receiveAndExtend(length) {
+        var n = receive(length);
+        if (n >= 1 << (length - 1))
+            return n;
+        return n + (-1 << length) + 1;
+    }
+    function decodeBaseline(component, zz) {
+        var t = decodeHuffman(component.huffmanTableDC);
+        var diff = t === 0 ? 0 : receiveAndExtend(t);
+        zz[0] = (component.pred += diff);
+        var k = 1;
+        while (k < 64) {
+            var rs = decodeHuffman(component.huffmanTableAC);
+            var s = rs & 15;
+            var r = rs >> 4;
+            if (s === 0) {
+                if (r < 15)
+                    break;
+                k += 16;
+                continue;
+            }
+            k += r;
+            var z = dctZigZag[k];
+            zz[z] = receiveAndExtend(s);
+            k++;
+        }
+    }
+    function decodeDCFirst(component, zz) {
+        var t = decodeHuffman(component.huffmanTableDC);
+        var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive);
+        zz[0] = (component.pred += diff);
+    }
+    function decodeDCSuccessive(_component, zz) {
+        zz[0] |= readBit() << successive;
+    }
+    var eobrun = 0;
+    function decodeACFirst(component, zz) {
+        if (eobrun > 0) {
+            eobrun--;
+            return;
+        }
+        var k = spectralStart, e = spectralEnd;
+        while (k <= e) {
+            var rs = decodeHuffman(component.huffmanTableAC);
+            var s = rs & 15;
+            var r = rs >> 4;
+            if (s === 0) {
+                if (r < 15) {
+                    eobrun = receive(r) + (1 << r) - 1;
+                    break;
+                }
+                k += 16;
+                continue;
+            }
+            k += r;
+            var z = dctZigZag[k];
+            zz[z] = receiveAndExtend(s) * (1 << successive);
+            k++;
+        }
+    }
+    var successiveACState = 0;
+    var successiveACNextValue = 0;
+    function decodeACSuccessive(component, zz) {
+        var k = spectralStart;
+        var e = spectralEnd;
+        var r = 0;
+        while (k <= e) {
+            var z = dctZigZag[k];
+            var direction = zz[z] < 0 ? -1 : 1;
+            switch (successiveACState) {
+                case 0: // initial state
+                    var rs = decodeHuffman(component.huffmanTableAC);
+                    var 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) {
+        var mcuRow = (mcu / mcusPerLine) | 0;
+        var mcuCol = mcu % mcusPerLine;
+        var blockRow = mcuRow * component.v + row;
+        var 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) {
+        var blockRow = (mcu / component.blocksPerLine) | 0;
+        var blockCol = mcu % component.blocksPerLine;
+        // If the block is missing, just skip it.
+        if (component.blocks[blockRow] === undefined)
+            return;
+        decode(component, component.blocks[blockRow][blockCol]);
+    }
+    var componentsLength = components.length;
+    var component;
+    var decodeFn;
+    if (progressive) {
+        if (spectralStart === 0) {
+            decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
+        }
+        else {
+            decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
+        }
+    }
+    else {
+        decodeFn = decodeBaseline;
+    }
+    var mcu = 0;
+    var mcuExpected;
+    if (componentsLength == 1) {
+        mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
+    }
+    else {
+        mcuExpected = mcusPerLine * frame.mcusPerColumn;
+    }
+    if (!resetInterval)
+        resetInterval = mcuExpected;
+    var h;
+    var v;
+    var marker;
+    while (mcu < mcuExpected) {
+        // reset interval stuff
+        for (var i = 0; i < componentsLength; i++)
+            components[i].pred = 0;
+        eobrun = 0;
+        if (componentsLength == 1) {
+            component = components[0];
+            for (var n = 0; n < resetInterval; n++) {
+                decodeBlock(component, decodeFn, mcu);
+                mcu++;
+            }
+        }
+        else {
+            for (var n = 0; n < resetInterval; n++) {
+                for (var i = 0; i < componentsLength; i++) {
+                    component = components[i];
+                    h = component.h;
+                    v = component.v;
+                    for (var j = 0; j < v; j++) {
+                        for (var 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) {
+    var lines = [];
+    var blocksPerLine = component.blocksPerLine;
+    var blocksPerColumn = component.blocksPerColumn;
+    var 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.
+    var R = new Int32Array(64);
+    var 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) {
+        var qt = component.quantizationTable;
+        var p = dataIn;
+        // dequant
+        for (var i = 0; i < 64; i++) {
+            p[i] = zz[i] * qt[i];
+        }
+        // inverse DCT on rows
+        for (var i = 0; i < 8; ++i) {
+            var 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) {
+                var t_1 = (dctSqrt2 * p[0 + row] + 512) >> 10;
+                p[0 + row] = t_1;
+                p[1 + row] = t_1;
+                p[2 + row] = t_1;
+                p[3 + row] = t_1;
+                p[4 + row] = t_1;
+                p[5 + row] = t_1;
+                p[6 + row] = t_1;
+                p[7 + row] = t_1;
+                continue;
+            }
+            // stage 4
+            var v0 = (dctSqrt2 * p[0 + row] + 128) >> 8;
+            var v1 = (dctSqrt2 * p[4 + row] + 128) >> 8;
+            var v2 = p[2 + row];
+            var v3 = p[6 + row];
+            var v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8;
+            var v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8;
+            var v5 = p[3 + row] << 4;
+            var v6 = p[5 + row] << 4;
+            // stage 3
+            var 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 (var i = 0; i < 8; ++i) {
+            var 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) {
+                var t_2 = (dctSqrt2 * dataIn[i + 0] + 8192) >> 14;
+                p[0 * 8 + col] = t_2;
+                p[1 * 8 + col] = t_2;
+                p[2 * 8 + col] = t_2;
+                p[3 * 8 + col] = t_2;
+                p[4 * 8 + col] = t_2;
+                p[5 * 8 + col] = t_2;
+                p[6 * 8 + col] = t_2;
+                p[7 * 8 + col] = t_2;
+                continue;
+            }
+            // stage 4
+            var v0 = (dctSqrt2 * p[0 * 8 + col] + 2048) >> 12;
+            var v1 = (dctSqrt2 * p[4 * 8 + col] + 2048) >> 12;
+            var v2 = p[2 * 8 + col];
+            var v3 = p[6 * 8 + col];
+            var v4 = (dctSqrt1d2 * (p[1 * 8 + col] - p[7 * 8 + col]) + 2048) >> 12;
+            var v7 = (dctSqrt1d2 * (p[1 * 8 + col] + p[7 * 8 + col]) + 2048) >> 12;
+            var v5 = p[3 * 8 + col];
+            var v6 = p[5 * 8 + col];
+            // stage 3
+            var 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 (var i = 0; i < 64; ++i) {
+            var sample = 128 + ((p[i] + 8) >> 4);
+            dataOut[i] = sample < 0 ? 0 : sample > 0xFF ? 0xFF : sample;
+        }
+    }
+    requestMemoryAllocation(samplesPerLine * blocksPerColumn * 8);
+    for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
+        var scanLine = blockRow << 3;
+        for (var i = 0; i < 8; i++)
+            lines.push(new Uint8Array(samplesPerLine));
+        for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
+            quantizeAndInverse(component.blocks[blockRow][blockCol], r, R);
+            var offset = 0;
+            var sample = blockCol << 3;
+            for (var j = 0; j < 8; j++) {
+                var line = lines[scanLine + j];
+                for (var 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) {
+    var self = {
+        width: 0,
+        height: 0,
+        comments: [],
+        adobe: undefined,
+        components: [],
+        exifBuffer: undefined,
+        jfif: undefined,
+    };
+    var maxResolutionInPixels = maxResolutionInMP * 1000 * 1000;
+    var offset = 0;
+    function readUint16() {
+        var value = (data[offset] << 8) | data[offset + 1];
+        offset += 2;
+        return value;
+    }
+    function readDataBlock() {
+        var length = readUint16();
+        var array = data.subarray(offset, offset + length - 2);
+        offset += array.length;
+        return array;
+    }
+    function prepareComponents(frame) {
+        var maxH = 0, maxV = 0;
+        for (var componentId in frame.components) {
+            if (frame.components.hasOwnProperty(componentId)) {
+                var component = frame.components[componentId];
+                if (maxH < component.h)
+                    maxH = component.h;
+                if (maxV < component.v)
+                    maxV = component.v;
+            }
+        }
+        var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH);
+        var mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV);
+        for (var componentId in frame.components) {
+            if (frame.components.hasOwnProperty(componentId)) {
+                var component = frame.components[componentId];
+                var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH);
+                var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV);
+                var blocksPerLineForMcu = mcusPerLine * component.h;
+                var blocksPerColumnForMcu = mcusPerColumn * component.v;
+                var blocksToAllocate = blocksPerColumnForMcu * blocksPerLineForMcu;
+                var blocks = [];
+                // Each block is a Int32Array of length 64 (4 x 64 = 256 bytes)
+                requestMemoryAllocation(blocksToAllocate * 256);
+                for (var i = 0; i < blocksPerColumnForMcu; i++) {
+                    var row = [];
+                    for (var 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;
+    }
+    var jfif = null;
+    var adobe = null;
+    var frame = undefined;
+    var resetInterval = 0;
+    var quantizationTables = [];
+    var frames = [];
+    var huffmanTablesAC = [];
+    var huffmanTablesDC = [];
+    var fileMarker = readUint16();
+    var 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)
+                var appData = readDataBlock();
+                if (fileMarker === 0xFFFE) {
+                    var comment = '';
+                    for (var 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)
+                var quantizationTablesLength = readUint16();
+                var quantizationTablesEnd = quantizationTablesLength + offset - 2;
+                while (offset < quantizationTablesEnd) {
+                    var quantizationTableSpec = data[offset++];
+                    requestMemoryAllocation(64 * 4);
+                    var tableData = new Int32Array(64);
+                    if ((quantizationTableSpec >> 4) === 0) { // 8 bit values
+                        for (var j = 0; j < 64; j++) {
+                            var z = dctZigZag[j];
+                            tableData[z] = data[offset++];
+                        }
+                    }
+                    else if ((quantizationTableSpec >> 4) === 1) { //16 bit
+                        for (var j = 0; j < 64; j++) {
+                            var 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,
+                };
+                var pixelsInFrame = frame.scanLines * frame.samplesPerLine;
+                if (pixelsInFrame > maxResolutionInPixels) {
+                    var exceededAmount = Math.ceil((pixelsInFrame - maxResolutionInPixels) / 1e6);
+                    throw new Error("maxResolutionInMP limit exceeded by ".concat(exceededAmount, "MP"));
+                }
+                var componentsCount = data[offset++];
+                for (var i = 0; i < componentsCount; i++) {
+                    var componentId = data[offset];
+                    var h = data[offset + 1] >> 4;
+                    var v = data[offset + 1] & 15;
+                    var 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)
+                var huffmanLength = readUint16();
+                for (var i = 2; i < huffmanLength;) {
+                    var huffmanTableSpec = data[offset++];
+                    var codeLengths = new Uint8Array(16);
+                    var codeLengthSum = 0;
+                    for (var j = 0; j < 16; j++, offset++) {
+                        codeLengthSum += (codeLengths[j] = data[offset]);
+                    }
+                    requestMemoryAllocation(16 + codeLengthSum);
+                    var huffmanValues = new Uint8Array(codeLengthSum);
+                    for (var j = 0; j < codeLengthSum; j++, offset++) {
+                        huffmanValues[j] = data[offset];
+                    }
+                    i += 17 + codeLengthSum;
+                    var index = huffmanTableSpec & 15;
+                    var 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
+                var selectorsCount = data[offset++];
+                var components = [];
+                for (var i = 0; i < selectorsCount; i++) {
+                    var component = frame.components[data[offset++]];
+                    var tableSpec = data[offset++];
+                    component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
+                    component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
+                    components.push(component);
+                }
+                var spectralStart = data[offset++];
+                var spectralEnd = data[offset++];
+                var successiveApproximation = data[offset++];
+                var 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 ".concat(malformedDataOffset.toString(16), ", second unknown JPEG marker ").concat(fileMarker.toString(16), " at offset ").concat((offset - 1).toString(16)));
+                    }
+                    malformedDataOffset = offset - 1;
+                    var 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 (var i = 0; i < frames.length; i++) {
+        var cp = frames[i].components;
+        for (var 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 (var i = 0; i < frame.componentsOrder.length; i++) {
+        var 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) {
+    var offset = 0;
+    var colorTransform = false;
+    var width = decoded.width;
+    var height = decoded.height;
+    var dataLength = width * height * decoded.components.length;
+    requestMemoryAllocation(dataLength);
+    var data = new Uint8Array(dataLength);
+    switch (decoded.components.length) {
+        case 1: {
+            var component1 = decoded.components[0];
+            for (var y = 0; y < height; y++) {
+                var component1Line = component1.lines[0 | (y * component1.scaleY)];
+                for (var x = 0; x < width; x++) {
+                    var Y = component1Line[0 | (x * component1.scaleX)];
+                    data[offset++] = Y;
+                }
+            }
+            break;
+        }
+        case 2: {
+            // PDF might compress two component data in custom colorspace
+            var component1 = decoded.components[0];
+            var component2 = decoded.components[1];
+            for (var y = 0; y < height; y++) {
+                var component1Line = component1.lines[0 | (y * component1.scaleY)];
+                var component2Line = component2.lines[0 | (y * component2.scaleY)];
+                for (var x = 0; x < width; x++) {
+                    var Y1 = component1Line[0 | (x * component1.scaleX)];
+                    data[offset++] = Y1;
+                    var 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;
+            var component1 = decoded.components[0];
+            var component2 = decoded.components[1];
+            var component3 = decoded.components[2];
+            for (var y = 0; y < height; y++) {
+                var component1Line = component1.lines[0 | (y * component1.scaleY)];
+                var component2Line = component2.lines[0 | (y * component2.scaleY)];
+                var component3Line = component3.lines[0 | (y * component3.scaleY)];
+                for (var x = 0; x < width; x++) {
+                    var Y = void 0, Cb = void 0, Cr = void 0, R = void 0, G = void 0, B = void 0;
+                    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;
+            var component1 = decoded.components[0];
+            var component2 = decoded.components[1];
+            var component3 = decoded.components[2];
+            var component4 = decoded.components[3];
+            for (var y = 0; y < height; y++) {
+                var component1Line = component1.lines[0 | (y * component1.scaleY)];
+                var component2Line = component2.lines[0 | (y * component2.scaleY)];
+                var component3Line = component3.lines[0 | (y * component3.scaleY)];
+                var component4Line = component4.lines[0 | (y * component4.scaleY)];
+                for (var x = 0; x < width; x++) {
+                    var Y = void 0, Cb = void 0, Cr = void 0, K = void 0, C = void 0, M = void 0, Ye = void 0;
+                    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;
+}
+function decodeJpeg(encoded, createImageData) {
+    totalBytesAllocated = 0;
+    if (encoded.length === 0)
+        throw new Error('Empty jpeg buffer');
+    var decoded = parse(encoded);
+    requestMemoryAllocation(decoded.width * decoded.height * 4);
+    var data = getData(decoded);
+    var imageData = createImageData(decoded.width, decoded.height);
+    var width = imageData.width;
+    var height = imageData.height;
+    var imageDataArray = imageData.data;
+    var i = 0;
+    var j = 0;
+    switch (decoded.components.length) {
+        case 1:
+            for (var y = 0; y < height; y++) {
+                for (var x = 0; x < width; x++) {
+                    var Y = data[i++];
+                    imageDataArray[j++] = Y;
+                    imageDataArray[j++] = Y;
+                    imageDataArray[j++] = Y;
+                    imageDataArray[j++] = 255;
+                }
+            }
+            break;
+        case 3:
+            for (var y = 0; y < height; y++) {
+                for (var x = 0; x < width; x++) {
+                    var R = data[i++];
+                    var G = data[i++];
+                    var B = data[i++];
+                    imageDataArray[j++] = R;
+                    imageDataArray[j++] = G;
+                    imageDataArray[j++] = B;
+                    imageDataArray[j++] = 255;
+                }
+            }
+            break;
+        case 4:
+            for (var y = 0; y < height; y++) {
+                for (var x = 0; x < width; x++) {
+                    var C = data[i++];
+                    var M = data[i++];
+                    var Y = data[i++];
+                    var K = data[i++];
+                    var R = 255 - clampTo8bit(C * (1 - K / 255) + K);
+                    var G = 255 - clampTo8bit(M * (1 - K / 255) + K);
+                    var 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;
+}
+exports.decodeJpeg = decodeJpeg;
+
+},{}],12:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LayerCompCapturedInfo = exports.SectionDividerType = exports.ColorMode = void 0;
@@ -8582,7 +9606,7 @@ var LayerCompCapturedInfo;
     LayerCompCapturedInfo[LayerCompCapturedInfo["Appearance"] = 4] = "Appearance";
 })(LayerCompCapturedInfo = exports.LayerCompCapturedInfo || (exports.LayerCompCapturedInfo = {}));
 
-},{}],12:[function(require,module,exports){
+},{}],13:[function(require,module,exports){
 "use strict";
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
@@ -9826,7 +10850,7 @@ function copyChannelToRGBA(srcData, dstData, ox, oy, offset) {
     }
 }
 
-},{"./additionalInfo":2,"./helpers":8,"./imageResources":9,"pako":35}],13:[function(require,module,exports){
+},{"./additionalInfo":2,"./helpers":8,"./imageResources":9,"pako":36}],14:[function(require,module,exports){
 "use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
@@ -10633,7 +11657,7 @@ function writeColor(writer, color) {
 }
 exports.writeColor = writeColor;
 
-},{"./additionalInfo":2,"./helpers":8,"./imageResources":9}],14:[function(require,module,exports){
+},{"./additionalInfo":2,"./helpers":8,"./imageResources":9}],15:[function(require,module,exports){
 "use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
@@ -11212,7 +12236,7 @@ function encodeEngineData(data) {
 }
 exports.encodeEngineData = encodeEngineData;
 
-},{}],15:[function(require,module,exports){
+},{}],16:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeString = exports.encodeString = exports.encodeStringTo = exports.stringLengthInBytes = void 0;
@@ -11371,7 +12395,7 @@ function decodeString(value) {
 }
 exports.decodeString = decodeString;
 
-},{}],16:[function(require,module,exports){
+},{}],17:[function(require,module,exports){
 
 /**
  * Array#filter.
@@ -11398,7 +12422,7 @@ module.exports = function (arr, fn, self) {
 
 var hasOwn = Object.prototype.hasOwnProperty;
 
-},{}],17:[function(require,module,exports){
+},{}],18:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -11423,7 +12447,7 @@ module.exports = function availableTypedArrays() {
 };
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"array-filter":16}],18:[function(require,module,exports){
+},{"array-filter":17}],19:[function(require,module,exports){
 'use strict'
 
 exports.byteLength = byteLength
@@ -11575,7 +12599,7 @@ function fromByteArray (uint8) {
   return parts.join('')
 }
 
-},{}],19:[function(require,module,exports){
+},{}],20:[function(require,module,exports){
 (function (Buffer){(function (){
 /*!
  * The buffer module from node.js, for the browser.
@@ -13356,7 +14380,7 @@ function numberIsNaN (obj) {
 }
 
 }).call(this)}).call(this,require("buffer").Buffer)
-},{"base64-js":18,"buffer":19,"ieee754":30}],20:[function(require,module,exports){
+},{"base64-js":19,"buffer":20,"ieee754":31}],21:[function(require,module,exports){
 'use strict';
 
 var GetIntrinsic = require('get-intrinsic');
@@ -13373,7 +14397,7 @@ module.exports = function callBoundIntrinsic(name, allowMissing) {
 	return intrinsic;
 };
 
-},{"./":21,"get-intrinsic":26}],21:[function(require,module,exports){
+},{"./":22,"get-intrinsic":27}],22:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
@@ -13422,7 +14446,7 @@ if ($defineProperty) {
 	module.exports.apply = applyBind;
 }
 
-},{"function-bind":25,"get-intrinsic":26}],22:[function(require,module,exports){
+},{"function-bind":26,"get-intrinsic":27}],23:[function(require,module,exports){
 'use strict';
 
 var GetIntrinsic = require('get-intrinsic');
@@ -13439,7 +14463,7 @@ if ($gOPD) {
 
 module.exports = $gOPD;
 
-},{"get-intrinsic":26}],23:[function(require,module,exports){
+},{"get-intrinsic":27}],24:[function(require,module,exports){
 
 var hasOwn = Object.prototype.hasOwnProperty;
 var toString = Object.prototype.toString;
@@ -13463,7 +14487,7 @@ module.exports = function forEach (obj, fn, ctx) {
 };
 
 
-},{}],24:[function(require,module,exports){
+},{}],25:[function(require,module,exports){
 'use strict';
 
 /* eslint no-invalid-this: 1 */
@@ -13549,14 +14573,14 @@ module.exports = function bind(that) {
     return bound;
 };
 
-},{}],25:[function(require,module,exports){
+},{}],26:[function(require,module,exports){
 'use strict';
 
 var implementation = require('./implementation');
 
 module.exports = Function.prototype.bind || implementation;
 
-},{"./implementation":24}],26:[function(require,module,exports){
+},{"./implementation":25}],27:[function(require,module,exports){
 'use strict';
 
 var undefined;
@@ -13892,7 +14916,7 @@ module.exports = function GetIntrinsic(name, allowMissing) {
 	return value;
 };
 
-},{"function-bind":25,"has":29,"has-symbols":27}],27:[function(require,module,exports){
+},{"function-bind":26,"has":30,"has-symbols":28}],28:[function(require,module,exports){
 'use strict';
 
 var origSymbol = typeof Symbol !== 'undefined' && Symbol;
@@ -13907,7 +14931,7 @@ module.exports = function hasNativeSymbols() {
 	return hasSymbolSham();
 };
 
-},{"./shams":28}],28:[function(require,module,exports){
+},{"./shams":29}],29:[function(require,module,exports){
 'use strict';
 
 /* eslint complexity: [2, 18], max-statements: [2, 33] */
@@ -13951,14 +14975,14 @@ module.exports = function hasSymbols() {
 	return true;
 };
 
-},{}],29:[function(require,module,exports){
+},{}],30:[function(require,module,exports){
 'use strict';
 
 var bind = require('function-bind');
 
 module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
 
-},{"function-bind":25}],30:[function(require,module,exports){
+},{"function-bind":26}],31:[function(require,module,exports){
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 exports.read = function (buffer, offset, isLE, mLen, nBytes) {
   var e, m
@@ -14045,7 +15069,7 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
   buffer[offset + i - d] |= s * 128
 }
 
-},{}],31:[function(require,module,exports){
+},{}],32:[function(require,module,exports){
 if (typeof Object.create === 'function') {
   // implementation from standard node.js 'util' module
   module.exports = function inherits(ctor, superCtor) {
@@ -14074,7 +15098,7 @@ if (typeof Object.create === 'function') {
   }
 }
 
-},{}],32:[function(require,module,exports){
+},{}],33:[function(require,module,exports){
 'use strict';
 
 var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
@@ -14109,7 +15133,7 @@ isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests
 
 module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
 
-},{"call-bind/callBound":20}],33:[function(require,module,exports){
+},{"call-bind/callBound":21}],34:[function(require,module,exports){
 'use strict';
 
 var toStr = Object.prototype.toString;
@@ -14143,7 +15167,7 @@ module.exports = function isGeneratorFunction(fn) {
 	return getProto && getProto(fn) === GeneratorFunction;
 };
 
-},{}],34:[function(require,module,exports){
+},{}],35:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -14208,7 +15232,7 @@ module.exports = function isTypedArray(value) {
 };
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"available-typed-arrays":17,"call-bind/callBound":20,"es-abstract/helpers/getOwnPropertyDescriptor":22,"foreach":23,"has-symbols":27}],35:[function(require,module,exports){
+},{"available-typed-arrays":18,"call-bind/callBound":21,"es-abstract/helpers/getOwnPropertyDescriptor":23,"foreach":24,"has-symbols":28}],36:[function(require,module,exports){
 // Top level file is just a mixin of submodules & constants
 'use strict';
 
@@ -14228,7 +15252,7 @@ module.exports.inflateRaw = inflateRaw;
 module.exports.ungzip = ungzip;
 module.exports.constants = constants;
 
-},{"./lib/deflate":36,"./lib/inflate":37,"./lib/zlib/constants":41}],36:[function(require,module,exports){
+},{"./lib/deflate":37,"./lib/inflate":38,"./lib/zlib/constants":42}],37:[function(require,module,exports){
 'use strict';
 
 
@@ -14610,7 +15634,7 @@ module.exports.deflateRaw = deflateRaw;
 module.exports.gzip = gzip;
 module.exports.constants = require('./zlib/constants');
 
-},{"./utils/common":38,"./utils/strings":39,"./zlib/constants":41,"./zlib/deflate":43,"./zlib/messages":48,"./zlib/zstream":50}],37:[function(require,module,exports){
+},{"./utils/common":39,"./utils/strings":40,"./zlib/constants":42,"./zlib/deflate":44,"./zlib/messages":49,"./zlib/zstream":51}],38:[function(require,module,exports){
 'use strict';
 
 
@@ -15031,7 +16055,7 @@ module.exports.inflateRaw = inflateRaw;
 module.exports.ungzip = inflate;
 module.exports.constants = require('./zlib/constants');
 
-},{"./utils/common":38,"./utils/strings":39,"./zlib/constants":41,"./zlib/gzheader":44,"./zlib/inflate":46,"./zlib/messages":48,"./zlib/zstream":50}],38:[function(require,module,exports){
+},{"./utils/common":39,"./utils/strings":40,"./zlib/constants":42,"./zlib/gzheader":45,"./zlib/inflate":47,"./zlib/messages":49,"./zlib/zstream":51}],39:[function(require,module,exports){
 'use strict';
 
 
@@ -15081,7 +16105,7 @@ module.exports.flattenChunks = (chunks) => {
   return result;
 };
 
-},{}],39:[function(require,module,exports){
+},{}],40:[function(require,module,exports){
 // String encode/decode helpers
 'use strict';
 
@@ -15257,7 +16281,7 @@ module.exports.utf8border = (buf, max) => {
   return (pos + _utf8len[buf[pos]] > max) ? pos : max;
 };
 
-},{}],40:[function(require,module,exports){
+},{}],41:[function(require,module,exports){
 'use strict';
 
 // Note: adler32 takes 12% for level 0 and 2% for level 6.
@@ -15310,7 +16334,7 @@ const adler32 = (adler, buf, len, pos) => {
 
 module.exports = adler32;
 
-},{}],41:[function(require,module,exports){
+},{}],42:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -15380,7 +16404,7 @@ module.exports = {
   //Z_NULL:                 null // Use -1 or null inline, depending on var type
 };
 
-},{}],42:[function(require,module,exports){
+},{}],43:[function(require,module,exports){
 'use strict';
 
 // Note: we can't get significant speed boost here.
@@ -15441,7 +16465,7 @@ const crc32 = (crc, buf, len, pos) => {
 
 module.exports = crc32;
 
-},{}],43:[function(require,module,exports){
+},{}],44:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -17491,7 +18515,7 @@ module.exports.deflatePrime = deflatePrime;
 module.exports.deflateTune = deflateTune;
 */
 
-},{"./adler32":40,"./constants":41,"./crc32":42,"./messages":48,"./trees":49}],44:[function(require,module,exports){
+},{"./adler32":41,"./constants":42,"./crc32":43,"./messages":49,"./trees":50}],45:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -17551,7 +18575,7 @@ function GZheader() {
 
 module.exports = GZheader;
 
-},{}],45:[function(require,module,exports){
+},{}],46:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -17897,7 +18921,7 @@ module.exports = function inflate_fast(strm, start) {
   return;
 };
 
-},{}],46:[function(require,module,exports){
+},{}],47:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -19471,7 +20495,7 @@ module.exports.inflateUndermine = inflateUndermine;
 module.exports.inflateValidate = inflateValidate;
 */
 
-},{"./adler32":40,"./constants":41,"./crc32":42,"./inffast":45,"./inftrees":47}],47:[function(require,module,exports){
+},{"./adler32":41,"./constants":42,"./crc32":43,"./inffast":46,"./inftrees":48}],48:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -19813,7 +20837,7 @@ const inflate_table = (type, lens, lens_index, codes, table, table_index, work,
 
 module.exports = inflate_table;
 
-},{}],48:[function(require,module,exports){
+},{}],49:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -19847,7 +20871,7 @@ module.exports = {
   '-6':   'incompatible version' /* Z_VERSION_ERROR (-6) */
 };
 
-},{}],49:[function(require,module,exports){
+},{}],50:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -21028,7 +22052,7 @@ module.exports._tr_flush_block  = _tr_flush_block;
 module.exports._tr_tally = _tr_tally;
 module.exports._tr_align = _tr_align;
 
-},{}],50:[function(require,module,exports){
+},{}],51:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -21077,7 +22101,7 @@ function ZStream() {
 
 module.exports = ZStream;
 
-},{}],51:[function(require,module,exports){
+},{}],52:[function(require,module,exports){
 // shim for using process in browser
 var process = module.exports = {};
 
@@ -21263,14 +22287,14 @@ process.chdir = function (dir) {
 };
 process.umask = function() { return 0; };
 
-},{}],52:[function(require,module,exports){
+},{}],53:[function(require,module,exports){
 module.exports = function isBuffer(arg) {
   return arg && typeof arg === 'object'
     && typeof arg.copy === 'function'
     && typeof arg.fill === 'function'
     && typeof arg.readUInt8 === 'function';
 }
-},{}],53:[function(require,module,exports){
+},{}],54:[function(require,module,exports){
 // Currently in sync with Node.js lib/internal/util/types.js
 // https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
 
@@ -21604,7 +22628,7 @@ exports.isAnyArrayBuffer = isAnyArrayBuffer;
   });
 });
 
-},{"is-arguments":32,"is-generator-function":33,"is-typed-array":34,"which-typed-array":55}],54:[function(require,module,exports){
+},{"is-arguments":33,"is-generator-function":34,"is-typed-array":35,"which-typed-array":56}],55:[function(require,module,exports){
 (function (process){(function (){
 // Copyright Joyent, Inc. and other Node contributors.
 //
@@ -22323,7 +23347,7 @@ function callbackify(original) {
 exports.callbackify = callbackify;
 
 }).call(this)}).call(this,require('_process'))
-},{"./support/isBuffer":52,"./support/types":53,"_process":51,"inherits":31}],55:[function(require,module,exports){
+},{"./support/isBuffer":53,"./support/types":54,"_process":52,"inherits":32}],56:[function(require,module,exports){
 (function (global){(function (){
 'use strict';
 
@@ -22383,5 +23407,5 @@ module.exports = function whichTypedArray(value) {
 };
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"available-typed-arrays":17,"call-bind/callBound":20,"es-abstract/helpers/getOwnPropertyDescriptor":22,"foreach":23,"has-symbols":27,"is-typed-array":34}]},{},[10])(10)
+},{"available-typed-arrays":18,"call-bind/callBound":21,"es-abstract/helpers/getOwnPropertyDescriptor":23,"foreach":24,"has-symbols":28,"is-typed-array":35}]},{},[10])(10)
 });