ag-psd 30.1.1 → 30.2.0

package/dist-es/psdReader.js

@@ -13,19 +13,19 @@ import { inflate as inflateSync } from 'pako';
 import { resetImageData, offsetForChannel, decodeBitmap, createImageData, toBlendMode, RAW_IMAGE_DATA, largeAdditionalInfoKeys, imageDataToCanvas } from './helpers';
 import { infoHandlersMap } from './additionalInfo';
 import { resourceHandlersMap } from './imageResources';
-export var supportedColorModes = [0 /* ColorMode.Bitmap */, 1 /* ColorMode.Grayscale */, 3 /* ColorMode.RGB */, 2 /* ColorMode.Indexed */];
-var colorModes = ['bitmap', 'grayscale', 'indexed', 'RGB', 'CMYK', 'multichannel', 'duotone', 'lab'];
+export const supportedColorModes = [0 /* ColorMode.Bitmap */, 1 /* ColorMode.Grayscale */, 3 /* ColorMode.RGB */, 2 /* ColorMode.Indexed */];
+const colorModes = ['bitmap', 'grayscale', 'indexed', 'RGB', 'CMYK', 'multichannel', 'duotone', 'lab'];
 function setupGrayscale(data) {
-    var size = data.width * data.height * 4;
-    for (var i = 0; i < size; i += 4) {
-        var c = data.data[i];
+    const size = data.width * data.height * 4;
+    for (let i = 0; i < size; i += 4) {
+        const c = data.data[i];
         data.data[i + 1] = c;
         data.data[i + 2] = c;
     }
 }
 export function createReader(buffer, offset, length) {
-    var view = new DataView(buffer, offset, length);
-    return { view: view, offset: 0, strict: false, debug: false, large: false, globalAlpha: false, log: console.log };
+    const view = new DataView(buffer, offset, length);
+    return { view, offset: 0, strict: false, debug: false, large: false, globalAlpha: false, log: console.log };
 }
 export function warnOrThrow(reader, message) {
     if (reader.strict)
@@ -81,15 +81,15 @@ export function readFixedPointPath32(reader) {
     return readInt32(reader) / (1 << 24);
 }
 export function readBytes(reader, length) {
-    var start = reader.view.byteOffset + reader.offset;
+    const start = reader.view.byteOffset + reader.offset;
     reader.offset += length;
     if ((start + length) > reader.view.buffer.byteLength) {
         // fix for broken PSD files that are missing part of file at the end
         warnOrThrow(reader, 'Reading bytes exceeding buffer length');
         if (length > (100 * 1024 * 1024))
             throw new Error('Reading past end of file'); // limit to 100MB
-        var result = new Uint8Array(length);
-        var len = Math.min(length, reader.view.byteLength - start);
+        const result = new Uint8Array(length);
+        const len = Math.min(length, reader.view.byteLength - start);
         if (len > 0)
             result.set(new Uint8Array(reader.view.buffer, start, len));
         return result;
@@ -102,28 +102,28 @@ export function readSignature(reader) {
     return readShortString(reader, 4);
 }
 export function validSignatureAt(reader, offset) {
-    var sig = String.fromCharCode(reader.view.getUint8(offset))
+    const sig = String.fromCharCode(reader.view.getUint8(offset))
         + String.fromCharCode(reader.view.getUint8(offset + 1))
         + String.fromCharCode(reader.view.getUint8(offset + 2))
         + String.fromCharCode(reader.view.getUint8(offset + 3));
     return sig == '8BIM' || sig == '8B64';
 }
 export function readPascalString(reader, padTo) {
-    var length = readUint8(reader);
-    var text = length ? readShortString(reader, length) : '';
+    let length = readUint8(reader);
+    const text = length ? readShortString(reader, length) : '';
     while (++length % padTo) { // starts with length + 1 so we count the size byte too
         reader.offset++;
     }
     return text;
 }
 export function readUnicodeString(reader) {
-    var length = readUint32(reader);
+    const length = readUint32(reader);
     return readUnicodeStringWithLength(reader, length);
 }
 export function readUnicodeStringWithLength(reader, length) {
-    var text = '';
+    let text = '';
     while (length--) {
-        var value = readUint16(reader);
+        const value = readUint16(reader);
         if (value || length > 0) { // remove trailing \0
             text += String.fromCharCode(value);
         }
@@ -131,9 +131,9 @@ export function readUnicodeStringWithLength(reader, length) {
     return text;
 }
 export function readUnicodeStringWithLengthLE(reader, length) {
-    var text = '';
+    let text = '';
     while (length--) {
-        var value = readUint16LE(reader);
+        const value = readUint16LE(reader);
         if (value || length > 0) { // remove trailing \0
             text += String.fromCharCode(value);
         }
@@ -141,7 +141,7 @@ export function readUnicodeStringWithLengthLE(reader, length) {
     return text;
 }
 export function readAsciiString(reader, length) {
-    var text = '';
+    let text = '';
     while (length--) {
         text += String.fromCharCode(readUint8(reader));
     }
@@ -151,16 +151,16 @@ export function skipBytes(reader, count) {
     reader.offset += count;
 }
 export function checkSignature(reader, a, b) {
-    var offset = reader.offset;
-    var signature = readSignature(reader);
+    const offset = reader.offset;
+    const signature = readSignature(reader);
     if (signature !== a && signature !== b) {
-        throw new Error("Invalid signature: '".concat(signature, "' at 0x").concat(offset.toString(16)));
+        throw new Error(`Invalid signature: '${signature}' at 0x${offset.toString(16)}`);
     }
 }
 function readShortString(reader, length) {
-    var buffer = readBytes(reader, length);
-    var result = '';
-    for (var i = 0; i < buffer.length; i++) {
+    const buffer = readBytes(reader, length);
+    let result = '';
+    for (let i = 0; i < buffer.length; i++) {
         result += String.fromCharCode(buffer[i]);
     }
     return result;
@@ -168,35 +168,34 @@ function readShortString(reader, length) {
 function isValidSignature(sig) {
     return sig === '8BIM' || sig === 'MeSa' || sig === 'AgHg' || sig === 'PHUT' || sig === 'DCSR';
 }
-export function readPsd(reader, readOptions) {
+export function readPsd(reader, readOptions = {}) {
     var _a;
-    if (readOptions === void 0) { readOptions = {}; }
     // header
     checkSignature(reader, '8BPS');
-    var version = readUint16(reader);
+    const version = readUint16(reader);
     if (version !== 1 && version !== 2)
-        throw new Error("Invalid PSD file version: ".concat(version));
+        throw new Error(`Invalid PSD file version: ${version}`);
     skipBytes(reader, 6);
-    var channels = readUint16(reader);
-    var height = readUint32(reader);
-    var width = readUint32(reader);
-    var bitsPerChannel = readUint16(reader);
-    var colorMode = readUint16(reader);
-    var maxSize = version === 1 ? 30000 : 300000;
+    const channels = readUint16(reader);
+    const height = readUint32(reader);
+    const width = readUint32(reader);
+    const bitsPerChannel = readUint16(reader);
+    const colorMode = readUint16(reader);
+    const maxSize = version === 1 ? 30000 : 300000;
     if (width > maxSize || height > maxSize)
-        throw new Error("Invalid size: ".concat(width, "x").concat(height));
+        throw new Error(`Invalid size: ${width}x${height}`);
     if (channels > 16)
-        throw new Error("Invalid channel count: ".concat(channels));
+        throw new Error(`Invalid channel count: ${channels}`);
     if (![1, 8, 16, 32].includes(bitsPerChannel))
-        throw new Error("Invalid bitsPerChannel: ".concat(bitsPerChannel));
+        throw new Error(`Invalid bitsPerChannel: ${bitsPerChannel}`);
     if (supportedColorModes.indexOf(colorMode) === -1)
-        throw new Error("Color mode not supported: ".concat((_a = colorModes[colorMode]) !== null && _a !== void 0 ? _a : colorMode));
-    var psd = { width: width, height: height, channels: channels, bitsPerChannel: bitsPerChannel, colorMode: colorMode };
+        throw new Error(`Color mode not supported: ${(_a = colorModes[colorMode]) !== null && _a !== void 0 ? _a : colorMode}`);
+    const psd = { width, height, channels, bitsPerChannel, colorMode };
     Object.assign(reader, readOptions);
     reader.large = version === 2;
     reader.globalAlpha = false;
     // color mode data
-    readSection(reader, 1, function (left) {
+    readSection(reader, 1, left => {
         if (!left())
             return;
         if (colorMode === 2 /* ColorMode.Indexed */) {
@@ -204,11 +203,11 @@ export function readPsd(reader, readOptions) {
             if (left() != 768)
                 throw new Error('Invalid color palette size');
             psd.palette = [];
-            for (var i = 0; i < 256; i++)
+            for (let i = 0; i < 256; i++)
                 psd.palette.push({ r: readUint8(reader), g: 0, b: 0 });
-            for (var i = 0; i < 256; i++)
+            for (let i = 0; i < 256; i++)
                 psd.palette[i].g = readUint8(reader);
-            for (var i = 0; i < 256; i++)
+            for (let i = 0; i < 256; i++)
                 psd.palette[i].b = readUint8(reader);
         }
         else {
@@ -218,15 +217,15 @@ export function readPsd(reader, readOptions) {
         skipBytes(reader, left());
     });
     // image resources
-    var imageResources = {};
-    readSection(reader, 1, function (left) {
-        var _loop_1 = function () {
+    const imageResources = {};
+    readSection(reader, 1, left => {
+        while (left() > 0) {
             realignWithSignature(reader, isValidSignature);
-            var id = readUint16(reader);
+            const id = readUint16(reader);
             readPascalString(reader, 2); // name
-            readSection(reader, 2, function (left) {
-                var handler = resourceHandlersMap[id];
-                var skip = id === 1036 && !!reader.skipThumbnail;
+            readSection(reader, 2, left => {
+                const handler = resourceHandlersMap[id];
+                const skip = id === 1036 && !!reader.skipThumbnail;
                 if (handler && !skip) {
                     try {
                         handler.read(reader, imageResources, left);
@@ -242,24 +241,21 @@ export function readPsd(reader, readOptions) {
                     skipBytes(reader, left());
                 }
             });
-        };
-        while (left() > 0) {
-            _loop_1();
         }
     });
-    var layersGroup = imageResources.layersGroup, layerGroupsEnabledId = imageResources.layerGroupsEnabledId, rest = __rest(imageResources, ["layersGroup", "layerGroupsEnabledId"]);
+    const { layersGroup, layerGroupsEnabledId } = imageResources, rest = __rest(imageResources, ["layersGroup", "layerGroupsEnabledId"]);
     if (Object.keys(rest)) {
         psd.imageResources = rest;
     }
     // layer and mask info
-    readSection(reader, 1, function (left) {
-        readSection(reader, 2, function (left) {
+    readSection(reader, 1, left => {
+        readSection(reader, 2, left => {
             readLayerInfo(reader, psd, imageResources);
             skipBytes(reader, left());
         }, undefined, reader.large);
         // SAI does not include this section
         if (left() > 0) {
-            var globalLayerMaskInfo = readGlobalLayerMaskInfo(reader);
+            const globalLayerMaskInfo = readGlobalLayerMaskInfo(reader);
             if (globalLayerMaskInfo)
                 psd.globalLayerMaskInfo = globalLayerMaskInfo;
         }
@@ -283,8 +279,8 @@ export function readPsd(reader, readOptions) {
             }
         }
     }, undefined, reader.large);
-    var hasChildren = psd.children && psd.children.length;
-    var skipComposite = reader.skipCompositeImageData && (reader.skipLayerImageData || hasChildren);
+    const hasChildren = psd.children && psd.children.length;
+    const skipComposite = reader.skipCompositeImageData && (reader.skipLayerImageData || hasChildren);
     if (!skipComposite) {
         readImageData(reader, psd);
     }
@@ -295,16 +291,16 @@ export function readPsd(reader, readOptions) {
 }
 export function readLayerInfo(reader, psd, imageResources) {
     var _a, _b;
-    var _c = imageResources.layersGroup, layersGroup = _c === void 0 ? [] : _c, _d = imageResources.layerGroupsEnabledId, layerGroupsEnabledId = _d === void 0 ? [] : _d;
-    var layerCount = readInt16(reader);
+    const { layersGroup = [], layerGroupsEnabledId = [] } = imageResources;
+    let layerCount = readInt16(reader);
     if (layerCount < 0) {
         reader.globalAlpha = true;
         layerCount = -layerCount;
     }
-    var layers = [];
-    var layerChannels = [];
-    for (var i = 0; i < layerCount; i++) {
-        var _e = readLayerRecord(reader, psd, imageResources), layer = _e.layer, channels = _e.channels;
+    const layers = [];
+    const layerChannels = [];
+    for (let i = 0; i < layerCount; i++) {
+        const { layer, channels } = readLayerRecord(reader, psd, imageResources);
         if (layersGroup[i] !== undefined)
             layer.linkGroup = layersGroup[i];
         if (layerGroupsEnabledId[i] !== undefined)
@@ -312,15 +308,15 @@ export function readLayerInfo(reader, psd, imageResources) {
         layers.push(layer);
         layerChannels.push(channels);
     }
-    for (var i = 0; i < layerCount; i++) {
+    for (let i = 0; i < layerCount; i++) {
         readLayerChannelImageData(reader, psd, layers[i], layerChannels[i]);
     }
     if (!psd.children)
         psd.children = [];
-    var stack = [psd];
-    for (var i = layers.length - 1; i >= 0; i--) {
-        var l = layers[i];
-        var type = l.sectionDivider ? l.sectionDivider.type : 0 /* SectionDividerType.Other */;
+    const stack = [psd];
+    for (let i = layers.length - 1; i >= 0; i--) {
+        const l = layers[i];
+        const type = l.sectionDivider ? l.sectionDivider.type : 0 /* SectionDividerType.Other */;
         if (type === 1 /* SectionDividerType.OpenFolder */ || type === 2 /* SectionDividerType.ClosedFolder */) {
             l.opened = type === 1 /* SectionDividerType.OpenFolder */;
             l.children = [];
@@ -343,31 +339,31 @@ export function readLayerInfo(reader, psd, imageResources) {
     }
 }
 function readLayerRecord(reader, psd, imageResources) {
-    var layer = {};
+    const layer = {};
     layer.top = readInt32(reader);
     layer.left = readInt32(reader);
     layer.bottom = readInt32(reader);
     layer.right = readInt32(reader);
-    var channelCount = readUint16(reader);
-    var channels = [];
-    for (var i = 0; i < channelCount; i++) {
-        var id = readInt16(reader);
-        var length_1 = readUint32(reader);
+    const channelCount = readUint16(reader);
+    const channels = [];
+    for (let i = 0; i < channelCount; i++) {
+        let id = readInt16(reader);
+        let length = readUint32(reader);
         if (reader.large) {
-            if (length_1 !== 0)
+            if (length !== 0)
                 throw new Error('Sizes larger than 4GB are not supported');
-            length_1 = readUint32(reader);
+            length = readUint32(reader);
         }
-        channels.push({ id: id, length: length_1 });
+        channels.push({ id, length });
     }
     checkSignature(reader, '8BIM');
-    var blendMode = readSignature(reader);
+    const blendMode = readSignature(reader);
     if (!toBlendMode[blendMode])
-        throw new Error("Invalid blend mode: '".concat(blendMode, "'"));
+        throw new Error(`Invalid blend mode: '${blendMode}'`);
     layer.blendMode = toBlendMode[blendMode];
     layer.opacity = readUint8(reader) / 0xff;
     layer.clipping = readUint8(reader) === 1;
-    var flags = readUint8(reader);
+    const flags = readUint8(reader);
     layer.transparencyProtected = (flags & 0x01) !== 0;
     layer.hidden = (flags & 0x02) !== 0;
     if (flags & 0x20)
@@ -377,9 +373,9 @@ function readLayerRecord(reader, psd, imageResources) {
     // 0x10 - pixel data irrelevant to appearance of document
     // 0x20 - effects/filters panel is expanded
     skipBytes(reader, 1);
-    readSection(reader, 1, function (left) {
+    readSection(reader, 1, left => {
         readLayerMaskData(reader, layer);
-        var blendingRanges = readLayerBlendingRanges(reader);
+        const blendingRanges = readLayerBlendingRanges(reader);
         if (blendingRanges)
             layer.blendingRanges = blendingRanges;
         layer.name = readPascalString(reader, 1); // should be padded to 4, but is not sometimes
@@ -390,27 +386,27 @@ function readLayerRecord(reader, psd, imageResources) {
             readAdditionalLayerInfo(reader, layer, psd, imageResources);
         skipBytes(reader, left());
     });
-    return { layer: layer, channels: channels };
+    return { layer, channels };
 }
 function readLayerMaskData(reader, layer) {
-    return readSection(reader, 1, function (left) {
+    return readSection(reader, 1, left => {
         if (!left())
             return undefined;
-        var mask = {};
+        const mask = {};
         layer.mask = mask;
         mask.top = readInt32(reader);
         mask.left = readInt32(reader);
         mask.bottom = readInt32(reader);
         mask.right = readInt32(reader);
         mask.defaultColor = readUint8(reader);
-        var flags = readUint8(reader);
+        const flags = readUint8(reader);
         mask.positionRelativeToLayer = (flags & 1 /* LayerMaskFlags.PositionRelativeToLayer */) !== 0;
         mask.disabled = (flags & 2 /* LayerMaskFlags.LayerMaskDisabled */) !== 0;
         mask.fromVectorData = (flags & 8 /* LayerMaskFlags.LayerMaskFromRenderingOtherData */) !== 0;
         if (left() >= 18) {
-            var realMask = {};
+            const realMask = {};
             layer.realMask = realMask;
-            var realFlags = readUint8(reader);
+            const realFlags = readUint8(reader);
             realMask.positionRelativeToLayer = (realFlags & 1 /* LayerMaskFlags.PositionRelativeToLayer */) !== 0;
             realMask.disabled = (realFlags & 2 /* LayerMaskFlags.LayerMaskDisabled */) !== 0;
             realMask.fromVectorData = (realFlags & 8 /* LayerMaskFlags.LayerMaskFromRenderingOtherData */) !== 0;
@@ -421,7 +417,7 @@ function readLayerMaskData(reader, layer) {
             realMask.right = readInt32(reader);
         }
         if (flags & 16 /* LayerMaskFlags.MaskHasParametersAppliedToIt */) {
-            var params = readUint8(reader);
+            const params = readUint8(reader);
             if (params & 1 /* MaskParams.UserMaskDensity */)
                 mask.userMaskDensity = readUint8(reader) / 0xff;
             if (params & 2 /* MaskParams.UserMaskFeather */)
@@ -438,28 +434,27 @@ function readBlendingRange(reader) {
     return [readUint8(reader), readUint8(reader), readUint8(reader), readUint8(reader)];
 }
 function readLayerBlendingRanges(reader) {
-    return readSection(reader, 1, function (left) {
-        var compositeGrayBlendSource = readBlendingRange(reader);
-        var compositeGraphBlendDestinationRange = readBlendingRange(reader);
-        var ranges = [];
+    return readSection(reader, 1, left => {
+        const compositeGrayBlendSource = readBlendingRange(reader);
+        const compositeGraphBlendDestinationRange = readBlendingRange(reader);
+        const ranges = [];
         while (left() > 0) {
-            var sourceRange = readBlendingRange(reader);
-            var destRange = readBlendingRange(reader);
-            ranges.push({ sourceRange: sourceRange, destRange: destRange });
+            const sourceRange = readBlendingRange(reader);
+            const destRange = readBlendingRange(reader);
+            ranges.push({ sourceRange, destRange });
         }
-        return { compositeGrayBlendSource: compositeGrayBlendSource, compositeGraphBlendDestinationRange: compositeGraphBlendDestinationRange, ranges: ranges };
+        return { compositeGrayBlendSource, compositeGraphBlendDestinationRange, ranges };
     });
 }
 function readLayerChannelImageData(reader, psd, layer, channels) {
     if (reader.skipLayerImageData)
         return;
-    var _a = psd.colorMode, colorMode = _a === void 0 ? 3 /* ColorMode.RGB */ : _a, _b = psd.bitsPerChannel, bitsPerChannel = _b === void 0 ? 8 : _b;
-    layer.rawData = { colorMode: colorMode, bitsPerChannel: bitsPerChannel, channels: [], large: reader.large };
-    for (var _i = 0, channels_1 = channels; _i < channels_1.length; _i++) {
-        var channel = channels_1[_i];
-        var start = reader.offset;
-        var compression = 0 /* Compression.RawData */;
-        var data = undefined;
+    const { colorMode = 3 /* ColorMode.RGB */, bitsPerChannel = 8 } = psd;
+    layer.rawData = { colorMode, bitsPerChannel, channels: [], large: reader.large };
+    for (const channel of channels) {
+        const start = reader.offset;
+        let compression = 0 /* Compression.RawData */;
+        let data = undefined;
         if (channel.length === 1)
             throw new Error('Invalid channel length');
         if (channel.length) {
@@ -475,37 +470,36 @@ function readLayerChannelImageData(reader, psd, layer, channels) {
                 compression = readUint16(reader);
             }
             if (compression > 3)
-                throw new Error("Invalid compression: ".concat(compression));
+                throw new Error(`Invalid compression: ${compression}`);
             if (channel.length > 2) {
                 data = readBytes(reader, channel.length - 2);
             }
         }
         reader.offset = start + channel.length;
-        layer.rawData.channels.push({ id: channel.id, compression: compression, data: data });
+        layer.rawData.channels.push({ id: channel.id, compression, data });
     }
     if (!reader.useRawData) {
         decodeLayerImageData(layer, !!reader.useImageData, !!reader.throwForMissingFeatures);
     }
 }
-function resetAlpha(_a, cmyk) {
-    var data = _a.data;
-    var alpha = (data instanceof Float32Array) ? 1.0 : ((data instanceof Uint16Array) ? 0xffff : 0xff);
-    var offset = (cmyk ? 4 : 3) | 0;
-    var length = data.length | 0;
-    var step = (cmyk ? 5 : 4) | 0;
-    for (var p = offset; p < length; p = (p + step) | 0) {
+function resetAlpha({ data }, cmyk) {
+    const alpha = (data instanceof Float32Array) ? 1.0 : ((data instanceof Uint16Array) ? 0xffff : 0xff);
+    const offset = (cmyk ? 4 : 3) | 0;
+    const length = data.length | 0;
+    const step = (cmyk ? 5 : 4) | 0;
+    for (let p = offset; p < length; p = (p + step) | 0) {
         data[p] = alpha;
     }
 }
 export function decodeLayerImageData(layer, useImageData, throwForMissingFeatures) {
     if (!layer.rawData)
         return;
-    var _a = layer.rawData, colorMode = _a.colorMode, bitsPerChannel = _a.bitsPerChannel, channels = _a.channels, large = _a.large;
-    var layerWidth = (layer.right || 0) - (layer.left || 0);
-    var layerHeight = (layer.bottom || 0) - (layer.top || 0);
-    var cmyk = colorMode === 4 /* ColorMode.CMYK */;
-    var imageData;
-    var initializedAlpha = false;
+    const { colorMode, bitsPerChannel, channels, large } = layer.rawData;
+    const layerWidth = (layer.right || 0) - (layer.left || 0);
+    const layerHeight = (layer.bottom || 0) - (layer.top || 0);
+    const cmyk = colorMode === 4 /* ColorMode.CMYK */;
+    let imageData;
+    let initializedAlpha = false;
     if (layerWidth && layerHeight) {
         if (cmyk) {
             if (bitsPerChannel !== 8)
@@ -520,21 +514,20 @@ export function decodeLayerImageData(layer, useImageData, throwForMissingFeature
         layer.imageDataRaw = [];
         layer.imageDataRawCompression = [];
     }
-    for (var _i = 0, channels_2 = channels; _i < channels_2.length; _i++) {
-        var _b = channels_2[_i], id = _b.id, compression = _b.compression, data = _b.data;
+    for (const { id, compression, data } of channels) {
         if (!data)
             continue;
-        var dataReader = createReader(data.buffer, data.byteOffset, data.byteLength);
+        const dataReader = createReader(data.buffer, data.byteOffset, data.byteLength);
         if (id === -2 /* ChannelID.UserMask */ || id === -3 /* ChannelID.RealUserMask */) {
-            var mask = id === -2 /* ChannelID.UserMask */ ? layer.mask : layer.realMask;
+            const mask = id === -2 /* ChannelID.UserMask */ ? layer.mask : layer.realMask;
             if (!mask)
-                throw new Error("Missing layer ".concat(id === -2 /* ChannelID.UserMask */ ? 'mask' : 'real mask', " data"));
-            var maskWidth = (mask.right || 0) - (mask.left || 0);
-            var maskHeight = (mask.bottom || 0) - (mask.top || 0);
+                throw new Error(`Missing layer ${id === -2 /* ChannelID.UserMask */ ? 'mask' : 'real mask'} data`);
+            const maskWidth = (mask.right || 0) - (mask.left || 0);
+            const maskHeight = (mask.bottom || 0) - (mask.top || 0);
             if (maskWidth < 0 || maskHeight < 0 || maskWidth > 30000 || maskHeight > 30000)
                 throw new Error('Invalid mask size');
             if (maskWidth && maskHeight) {
-                var maskData = createImageDataBitDepth(maskWidth, maskHeight, bitsPerChannel);
+                const maskData = createImageDataBitDepth(maskWidth, maskHeight, bitsPerChannel);
                 readData(dataReader, data.byteLength, maskData, compression, maskWidth, maskHeight, bitsPerChannel, 0, large, 4);
                 if (RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
                     if (id === -2 /* ChannelID.UserMask */) {
@@ -557,12 +550,12 @@ export function decodeLayerImageData(layer, useImageData, throwForMissingFeature
             }
         }
         else {
-            var offset = offsetForChannel(id, cmyk);
-            var targetData = imageData;
+            const offset = offsetForChannel(id, cmyk);
+            let targetData = imageData;
             if (offset < 0) {
                 targetData = undefined;
                 if (throwForMissingFeatures) {
-                    throw new Error("Channel not supported: ".concat(id));
+                    throw new Error(`Channel not supported: ${id}`);
                 }
             }
             readData(dataReader, data.byteLength, targetData, compression, layerWidth, layerHeight, bitsPerChannel, offset, large, cmyk ? 5 : 4);
@@ -582,7 +575,7 @@ export function decodeLayerImageData(layer, useImageData, throwForMissingFeature
         if (!initializedAlpha)
             resetAlpha(imageData, cmyk);
         if (cmyk) {
-            var cmykData = imageData;
+            const cmykData = imageData;
             imageData = createImageData(cmykData.width, cmykData.height);
             cmykToRgb(cmykData, imageData, false);
         }
@@ -600,9 +593,9 @@ function readData(reader, length, pixels, compression, width, height, bitDepth,
         return;
     if (compression === 0 /* Compression.RawData */) {
         if (length !== (width * height * Math.floor(bitDepth / 8))) {
-            reader.log("Invalid length (".concat(length, ", ").concat(width * height * Math.floor(bitDepth / 8), ")"));
+            reader.log(`Invalid length (${length}, ${width * height * Math.floor(bitDepth / 8)})`);
         }
-        var data = readBytes(reader, length);
+        const data = readBytes(reader, length);
         readDataRaw(data, pixels, bitDepth, step, offset);
     }
     else if (compression === 1 /* Compression.RleCompressed */) {
@@ -610,39 +603,38 @@ function readData(reader, length, pixels, compression, width, height, bitDepth,
         readDataRLE(reader, pixels, width, height, bitDepth, step, [offset], large);
     }
     else if (compression === 2 /* Compression.ZipWithoutPrediction */) {
-        var data = readBytes(reader, length);
+        const data = readBytes(reader, length);
         readDataZip(data, pixels, width, height, bitDepth, step, offset, false);
     }
     else if (compression === 3 /* Compression.ZipWithPrediction */) {
-        var data = readBytes(reader, length);
+        const data = readBytes(reader, length);
         readDataZip(data, pixels, width, height, bitDepth, step, offset, true);
     }
     else {
-        throw new Error("Invalid Compression type: ".concat(compression));
+        throw new Error(`Invalid Compression type: ${compression}`);
     }
 }
 export function readGlobalLayerMaskInfo(reader) {
-    return readSection(reader, 1, function (left) {
+    return readSection(reader, 1, left => {
         if (!left())
             return undefined;
-        var overlayColorSpace = readUint16(reader);
-        var colorSpace1 = readUint16(reader);
-        var colorSpace2 = readUint16(reader);
-        var colorSpace3 = readUint16(reader);
-        var colorSpace4 = readUint16(reader);
-        var opacity = readUint16(reader) / 0xff;
-        var kind = readUint8(reader);
+        const overlayColorSpace = readUint16(reader);
+        const colorSpace1 = readUint16(reader);
+        const colorSpace2 = readUint16(reader);
+        const colorSpace3 = readUint16(reader);
+        const colorSpace4 = readUint16(reader);
+        const opacity = readUint16(reader) / 0xff;
+        const kind = readUint8(reader);
         skipBytes(reader, left()); // 3 bytes of padding ?
-        return { overlayColorSpace: overlayColorSpace, colorSpace1: colorSpace1, colorSpace2: colorSpace2, colorSpace3: colorSpace3, colorSpace4: colorSpace4, opacity: opacity, kind: kind };
+        return { overlayColorSpace, colorSpace1, colorSpace2, colorSpace3, colorSpace4, opacity, kind };
     });
 }
-var fixOffsets = [0, 1, -1, 2, -2, 3, -3, 4, -4];
+const fixOffsets = [0, 1, -1, 2, -2, 3, -3, 4, -4];
 function realignWithSignature(reader, isValid) {
-    var sigOffset = reader.offset;
-    var sig = '';
+    const sigOffset = reader.offset;
+    let sig = '';
     // attempt to fix broken document by realigning with the signature
-    for (var _i = 0, fixOffsets_1 = fixOffsets; _i < fixOffsets_1.length; _i++) {
-        var offset = fixOffsets_1[_i];
+    for (const offset of fixOffsets) {
         try {
             reader.offset = sigOffset + offset;
             sig = readSignature(reader);
@@ -652,7 +644,7 @@ function realignWithSignature(reader, isValid) {
             break;
     }
     if (!isValid(sig)) {
-        throw new Error("Invalid signature: '".concat(sig, "' at 0x").concat((sigOffset).toString(16)));
+        throw new Error(`Invalid signature: '${sig}' at 0x${(sigOffset).toString(16)}`);
     }
     return sig;
 }
@@ -660,12 +652,12 @@ function isValidAdditionalInfoSignature(sig) {
     return sig === '8BIM' || sig === '8B64';
 }
 export function readAdditionalLayerInfo(reader, target, psd, imageResources) {
-    var sig = realignWithSignature(reader, isValidAdditionalInfoSignature);
-    var key = readSignature(reader);
+    const sig = realignWithSignature(reader, isValidAdditionalInfoSignature);
+    const key = readSignature(reader);
     // `largeAdditionalInfoKeys` fallback, because some keys don't have 8B64 signature even when they are 64bit
-    var u64 = sig === '8B64' || (reader.large && largeAdditionalInfoKeys.indexOf(key) !== -1);
-    readSection(reader, 2, function (left) {
-        var handler = infoHandlersMap[key];
+    const u64 = sig === '8B64' || (reader.large && largeAdditionalInfoKeys.indexOf(key) !== -1);
+    readSection(reader, 2, left => {
+        const handler = infoHandlersMap[key];
         if (handler) {
             try {
                 handler.read(reader, target, left, psd, imageResources);
@@ -676,50 +668,49 @@ export function readAdditionalLayerInfo(reader, target, psd, imageResources) {
             }
         }
         else {
-            reader.logMissingFeatures && reader.log("Unhandled additional info: ".concat(key));
+            reader.logMissingFeatures && reader.log(`Unhandled additional info: ${key}`);
             skipBytes(reader, left());
         }
         if (left()) {
-            reader.logMissingFeatures && reader.log("Unread ".concat(left(), " bytes left for additional info: ").concat(key));
+            reader.logMissingFeatures && reader.log(`Unread ${left()} bytes left for additional info: ${key}`);
             skipBytes(reader, left());
         }
     }, false, u64);
 }
-export function createImageDataBitDepth(width, height, bitDepth, channels) {
-    if (channels === void 0) { channels = 4; }
+export function createImageDataBitDepth(width, height, bitDepth, channels = 4) {
     if (bitDepth === 1 || bitDepth === 8) {
         if (channels === 4) {
             return createImageData(width, height);
         }
         else {
-            return { width: width, height: height, data: new Uint8ClampedArray(width * height * channels) };
+            return { width, height, data: new Uint8ClampedArray(width * height * channels) };
         }
     }
     else if (bitDepth === 16) {
-        return { width: width, height: height, data: new Uint16Array(width * height * channels) };
+        return { width, height, data: new Uint16Array(width * height * channels) };
     }
     else if (bitDepth === 32) {
-        return { width: width, height: height, data: new Float32Array(width * height * channels) };
+        return { width, height, data: new Float32Array(width * height * channels) };
     }
     else {
-        throw new Error("Invalid bitDepth (".concat(bitDepth, ")"));
+        throw new Error(`Invalid bitDepth (${bitDepth})`);
     }
 }
 function readImageData(reader, psd) {
     var _a;
-    var compression = readUint16(reader);
-    var bitsPerChannel = (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
+    const compression = readUint16(reader);
+    const bitsPerChannel = (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
     if (supportedColorModes.indexOf(psd.colorMode) === -1)
-        throw new Error("Color mode not supported: ".concat(psd.colorMode));
+        throw new Error(`Color mode not supported: ${psd.colorMode}`);
     if (compression !== 0 /* Compression.RawData */ && compression !== 1 /* Compression.RleCompressed */)
-        throw new Error("Compression type not supported: ".concat(compression));
-    var imageData = createImageDataBitDepth(psd.width, psd.height, bitsPerChannel);
+        throw new Error(`Compression type not supported: ${compression}`);
+    const imageData = createImageDataBitDepth(psd.width, psd.height, bitsPerChannel);
     resetImageData(imageData);
     switch (psd.colorMode) {
         case 0 /* ColorMode.Bitmap */: {
             if (bitsPerChannel !== 1)
                 throw new Error('Invalid bitsPerChannel for bitmap color mode');
-            var bytes = void 0;
+            let bytes;
             if (compression === 0 /* Compression.RawData */) {
                 bytes = readBytes(reader, Math.ceil(psd.width / 8) * psd.height);
             }
@@ -728,16 +719,16 @@ function readImageData(reader, psd) {
                 readDataRLE(reader, { data: bytes, width: psd.width, height: psd.height }, psd.width, psd.height, 8, 1, [0], reader.large);
             }
             else {
-                throw new Error("Bitmap compression not supported: ".concat(compression));
+                throw new Error(`Bitmap compression not supported: ${compression}`);
             }
             decodeBitmap(bytes, imageData.data, psd.width, psd.height);
             break;
         }
         case 3 /* ColorMode.RGB */:
         case 1 /* ColorMode.Grayscale */: {
-            var channels = psd.colorMode === 1 /* ColorMode.Grayscale */ ? [0] : [0, 1, 2];
+            const channels = psd.colorMode === 1 /* ColorMode.Grayscale */ ? [0] : [0, 1, 2];
             if (psd.channels && psd.channels > 3) {
-                for (var i = 3; i < psd.channels; i++) {
+                for (let i = 3; i < psd.channels; i++) {
                     // TODO: store these channels in additional image data
                     channels.push(i);
                 }
@@ -746,13 +737,13 @@ function readImageData(reader, psd) {
                 channels.push(3);
             }
             if (compression === 0 /* Compression.RawData */) {
-                for (var i = 0; i < channels.length; i++) {
-                    var data = readBytes(reader, psd.width * psd.height * Math.floor(bitsPerChannel / 8));
+                for (let i = 0; i < channels.length; i++) {
+                    const data = readBytes(reader, psd.width * psd.height * Math.floor(bitsPerChannel / 8));
                     readDataRaw(data, imageData, bitsPerChannel, 4, channels[i]);
                 }
             }
             else if (compression === 1 /* Compression.RleCompressed */) {
-                var start = reader.offset;
+                const start = reader.offset;
                 readDataRLE(reader, imageData, psd.width, psd.height, bitsPerChannel, 4, channels, reader.large);
                 if (RAW_IMAGE_DATA)
                     psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
@@ -770,10 +761,10 @@ function readImageData(reader, psd) {
             if (!psd.palette)
                 throw new Error('Missing color palette');
             if (compression === 0 /* Compression.RawData */) {
-                throw new Error("Not implemented");
+                throw new Error(`Not implemented`);
             }
             else if (compression === 1 /* Compression.RleCompressed */) {
-                var indexedImageData = {
+                const indexedImageData = {
                     width: imageData.width,
                     height: imageData.height,
                     data: new Uint8Array(imageData.width * imageData.height),
@@ -782,7 +773,7 @@ function readImageData(reader, psd) {
                 indexedToRgb(indexedImageData, imageData, psd.palette);
             }
             else {
-                throw new Error("Not implemented");
+                throw new Error(`Not implemented`);
             }
             break;
         }
@@ -790,48 +781,48 @@ function readImageData(reader, psd) {
             if (bitsPerChannel !== 8)
                 throw new Error('bitsPerChannel Not supproted');
             if (psd.channels !== 4)
-                throw new Error("Invalid channel count");
-            var channels = [0, 1, 2, 3];
+                throw new Error(`Invalid channel count`);
+            const channels = [0, 1, 2, 3];
             if (reader.globalAlpha)
                 channels.push(4);
             if (compression === 0 /* Compression.RawData */) {
-                throw new Error("Not implemented");
+                throw new Error(`Not implemented`);
                 // TODO: ...
                 // for (let i = 0; i < channels.length; i++) {
                 // 	readDataRaw(reader, imageData, channels[i], psd.width, psd.height);
                 // }
             }
             else if (compression === 1 /* Compression.RleCompressed */) {
-                var cmykImageData = {
+                const cmykImageData = {
                     width: imageData.width,
                     height: imageData.height,
                     data: new Uint8Array(imageData.width * imageData.height * 5),
                 };
-                var start = reader.offset;
+                const start = reader.offset;
                 readDataRLE(reader, cmykImageData, psd.width, psd.height, bitsPerChannel, 5, channels, reader.large);
                 cmykToRgb(cmykImageData, imageData, true);
                 if (RAW_IMAGE_DATA)
                     psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
             }
             else {
-                throw new Error("Not implemented");
+                throw new Error(`Not implemented`);
             }
             break;
         }
-        default: throw new Error("Color mode not supported: ".concat(psd.colorMode));
+        default: throw new Error(`Color mode not supported: ${psd.colorMode}`);
     }
     // remove weird white matte
     if (reader.globalAlpha) {
         if (psd.bitsPerChannel !== 8)
             throw new Error('bitsPerChannel Not supproted');
-        var p = imageData.data;
-        var size = imageData.width * imageData.height * 4;
-        for (var i = 0; i < size; i += 4) {
-            var pa = p[i + 3];
+        const p = imageData.data;
+        const size = imageData.width * imageData.height * 4;
+        for (let i = 0; i < size; i += 4) {
+            const pa = p[i + 3];
             if (pa != 0 && pa != 255) {
-                var a = pa / 255;
-                var ra = 1 / a;
-                var invA = 255 * (1 - ra);
+                const a = pa / 255;
+                const ra = 1 / a;
+                const invA = 255 * (1 - ra);
                 p[i + 0] = p[i + 0] * ra + invA;
                 p[i + 1] = p[i + 1] * ra + invA;
                 p[i + 2] = p[i + 2] * ra + invA;
@@ -846,14 +837,14 @@ function readImageData(reader, psd) {
     }
 }
 function cmykToRgb(cmyk, rgb, reverseAlpha) {
-    var size = rgb.width * rgb.height * 4;
-    var srcData = cmyk.data;
-    var dstData = rgb.data;
-    for (var src = 0, dst = 0; dst < size; src += 5, dst += 4) {
-        var c = srcData[src];
-        var m = srcData[src + 1];
-        var y = srcData[src + 2];
-        var k = srcData[src + 3];
+    const size = rgb.width * rgb.height * 4;
+    const srcData = cmyk.data;
+    const dstData = rgb.data;
+    for (let src = 0, dst = 0; dst < size; src += 5, dst += 4) {
+        const c = srcData[src];
+        const m = srcData[src + 1];
+        const y = srcData[src + 2];
+        const k = srcData[src + 3];
         dstData[dst] = ((((c * k) | 0) / 255) | 0);
         dstData[dst + 1] = ((((m * k) | 0) / 255) | 0);
         dstData[dst + 2] = ((((y * k) | 0) / 255) | 0);
@@ -871,11 +862,11 @@ function cmykToRgb(cmyk, rgb, reverseAlpha) {
     // }
 }
 function indexedToRgb(indexed, rgb, palette) {
-    var size = indexed.width * indexed.height;
-    var srcData = indexed.data;
-    var dstData = rgb.data;
-    for (var src = 0, dst = 0; src < size; src++, dst += 4) {
-        var c = palette[srcData[src]];
+    const size = indexed.width * indexed.height;
+    const srcData = indexed.data;
+    const dstData = rgb.data;
+    for (let src = 0, dst = 0; src < size; src++, dst += 4) {
+        const c = palette[srcData[src]];
         dstData[dst + 0] = c.r;
         dstData[dst + 1] = c.g;
         dstData[dst + 2] = c.b;
@@ -894,13 +885,13 @@ function bytesToArray(bytes, bitDepth) {
     else if (bitDepth === 16) {
         // PSD files store 16-bit channel data in big-endian byte order.
         // Swap each pair of bytes so that Uint16Array (native-endian) reads the correct values.
-        for (var i = 0; i < bytes.byteLength; i += 2) {
-            var tmp = bytes[i];
+        for (let i = 0; i < bytes.byteLength; i += 2) {
+            const tmp = bytes[i];
             bytes[i] = bytes[i + 1];
             bytes[i + 1] = tmp;
         }
         if (bytes.byteOffset % 2) {
-            var result = new Uint16Array(bytes.byteLength / 2);
+            const result = new Uint16Array(bytes.byteLength / 2);
             new Uint8Array(result.buffer, result.byteOffset, result.byteLength).set(bytes);
             return result;
         }
@@ -910,7 +901,7 @@ function bytesToArray(bytes, bitDepth) {
     }
     else if (bitDepth === 32) {
         if (bytes.byteOffset % 4) {
-            var result = new Float32Array(bytes.byteLength / 4);
+            const result = new Float32Array(bytes.byteLength / 4);
             new Uint8Array(result.buffer, result.byteOffset, result.byteLength).set(bytes);
             return result;
         }
@@ -919,47 +910,47 @@ function bytesToArray(bytes, bitDepth) {
         }
     }
     else {
-        throw new Error("Invalid bitDepth (".concat(bitDepth, ")"));
+        throw new Error(`Invalid bitDepth (${bitDepth})`);
     }
 }
 function copyChannelToPixelData(pixelData, channel, offset, step) {
     verifyCompatible(pixelData.data, channel);
-    var size = pixelData.width * pixelData.height;
-    var data = pixelData.data;
-    for (var i = 0, p = offset | 0; i < size; i++, p = (p + step) | 0) {
+    const size = pixelData.width * pixelData.height;
+    const data = pixelData.data;
+    for (let i = 0, p = offset | 0; i < size; i++, p = (p + step) | 0) {
         data[p] = channel[i];
     }
 }
 function readDataRaw(buffer, pixelData, bitDepth, step, offset) {
     if (bitDepth == 32) {
-        for (var i = 0; i < buffer.byteLength; i += 4) {
-            var a = buffer[i + 0];
-            var b = buffer[i + 1];
-            var c = buffer[i + 2];
-            var d = buffer[i + 3];
+        for (let i = 0; i < buffer.byteLength; i += 4) {
+            const a = buffer[i + 0];
+            const b = buffer[i + 1];
+            const c = buffer[i + 2];
+            const d = buffer[i + 3];
             buffer[i + 0] = d;
             buffer[i + 1] = c;
             buffer[i + 2] = b;
             buffer[i + 3] = a;
         }
     }
-    var array = bytesToArray(buffer, bitDepth);
+    const array = bytesToArray(buffer, bitDepth);
     if (pixelData && offset < step) {
         copyChannelToPixelData(pixelData, array, offset, step);
     }
 }
 function decodePredicted(data, width, height, mod) {
-    for (var y = 0; y < height; y++) {
-        var offset = y * width;
-        for (var x = 1, o = offset + 1; x < width; x++, o++) {
+    for (let y = 0; y < height; y++) {
+        const offset = y * width;
+        for (let x = 1, o = offset + 1; x < width; x++, o++) {
             data[o] = (data[o - 1] + data[o]) % mod;
         }
     }
 }
 export function readDataZip(compressed, pixelData, width, height, bitDepth, step, offset, prediction) {
-    var decompressed = inflateSync(compressed);
+    const decompressed = inflateSync(compressed);
     if (pixelData && offset < step) {
-        var array = bytesToArray(decompressed, bitDepth);
+        const array = bytesToArray(decompressed, bitDepth);
         if (bitDepth === 8) {
             if (prediction)
                 decodePredicted(decompressed, width, height, 0x100);
@@ -973,14 +964,14 @@ export function readDataZip(compressed, pixelData, width, height, bitDepth, step
         else if (bitDepth === 32) {
             if (prediction)
                 decodePredicted(decompressed, width * 4, height, 0x100);
-            var di = offset;
-            var dst = new Uint32Array(pixelData.data.buffer, pixelData.data.byteOffset, pixelData.data.length);
-            for (var y = 0; y < height; y++) {
-                var a = width * 4 * y;
-                for (var x = 0; x < width; x++, a++, di += step) {
-                    var b = a + width;
-                    var c = b + width;
-                    var d = c + width;
+            let di = offset;
+            const dst = new Uint32Array(pixelData.data.buffer, pixelData.data.byteOffset, pixelData.data.length);
+            for (let y = 0; y < height; y++) {
+                let a = width * 4 * y;
+                for (let x = 0; x < width; x++, a++, di += step) {
+                    const b = a + width;
+                    const c = b + width;
+                    const d = c + width;
                     dst[di] = ((decompressed[a] << 24) | (decompressed[b] << 16) | (decompressed[c] << 8) | decompressed[d]) >>> 0;
                 }
             }
@@ -991,50 +982,50 @@ export function readDataZip(compressed, pixelData, width, height, bitDepth, step
     }
 }
 export function readDataRLE(reader, pixelData, width, height, _bitDepth, step, offsets, large) {
-    var data = pixelData && pixelData.data;
-    var lengths;
+    const data = pixelData && pixelData.data;
+    let lengths;
     if (large) {
         lengths = new Uint32Array(offsets.length * height);
-        for (var o = 0, li = 0; o < offsets.length; o++) {
-            for (var y = 0; y < height; y++, li++) {
+        for (let o = 0, li = 0; o < offsets.length; o++) {
+            for (let y = 0; y < height; y++, li++) {
                 lengths[li] = readUint32(reader);
             }
         }
     }
     else {
         lengths = new Uint16Array(offsets.length * height);
-        for (var o = 0, li = 0; o < offsets.length; o++) {
-            for (var y = 0; y < height; y++, li++) {
+        for (let o = 0, li = 0; o < offsets.length; o++) {
+            for (let y = 0; y < height; y++, li++) {
                 lengths[li] = readUint16(reader);
             }
         }
     }
     // if (bitDepth !== 1 && bitDepth !== 8) throw new Error(`Invalid bit depth (${bitDepth})`);
-    var extraLimit = (step - 1) | 0; // 3 for rgb, 4 for cmyk
-    for (var c = 0, li = 0; c < offsets.length; c++) {
-        var offset = offsets[c] | 0;
-        var extra = c > extraLimit || offset > extraLimit;
+    const extraLimit = (step - 1) | 0; // 3 for rgb, 4 for cmyk
+    for (let c = 0, li = 0; c < offsets.length; c++) {
+        const offset = offsets[c] | 0;
+        const extra = c > extraLimit || offset > extraLimit;
         if (!data || extra) {
-            for (var y = 0; y < height; y++, li++) {
+            for (let y = 0; y < height; y++, li++) {
                 skipBytes(reader, lengths[li]);
             }
         }
         else {
-            for (var y = 0, p = offset | 0; y < height; y++, li++) {
-                var length_2 = lengths[li];
-                var buffer = readBytes(reader, length_2);
-                for (var i = 0, x = 0; i < length_2; i++) {
-                    var header = buffer[i];
+            for (let y = 0, p = offset | 0; y < height; y++, li++) {
+                const length = lengths[li];
+                const buffer = readBytes(reader, length);
+                for (let i = 0, x = 0; i < length; i++) {
+                    let header = buffer[i];
                     if (header > 128) {
-                        var value = buffer[++i];
+                        const value = buffer[++i];
                         header = (256 - header) | 0;
-                        for (var j = 0; j <= header && x < width; j = (j + 1) | 0, x = (x + 1) | 0) {
+                        for (let j = 0; j <= header && x < width; j = (j + 1) | 0, x = (x + 1) | 0) {
                             data[p] = value;
                             p = (p + step) | 0;
                         }
                     }
                     else if (header < 128) {
-                        for (var j = 0; j <= header && x < width; j = (j + 1) | 0, x = (x + 1) | 0) {
+                        for (let j = 0; j <= header && x < width; j = (j + 1) | 0, x = (x + 1) | 0) {
                             data[p] = buffer[++i];
                             p = (p + step) | 0;
                         }
@@ -1049,10 +1040,8 @@ export function readDataRLE(reader, pixelData, width, height, _bitDepth, step, o
         }
     }
 }
-export function readSection(reader, round, func, skipEmpty, eightBytes) {
-    if (skipEmpty === void 0) { skipEmpty = true; }
-    if (eightBytes === void 0) { eightBytes = false; }
-    var length = readUint32(reader);
+export function readSection(reader, round, func, skipEmpty = true, eightBytes = false) {
+    let length = readUint32(reader);
     if (eightBytes) {
         if (length !== 0)
             throw new Error('Sizes larger than 4GB are not supported');
@@ -1060,16 +1049,16 @@ export function readSection(reader, round, func, skipEmpty, eightBytes) {
     }
     if (length <= 0 && skipEmpty)
         return undefined;
-    var end = reader.offset + length;
+    let end = reader.offset + length;
     if (end > reader.view.byteLength)
         throw new Error('Section exceeds file size');
-    var result = func(function () { return end - reader.offset; });
+    const result = func(() => end - reader.offset);
     if (reader.offset !== end) {
         if (reader.offset > end) {
             warnOrThrow(reader, 'Exceeded section limits');
         }
         else {
-            warnOrThrow(reader, "Unread section data"); // : ${end - reader.offset} bytes at 0x${reader.offset.toString(16)}`);
+            warnOrThrow(reader, `Unread section data`); // : ${end - reader.offset} bytes at 0x${reader.offset.toString(16)}`);
         }
     }
     while (length % round) {
@@ -1081,67 +1070,67 @@ export function readSection(reader, round, func, skipEmpty, eightBytes) {
     return result;
 }
 export function readColor(reader) {
-    var colorSpace = readUint16(reader);
+    const colorSpace = readUint16(reader);
     switch (colorSpace) {
         case 0 /* ColorSpace.RGB */: {
-            var r = readUint16(reader) / 257;
-            var g = readUint16(reader) / 257;
-            var b = readUint16(reader) / 257;
+            const r = readUint16(reader) / 257;
+            const g = readUint16(reader) / 257;
+            const b = readUint16(reader) / 257;
             skipBytes(reader, 2);
-            return { r: r, g: g, b: b };
+            return { r, g, b };
         }
         case 1 /* ColorSpace.HSB */: {
-            var h = readUint16(reader) / 0xffff;
-            var s = readUint16(reader) / 0xffff;
-            var b = readUint16(reader) / 0xffff;
+            const h = readUint16(reader) / 0xffff;
+            const s = readUint16(reader) / 0xffff;
+            const b = readUint16(reader) / 0xffff;
             skipBytes(reader, 2);
-            return { h: h, s: s, b: b };
+            return { h, s, b };
         }
         case 2 /* ColorSpace.CMYK */: {
-            var c = readUint16(reader) / 257;
-            var m = readUint16(reader) / 257;
-            var y = readUint16(reader) / 257;
-            var k = readUint16(reader) / 257;
-            return { c: c, m: m, y: y, k: k };
+            const c = readUint16(reader) / 257;
+            const m = readUint16(reader) / 257;
+            const y = readUint16(reader) / 257;
+            const k = readUint16(reader) / 257;
+            return { c, m, y, k };
         }
         case 7 /* ColorSpace.Lab */: {
-            var l = readInt16(reader) / 10000;
-            var ta = readInt16(reader);
-            var tb = readInt16(reader);
-            var a = ta < 0 ? (ta / 12800) : (ta / 12700);
-            var b = tb < 0 ? (tb / 12800) : (tb / 12700);
+            const l = readInt16(reader) / 10000;
+            const ta = readInt16(reader);
+            const tb = readInt16(reader);
+            const a = ta < 0 ? (ta / 12800) : (ta / 12700);
+            const b = tb < 0 ? (tb / 12800) : (tb / 12700);
             skipBytes(reader, 2);
-            return { l: l, a: a, b: b };
+            return { l, a, b };
         }
         case 8 /* ColorSpace.Grayscale */: {
-            var k = readUint16(reader) * 255 / 10000;
+            const k = readUint16(reader) * 255 / 10000;
             skipBytes(reader, 6);
-            return { k: k };
+            return { k };
         }
         default:
             throw new Error('Invalid color space');
     }
 }
 export function readPattern(reader) {
-    var length = readUint32(reader);
+    let length = readUint32(reader);
     while (length % 4)
         length++;
-    var end = reader.offset + length;
-    var version = readUint32(reader);
+    const end = reader.offset + length;
+    const version = readUint32(reader);
     if (version !== 1)
-        throw new Error("Invalid pattern version: ".concat(version));
-    var colorMode = readUint32(reader);
-    var x = readInt16(reader);
-    var y = readInt16(reader);
+        throw new Error(`Invalid pattern version: ${version}`);
+    const colorMode = readUint32(reader);
+    const x = readInt16(reader);
+    const y = readInt16(reader);
     // we only support RGB and grayscale for now
     if (colorMode !== 3 /* ColorMode.RGB */ && colorMode !== 1 /* ColorMode.Grayscale */ && colorMode !== 2 /* ColorMode.Indexed */) {
-        throw new Error("Unsupported pattern color mode: ".concat(colorMode));
+        throw new Error(`Unsupported pattern color mode: ${colorMode}`);
     }
-    var name = readUnicodeString(reader);
-    var id = readPascalString(reader, 1);
-    var palette = [];
+    let name = readUnicodeString(reader);
+    const id = readPascalString(reader, 1);
+    const palette = [];
     if (colorMode === 2 /* ColorMode.Indexed */) {
-        for (var i = 0; i < 256; i++) {
+        for (let i = 0; i < 256; i++) {
             palette.push({
                 r: readUint8(reader),
                 g: readUint8(reader),
@@ -1151,58 +1140,58 @@ export function readPattern(reader) {
         skipBytes(reader, 4); // no idea what this is
     }
     // virtual memory array list
-    var version2 = readUint32(reader);
+    const version2 = readUint32(reader);
     if (version2 !== 3)
-        throw new Error("Invalid pattern VMAL version: ".concat(version2));
+        throw new Error(`Invalid pattern VMAL version: ${version2}`);
     readUint32(reader); // length
-    var top = readUint32(reader);
-    var left = readUint32(reader);
-    var bottom = readUint32(reader);
-    var right = readUint32(reader);
-    var channelsCount = readUint32(reader);
-    var width = right - left;
-    var height = bottom - top;
-    var data = new Uint8Array(width * height * 4);
-    for (var i = 3; i < data.byteLength; i += 4) {
+    const top = readUint32(reader);
+    const left = readUint32(reader);
+    const bottom = readUint32(reader);
+    const right = readUint32(reader);
+    const channelsCount = readUint32(reader);
+    const width = right - left;
+    const height = bottom - top;
+    const data = new Uint8Array(width * height * 4);
+    for (let i = 3; i < data.byteLength; i += 4) {
         data[i] = 255;
     }
-    for (var i = 0, ch = 0; i < (channelsCount + 2); i++) {
-        var has = readUint32(reader);
+    for (let i = 0, ch = 0; i < (channelsCount + 2); i++) {
+        const has = readUint32(reader);
         if (!has)
             continue;
-        var length_3 = readUint32(reader);
-        var pixelDepth = readUint32(reader);
-        var ctop = readUint32(reader);
-        var cleft = readUint32(reader);
-        var cbottom = readUint32(reader);
-        var cright = readUint32(reader);
-        var pixelDepth2 = readUint16(reader);
-        var compressionMode = readUint8(reader); // 0 - raw, 1 - rle
-        var dataLength = length_3 - (4 + 16 + 2 + 1);
-        var cdata = readBytes(reader, dataLength);
+        const length = readUint32(reader);
+        const pixelDepth = readUint32(reader);
+        const ctop = readUint32(reader);
+        const cleft = readUint32(reader);
+        const cbottom = readUint32(reader);
+        const cright = readUint32(reader);
+        const pixelDepth2 = readUint16(reader);
+        const compressionMode = readUint8(reader); // 0 - raw, 1 - rle
+        const dataLength = length - (4 + 16 + 2 + 1);
+        const cdata = readBytes(reader, dataLength);
         if (pixelDepth !== 8 || pixelDepth2 !== 8) {
             throw new Error('16bit pixel depth not supported for patterns');
         }
-        var w = cright - cleft;
-        var h = cbottom - ctop;
-        var ox = cleft - left;
-        var oy = ctop - top;
+        const w = cright - cleft;
+        const h = cbottom - ctop;
+        const ox = cleft - left;
+        const oy = ctop - top;
         if (compressionMode === 0) {
             if (colorMode === 3 /* ColorMode.RGB */ && ch < 3) {
-                for (var y_1 = 0; y_1 < h; y_1++) {
-                    for (var x_1 = 0; x_1 < w; x_1++) {
-                        var src = x_1 + y_1 * w;
-                        var dst = (ox + x_1 + (y_1 + oy) * width) * 4;
+                for (let y = 0; y < h; y++) {
+                    for (let x = 0; x < w; x++) {
+                        const src = x + y * w;
+                        const dst = (ox + x + (y + oy) * width) * 4;
                         data[dst + ch] = cdata[src];
                     }
                 }
             }
             if (colorMode === 1 /* ColorMode.Grayscale */ && ch < 1) {
-                for (var y_2 = 0; y_2 < h; y_2++) {
-                    for (var x_2 = 0; x_2 < w; x_2++) {
-                        var src = x_2 + y_2 * w;
-                        var dst = (ox + x_2 + (y_2 + oy) * width) * 4;
-                        var value = cdata[src];
+                for (let y = 0; y < h; y++) {
+                    for (let x = 0; x < w; x++) {
+                        const src = x + y * w;
+                        const dst = (ox + x + (y + oy) * width) * 4;
+                        const value = cdata[src];
                         data[dst + 0] = value;
                         data[dst + 1] = value;
                         data[dst + 2] = value;
@@ -1215,9 +1204,9 @@ export function readPattern(reader) {
             }
         }
         else if (compressionMode === 1) {
-            var pixelData = { data: data, width: width, height: height };
-            var tempData = { data: new Uint8Array(w * h), width: w, height: h };
-            var cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
+            const pixelData = { data, width, height };
+            const tempData = { data: new Uint8Array(w * h), width: w, height: h };
+            const cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
             if (colorMode === 3 /* ColorMode.RGB */ && ch < 3) {
                 readDataRLE(cdataReader, tempData, w, h, 8, 1, [0], false);
                 copyChannelToRGBA(tempData, pixelData, ox, oy, ch);
@@ -1238,17 +1227,17 @@ export function readPattern(reader) {
         ch++;
     }
     reader.offset = end;
-    return { id: id, name: name, x: x, y: y, bounds: { x: left, y: top, w: width, h: height }, data: data };
+    return { id, name, x, y, bounds: { x: left, y: top, w: width, h: height }, data };
 }
 function copyChannelToRGBA(srcData, dstData, ox, oy, offset) {
-    var w = srcData.width;
-    var h = srcData.height;
-    var width = dstData.width;
-    for (var y = 0; y < h; y++) {
-        for (var x = 0; x < w; x++) {
-            var src = x + y * w;
-            var dst = (ox + x + (y + oy) * width) * 4;
-            var value = srcData.data[src];
+    const w = srcData.width;
+    const h = srcData.height;
+    const width = dstData.width;
+    for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+            const src = x + y * w;
+            const dst = (ox + x + (y + oy) * width) * 4;
+            const value = srcData.data[src];
             dstData.data[dst + offset] = value;
         }
     }