ag-psd 30.1.1 → 30.2.0

package/dist-es/additionalInfo.js

@@ -1,28 +1,17 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import { fromByteArray, toByteArray } from 'base64-js';
 import { readEffects, writeEffects } from './effectsHelpers';
 import { clamp, createEnum, layerColors, MOCK_HANDLERS } from './helpers';
 import { readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16, readBytes, readInt16, checkSignature, readFloat32, readFixedPointPath32, readSection, readColor, readInt32, readPascalString, readUnicodeStringWithLength, readAsciiString, readPattern, readLayerInfo } from './psdReader';
-import { writeZeros, writeSignature, writeBytes, writeUint32, writeUint16, writeFloat64, writeUint8, writeInt16, writeFloat32, writeFixedPointPath32, writeUnicodeString, writeSection, writeUnicodeStringWithPadding, writeColor, writePascalString, writeInt32 } from './psdWriter';
+import { writeZeros, writeSignature, writeBytes, writeUint32, writeUint16, writeFloat64, writeUint8, writeInt16, writeFloat32, writeFixedPointPath32, writeUnicodeString, writeSection, writeUnicodeStringWithPadding, writeColor, writePascalString, writeInt32, writePattern } from './psdWriter';
 import { Annt, BlnM, parsePercent, parseUnits, parseUnitsOrNumber, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, textGridding, unitsPercent, unitsValue, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, Ornt, horzVrtcToXY, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, serializeTrackList, BlrM, BlrQ, SmBQ, SmBM, DspM, UndA, Cnvr, RplS, SphM, Wvtp, ZZTy, Dstr, Chnl, MztT, Lns, blurType, DfsM, ExtT, ExtR, FlCl, CntE, WndM, Drct, IntE, IntC, FlMd, unitsPercentF, frac, ClrS, descBoundsToBounds, boundsToDescBounds, presetKindType, gradientInterpolationMethodType } from './descriptor';
 import { serializeEngineData, parseEngineData } from './engineData';
 import { encodeEngineData, decodeEngineData } from './text';
 import { decodeEngineData2 } from './engineData2';
-var fromAtoZ = 'abcdefghijklmnopqrstuvwxyz';
-export var infoHandlers = [];
-export var infoHandlersMap = {};
+const fromAtoZ = 'abcdefghijklmnopqrstuvwxyz';
+export const infoHandlers = [];
+export const infoHandlersMap = {};
 function addHandler(key, has, read, write) {
-    var handler = { key: key, has: has, read: read, write: write };
+    const handler = { key, has, read, write };
     infoHandlers.push(handler);
     infoHandlersMap[handler.key] = handler;
 }
@@ -30,33 +19,33 @@ function addHandlerAlias(key, target) {
     infoHandlersMap[key] = infoHandlersMap[target];
 }
 function hasKey(key) {
-    return function (target) { return target[key] !== undefined; };
+    return (target) => target[key] !== undefined;
 }
 function readLength64(reader) {
     if (readUint32(reader))
-        throw new Error("Resource size above 4 GB limit at ".concat(reader.offset.toString(16)));
+        throw new Error(`Resource size above 4 GB limit at ${reader.offset.toString(16)}`);
     return readUint32(reader);
 }
 function writeLength64(writer, length) {
     writeUint32(writer, 0);
     writeUint32(writer, length);
 }
-addHandler('TySh', hasKey('text'), function (reader, target, leftBytes) {
+addHandler('TySh', hasKey('text'), (reader, target, leftBytes) => {
     if (readInt16(reader) !== 1)
-        throw new Error("Invalid TySh version");
-    var transform = [];
-    for (var i = 0; i < 6; i++)
+        throw new Error(`Invalid TySh version`);
+    const transform = [];
+    for (let i = 0; i < 6; i++)
         transform.push(readFloat64(reader));
     if (readInt16(reader) !== 50)
-        throw new Error("Invalid TySh text version");
-    var text = readVersionAndDescriptor(reader);
+        throw new Error(`Invalid TySh text version`);
+    const text = readVersionAndDescriptor(reader);
     // console.log(require('util').inspect(text, false, 99, false), 'utf8');
     if (readInt16(reader) !== 1)
-        throw new Error("Invalid TySh warp version");
-    var warp = readVersionAndDescriptor(reader);
+        throw new Error(`Invalid TySh warp version`);
+    const warp = readVersionAndDescriptor(reader);
     // console.log(require('util').inspect(warp, false, 99, false), 'utf8');
     target.text = {
-        transform: transform,
+        transform,
         left: readFloat32(reader),
         top: readFloat32(reader),
         right: readFloat32(reader),
@@ -79,8 +68,8 @@ addHandler('TySh', hasKey('text'), function (reader, target, leftBytes) {
     if (text.boundingBox)
         target.text.boundingBox = descBoundsToBounds(text.boundingBox);
     if (text.EngineData) {
-        var engineData = parseEngineData(text.EngineData);
-        var textData = decodeEngineData(engineData);
+        const engineData = parseEngineData(text.EngineData);
+        const textData = decodeEngineData(engineData);
         // console.log(require('util').inspect(engineData, false, 99, false), 'utf8');
         // require('fs').writeFileSync(`layer-${target.name}.txt`, require('util').inspect(engineData, false, 99, false), 'utf8');
         // const before = parseEngineData(text.EngineData);
@@ -88,17 +77,17 @@ addHandler('TySh', hasKey('text'), function (reader, target, leftBytes) {
         // require('fs').writeFileSync('before.txt', require('util').inspect(before, false, 99, false), 'utf8');
         // require('fs').writeFileSync('after.txt', require('util').inspect(after, false, 99, false), 'utf8');
         // console.log(require('util').inspect(parseEngineData(text.EngineData), false, 99, true));
-        target.text = __assign(__assign({}, target.text), textData);
+        target.text = Object.assign(Object.assign({}, target.text), textData);
         // console.log(require('util').inspect(target.text, false, 99, true));
     }
     skipBytes(reader, leftBytes());
-}, function (writer, target) {
-    var text = target.text;
-    var warp = text.warp || {};
-    var transform = text.transform || [1, 0, 0, 1, 0, 0];
-    var textDescriptor = __assign(__assign(__assign({ 'Txt ': (text.text || '').replace(/\r?\n/g, '\r'), textGridding: textGridding.encode(text.gridding), Ornt: Ornt.encode(text.orientation), AntA: Annt.encode(text.antiAlias) }, (text.bounds ? { bounds: boundsToDescBounds(text.bounds) } : {})), (text.boundingBox ? { boundingBox: boundsToDescBounds(text.boundingBox) } : {})), { TextIndex: text.index || 0, EngineData: serializeEngineData(encodeEngineData(text)) });
+}, (writer, target) => {
+    const text = target.text;
+    const warp = text.warp || {};
+    const transform = text.transform || [1, 0, 0, 1, 0, 0];
+    const textDescriptor = Object.assign(Object.assign(Object.assign({ 'Txt ': (text.text || '').replace(/\r?\n/g, '\r'), textGridding: textGridding.encode(text.gridding), Ornt: Ornt.encode(text.orientation), AntA: Annt.encode(text.antiAlias) }, (text.bounds ? { bounds: boundsToDescBounds(text.bounds) } : {})), (text.boundingBox ? { boundingBox: boundsToDescBounds(text.boundingBox) } : {})), { TextIndex: text.index || 0, EngineData: serializeEngineData(encodeEngineData(text)) });
     writeInt16(writer, 1); // version
-    for (var i = 0; i < 6; i++) {
+    for (let i = 0; i < 6; i++) {
         writeFloat64(writer, transform[i]);
     }
     writeInt16(writer, 50); // text version
@@ -112,48 +101,48 @@ addHandler('TySh', hasKey('text'), function (reader, target, leftBytes) {
     // writeZeros(writer, 2);
 });
 // vector fills
-addHandler('SoCo', function (target) { return target.vectorFill !== undefined && target.vectorStroke === undefined &&
-    target.vectorFill.type === 'color'; }, function (reader, target) {
-    var descriptor = readVersionAndDescriptor(reader);
+addHandler('SoCo', target => target.vectorFill !== undefined && target.vectorStroke === undefined &&
+    target.vectorFill.type === 'color', (reader, target) => {
+    const descriptor = readVersionAndDescriptor(reader);
     target.vectorFill = parseVectorContent(descriptor);
-}, function (writer, target) {
-    var descriptor = serializeVectorContent(target.vectorFill).descriptor;
+}, (writer, target) => {
+    const { descriptor } = serializeVectorContent(target.vectorFill);
     writeVersionAndDescriptor(writer, '', 'null', descriptor);
 });
-addHandler('GdFl', function (target) { return target.vectorFill !== undefined && target.vectorStroke === undefined &&
-    (target.vectorFill.type === 'solid' || target.vectorFill.type === 'noise'); }, function (reader, target, left) {
-    var descriptor = readVersionAndDescriptor(reader);
+addHandler('GdFl', target => target.vectorFill !== undefined && target.vectorStroke === undefined &&
+    (target.vectorFill.type === 'solid' || target.vectorFill.type === 'noise'), (reader, target, left) => {
+    const descriptor = readVersionAndDescriptor(reader);
     target.vectorFill = parseVectorContent(descriptor);
     skipBytes(reader, left());
-}, function (writer, target) {
-    var descriptor = serializeVectorContent(target.vectorFill).descriptor;
+}, (writer, target) => {
+    const { descriptor } = serializeVectorContent(target.vectorFill);
     writeVersionAndDescriptor(writer, '', 'null', descriptor);
 });
-addHandler('PtFl', function (target) { return target.vectorFill !== undefined && target.vectorStroke === undefined &&
-    target.vectorFill.type === 'pattern'; }, function (reader, target) {
-    var descriptor = readVersionAndDescriptor(reader);
+addHandler('PtFl', target => target.vectorFill !== undefined && target.vectorStroke === undefined &&
+    target.vectorFill.type === 'pattern', (reader, target) => {
+    const descriptor = readVersionAndDescriptor(reader);
     target.vectorFill = parseVectorContent(descriptor);
-}, function (writer, target) {
-    var descriptor = serializeVectorContent(target.vectorFill).descriptor;
+}, (writer, target) => {
+    const { descriptor } = serializeVectorContent(target.vectorFill);
     writeVersionAndDescriptor(writer, '', 'null', descriptor);
 });
-addHandler('vscg', function (target) { return target.vectorFill !== undefined && target.vectorStroke !== undefined; }, function (reader, target, left) {
+addHandler('vscg', target => target.vectorFill !== undefined && target.vectorStroke !== undefined, (reader, target, left) => {
     readSignature(reader); // key
-    var desc = readVersionAndDescriptor(reader);
+    const desc = readVersionAndDescriptor(reader);
     target.vectorFill = parseVectorContent(desc);
     skipBytes(reader, left());
-}, function (writer, target) {
-    var _a = serializeVectorContent(target.vectorFill), descriptor = _a.descriptor, key = _a.key;
+}, (writer, target) => {
+    const { descriptor, key } = serializeVectorContent(target.vectorFill);
     writeSignature(writer, key);
     writeVersionAndDescriptor(writer, '', 'null', descriptor);
 });
 export function readBezierKnot(reader, width, height) {
-    var y0 = readFixedPointPath32(reader) * height;
-    var x0 = readFixedPointPath32(reader) * width;
-    var y1 = readFixedPointPath32(reader) * height;
-    var x1 = readFixedPointPath32(reader) * width;
-    var y2 = readFixedPointPath32(reader) * height;
-    var x2 = readFixedPointPath32(reader) * width;
+    const y0 = readFixedPointPath32(reader) * height;
+    const x0 = readFixedPointPath32(reader) * width;
+    const y1 = readFixedPointPath32(reader) * height;
+    const x1 = readFixedPointPath32(reader) * width;
+    const y2 = readFixedPointPath32(reader) * height;
+    const x2 = readFixedPointPath32(reader) * width;
     return [x0, y0, x1, y1, x2, y2];
 }
 function writeBezierKnot(writer, points, width, height) {
@@ -164,19 +153,19 @@ function writeBezierKnot(writer, points, width, height) {
     writeFixedPointPath32(writer, points[5] / height); // y2
     writeFixedPointPath32(writer, points[4] / width); // x2
 }
-export var booleanOperations = ['exclude', 'combine', 'subtract', 'intersect'];
+export const booleanOperations = ['exclude', 'combine', 'subtract', 'intersect'];
 export function readVectorMask(reader, vectorMask, width, height, size) {
-    var end = reader.offset + size;
-    var paths = vectorMask.paths;
-    var path = undefined;
+    const end = reader.offset + size;
+    const paths = vectorMask.paths;
+    let path = undefined;
     while ((end - reader.offset) >= 26) {
-        var selector = readUint16(reader);
+        const selector = readUint16(reader);
         switch (selector) {
             case 0: // Closed subpath length record
             case 3: { // Open subpath length record
                 readUint16(reader); // count
-                var boolOp = readInt16(reader);
-                var flags = readUint16(reader); // bit 1 always 1 ?
+                const boolOp = readInt16(reader);
+                const flags = readUint16(reader); // bit 1 always 1 ?
                 skipBytes(reader, 18);
                 path = {
                     open: selector === 3,
@@ -199,13 +188,13 @@ export function readVectorMask(reader, vectorMask, width, height, size) {
                 break;
             case 7: { // Clipboard record
                 // TODO: check if these need to be multiplied by document size
-                var top_1 = readFixedPointPath32(reader);
-                var left = readFixedPointPath32(reader);
-                var bottom = readFixedPointPath32(reader);
-                var right = readFixedPointPath32(reader);
-                var resolution = readFixedPointPath32(reader);
+                const top = readFixedPointPath32(reader);
+                const left = readFixedPointPath32(reader);
+                const bottom = readFixedPointPath32(reader);
+                const right = readFixedPointPath32(reader);
+                const resolution = readFixedPointPath32(reader);
                 skipBytes(reader, 4);
-                vectorMask.clipboard = { top: top_1, left: left, bottom: bottom, right: right, resolution: resolution };
+                vectorMask.clipboard = { top, left, bottom, right, resolution };
                 break;
             }
             case 8: // Initial fill rule record
@@ -217,23 +206,21 @@ export function readVectorMask(reader, vectorMask, width, height, size) {
     }
     return paths;
 }
-addHandler('vmsk', hasKey('vectorMask'), function (reader, target, left, _a) {
-    var width = _a.width, height = _a.height;
+addHandler('vmsk', hasKey('vectorMask'), (reader, target, left, { width, height }) => {
     if (readUint32(reader) !== 3)
         throw new Error('Invalid vmsk version');
     target.vectorMask = { paths: [] };
-    var vectorMask = target.vectorMask;
-    var flags = readUint32(reader);
+    const vectorMask = target.vectorMask;
+    const flags = readUint32(reader);
     vectorMask.invert = (flags & 1) !== 0;
     vectorMask.notLink = (flags & 2) !== 0;
     vectorMask.disable = (flags & 4) !== 0;
     readVectorMask(reader, vectorMask, width, height, left());
     // drawBezierPaths(vectorMask.paths, width, height, 'out.png');
     skipBytes(reader, left());
-}, function (writer, target, _a) {
-    var width = _a.width, height = _a.height;
-    var vectorMask = target.vectorMask;
-    var flags = (vectorMask.invert ? 1 : 0) |
+}, (writer, target, { width, height }) => {
+    const vectorMask = target.vectorMask;
+    const flags = (vectorMask.invert ? 1 : 0) |
         (vectorMask.notLink ? 2 : 0) |
         (vectorMask.disable ? 4 : 0);
     writeUint32(writer, 3); // version
@@ -241,7 +228,7 @@ addHandler('vmsk', hasKey('vectorMask'), function (reader, target, left, _a) {
     // initial entry
     writeUint16(writer, 6);
     writeZeros(writer, 24);
-    var clipboard = vectorMask.clipboard;
+    const clipboard = vectorMask.clipboard;
     if (clipboard) {
         writeUint16(writer, 7);
         writeFixedPointPath32(writer, clipboard.top);
@@ -254,17 +241,15 @@ addHandler('vmsk', hasKey('vectorMask'), function (reader, target, left, _a) {
     writeUint16(writer, 8);
     writeUint16(writer, vectorMask.fillStartsWithAllPixels ? 1 : 0);
     writeZeros(writer, 22);
-    for (var _i = 0, _b = vectorMask.paths; _i < _b.length; _i++) {
-        var path = _b[_i];
+    for (const path of vectorMask.paths) {
         writeUint16(writer, path.open ? 3 : 0);
         writeUint16(writer, path.knots.length);
         writeUint16(writer, path.operation ? booleanOperations.indexOf(path.operation) : -1); // -1 for undefined
         writeUint16(writer, path.fillRule === 'non-zero' ? 2 : 1);
         writeZeros(writer, 18); // TODO: these are sometimes non-zero
-        var linkedKnot = path.open ? 4 : 1;
-        var unlinkedKnot = path.open ? 5 : 2;
-        for (var _c = 0, _d = path.knots; _c < _d.length; _c++) {
-            var _e = _d[_c], linked = _e.linked, points = _e.points;
+        const linkedKnot = path.open ? 4 : 1;
+        const unlinkedKnot = path.open ? 5 : 2;
+        for (const { linked, points } of path.knots) {
             writeUint16(writer, linked ? linkedKnot : unlinkedKnot);
             writeBezierKnot(writer, points, width, height);
         }
@@ -274,20 +259,19 @@ addHandler('vmsk', hasKey('vectorMask'), function (reader, target, left, _a) {
 addHandlerAlias('vsms', 'vmsk');
 // addHandlerAlias('vmsk', 'vsms');
 addHandler('vowv', // something with vectors?
-hasKey('vowv'), function (reader, target) {
+hasKey('vowv'), (reader, target) => {
     target.vowv = readUint32(reader); // always 2 ????
-}, function (writer, target) {
+}, (writer, target) => {
     writeUint32(writer, target.vowv);
 });
-addHandler('vogk', hasKey('vectorOrigination'), function (reader, target, left) {
+addHandler('vogk', hasKey('vectorOrigination'), (reader, target, left) => {
     if (readInt32(reader) !== 1)
-        throw new Error("Invalid vogk version");
-    var desc = readVersionAndDescriptor(reader);
+        throw new Error(`Invalid vogk version`);
+    const desc = readVersionAndDescriptor(reader);
     // console.log(require('util').inspect(desc, false, 99, true));
     target.vectorOrigination = { keyDescriptorList: [] };
-    for (var _i = 0, _a = desc.keyDescriptorList; _i < _a.length; _i++) {
-        var i = _a[_i];
-        var item = {};
+    for (const i of desc.keyDescriptorList) {
+        const item = {};
         if (i.keyShapeInvalidated != null)
             item.keyShapeInvalidated = i.keyShapeInvalidated;
         if (i.keyOriginType != null)
@@ -302,7 +286,7 @@ addHandler('vogk', hasKey('vectorOrigination'), function (reader, target, left)
                 right: parseUnitsOrNumber(i.keyOriginShapeBBox.Rght),
             };
         }
-        var rectRadii = i.keyOriginRRectRadii;
+        const rectRadii = i.keyOriginRRectRadii;
         if (rectRadii) {
             item.keyOriginRRectRadii = {
                 topRight: parseUnits(rectRadii.topRight),
@@ -311,7 +295,7 @@ addHandler('vogk', hasKey('vectorOrigination'), function (reader, target, left)
                 bottomRight: parseUnits(rectRadii.bottomRight),
             };
         }
-        var corners = i.keyOriginBoxCorners;
+        const corners = i.keyOriginBoxCorners;
         if (corners) {
             item.keyOriginBoxCorners = [
                 { x: corners.rectangleCornerA.Hrzn, y: corners.rectangleCornerA.Vrtc },
@@ -320,26 +304,26 @@ addHandler('vogk', hasKey('vectorOrigination'), function (reader, target, left)
                 { x: corners.rectangleCornerD.Hrzn, y: corners.rectangleCornerD.Vrtc },
             ];
         }
-        var trnf = i.Trnf;
+        const trnf = i.Trnf;
         if (trnf) {
             item.transform = [trnf.xx, trnf.xy, trnf.yx, trnf.yy, trnf.tx, trnf.ty];
         }
         target.vectorOrigination.keyDescriptorList.push(item);
     }
     skipBytes(reader, left());
-}, function (writer, target) {
+}, (writer, target) => {
     target;
-    var orig = target.vectorOrigination;
-    var desc = { keyDescriptorList: [] };
-    for (var i = 0; i < orig.keyDescriptorList.length; i++) {
-        var item = orig.keyDescriptorList[i];
+    const orig = target.vectorOrigination;
+    const desc = { keyDescriptorList: [] };
+    for (let i = 0; i < orig.keyDescriptorList.length; i++) {
+        const item = orig.keyDescriptorList[i];
         desc.keyDescriptorList.push({}); // we're adding keyOriginIndex at the end
-        var out = desc.keyDescriptorList[desc.keyDescriptorList.length - 1];
+        const out = desc.keyDescriptorList[desc.keyDescriptorList.length - 1];
         if (item.keyOriginType != null)
             out.keyOriginType = item.keyOriginType;
         if (item.keyOriginResolution != null)
             out.keyOriginResolution = item.keyOriginResolution;
-        var radii = item.keyOriginRRectRadii;
+        const radii = item.keyOriginRRectRadii;
         if (radii) {
             out.keyOriginRRectRadii = {
                 unitValueQuadVersion: 1,
@@ -349,7 +333,7 @@ addHandler('vogk', hasKey('vectorOrigination'), function (reader, target, left)
                 bottomRight: unitsValue(radii.bottomRight, 'bottomRight'),
             };
         }
-        var box = item.keyOriginShapeBoundingBox;
+        const box = item.keyOriginShapeBoundingBox;
         if (box) {
             out.keyOriginShapeBBox = {
                 unitValueQuadVersion: 1,
@@ -359,7 +343,7 @@ addHandler('vogk', hasKey('vectorOrigination'), function (reader, target, left)
                 Rght: unitsValue(box.right, 'right'),
             };
         }
-        var corners = item.keyOriginBoxCorners;
+        const corners = item.keyOriginBoxCorners;
         if (corners && corners.length === 4) {
             out.keyOriginBoxCorners = {
                 rectangleCornerA: { Hrzn: corners[0].x, Vrtc: corners[0].y },
@@ -368,7 +352,7 @@ addHandler('vogk', hasKey('vectorOrigination'), function (reader, target, left)
                 rectangleCornerD: { Hrzn: corners[3].x, Vrtc: corners[3].y },
             };
         }
-        var transform = item.transform;
+        const transform = item.transform;
         if (transform && transform.length === 6) {
             out.Trnf = {
                 xx: transform[0],
@@ -386,33 +370,33 @@ addHandler('vogk', hasKey('vectorOrigination'), function (reader, target, left)
     writeInt32(writer, 1); // version
     writeVersionAndDescriptor(writer, '', 'null', desc);
 });
-addHandler('lmfx', function (target) { return target.effects !== undefined && hasMultiEffects(target.effects); }, function (reader, target, left) {
-    var version = readUint32(reader);
+addHandler('lmfx', target => target.effects !== undefined && hasMultiEffects(target.effects), (reader, target, left) => {
+    const version = readUint32(reader);
     if (version !== 0)
         throw new Error('Invalid lmfx version');
-    var desc = readVersionAndDescriptor(reader);
+    const desc = readVersionAndDescriptor(reader);
     // console.log('READ', require('util').inspect(desc, false, 99, true));
     // discard if read in 'lrFX' or 'lfx2' section
     target.effects = parseEffects(desc, !!reader.logMissingFeatures);
     skipBytes(reader, left());
-}, function (writer, target, _, options) {
-    var desc = serializeEffects(target.effects, !!options.logMissingFeatures, true);
+}, (writer, target, _, options) => {
+    const desc = serializeEffects(target.effects, !!options.logMissingFeatures, true);
     // console.log('WRITE', require('util').inspect(desc, false, 99, true));
     writeUint32(writer, 0); // version
     writeVersionAndDescriptor(writer, '', 'null', desc);
 });
-addHandler('lrFX', hasKey('effects'), function (reader, target, left) {
+addHandler('lrFX', hasKey('effects'), (reader, target, left) => {
     if (!target.effects)
         target.effects = readEffects(reader);
     skipBytes(reader, left());
-}, function (writer, target) {
+}, (writer, target) => {
     writeEffects(writer, target.effects);
 });
-addHandler('luni', hasKey('name'), function (reader, target, left) {
+addHandler('luni', hasKey('name'), (reader, target, left) => {
     if (left() > 4) {
-        var length_1 = readUint32(reader);
-        if (left() >= (length_1 * 2)) {
-            target.name = readUnicodeStringWithLength(reader, length_1);
+        const length = readUint32(reader);
+        if (left() >= (length * 2)) {
+            target.name = readUnicodeStringWithLength(reader, length);
         }
         else {
             if (reader.logDevFeatures)
@@ -424,22 +408,22 @@ addHandler('luni', hasKey('name'), function (reader, target, left) {
             reader.log('empty luni section');
     }
     skipBytes(reader, left());
-}, function (writer, target) {
+}, (writer, target) => {
     writeUnicodeString(writer, target.name);
     // writeUint16(writer, 0); // padding (but not extending string length)
 });
-addHandler('lnsr', hasKey('nameSource'), function (reader, target) { return target.nameSource = readSignature(reader); }, function (writer, target) { return writeSignature(writer, target.nameSource); });
-addHandler('lyid', hasKey('id'), function (reader, target) {
+addHandler('lnsr', hasKey('nameSource'), (reader, target) => target.nameSource = readSignature(reader), (writer, target) => writeSignature(writer, target.nameSource));
+addHandler('lyid', hasKey('id'), (reader, target) => {
     target.id = readUint32(reader);
-}, function (writer, target, _psd, options) {
-    var id = target.id;
+}, (writer, target, _psd, options) => {
+    let id = target.id;
     while (options.layerIds.has(id))
         id += 100; // make sure we don't have duplicate layer ids
     writeUint32(writer, id);
     options.layerIds.add(id);
     options.layerToId.set(target, id);
 });
-addHandler('lsct', hasKey('sectionDivider'), function (reader, target, left) {
+addHandler('lsct', hasKey('sectionDivider'), (reader, target, left) => {
     target.sectionDivider = { type: readUint32(reader) };
     if (left()) {
         checkSignature(reader, '8BIM');
@@ -448,7 +432,7 @@ addHandler('lsct', hasKey('sectionDivider'), function (reader, target, left) {
     if (left()) {
         target.sectionDivider.subType = readUint32(reader);
     }
-}, function (writer, target) {
+}, (writer, target) => {
     writeUint32(writer, target.sectionDivider.type);
     if (target.sectionDivider.key) {
         writeSignature(writer, '8BIM');
@@ -461,36 +445,36 @@ addHandler('lsct', hasKey('sectionDivider'), function (reader, target, left) {
 // it seems lsdk is used when there's a layer is nested more than 6 levels, but I don't know why?
 // maybe some limitation of old version of PS?
 addHandlerAlias('lsdk', 'lsct');
-addHandler('clbl', hasKey('blendClippendElements'), function (reader, target) {
+addHandler('clbl', hasKey('blendClippendElements'), (reader, target) => {
     target.blendClippendElements = !!readUint8(reader);
     skipBytes(reader, 3);
-}, function (writer, target) {
+}, (writer, target) => {
     writeUint8(writer, target.blendClippendElements ? 1 : 0);
     writeZeros(writer, 3);
 });
-addHandler('infx', hasKey('blendInteriorElements'), function (reader, target) {
+addHandler('infx', hasKey('blendInteriorElements'), (reader, target) => {
     target.blendInteriorElements = !!readUint8(reader);
     skipBytes(reader, 3);
-}, function (writer, target) {
+}, (writer, target) => {
     writeUint8(writer, target.blendInteriorElements ? 1 : 0);
     writeZeros(writer, 3);
 });
-addHandler('knko', hasKey('knockout'), function (reader, target) {
+addHandler('knko', hasKey('knockout'), (reader, target) => {
     target.knockout = !!readUint8(reader);
     skipBytes(reader, 3);
-}, function (writer, target) {
+}, (writer, target) => {
     writeUint8(writer, target.knockout ? 1 : 0);
     writeZeros(writer, 3);
 });
-addHandler('lmgm', hasKey('layerMaskAsGlobalMask'), function (reader, target) {
+addHandler('lmgm', hasKey('layerMaskAsGlobalMask'), (reader, target) => {
     target.layerMaskAsGlobalMask = !!readUint8(reader);
     skipBytes(reader, 3);
-}, function (writer, target) {
+}, (writer, target) => {
     writeUint8(writer, target.layerMaskAsGlobalMask ? 1 : 0);
     writeZeros(writer, 3);
 });
-addHandler('lspf', hasKey('protected'), function (reader, target) {
-    var flags = readUint32(reader);
+addHandler('lspf', hasKey('protected'), (reader, target) => {
+    const flags = readUint32(reader);
     target.protected = {
         transparency: (flags & 0x01) !== 0,
         composite: (flags & 0x02) !== 0,
@@ -498,45 +482,45 @@ addHandler('lspf', hasKey('protected'), function (reader, target) {
     };
     if (flags & 0x08)
         target.protected.artboards = true;
-}, function (writer, target) {
-    var flags = (target.protected.transparency ? 0x01 : 0) |
+}, (writer, target) => {
+    const flags = (target.protected.transparency ? 0x01 : 0) |
         (target.protected.composite ? 0x02 : 0) |
         (target.protected.position ? 0x04 : 0) |
         (target.protected.artboards ? 0x08 : 0);
     writeUint32(writer, flags);
 });
-addHandler('lclr', hasKey('layerColor'), function (reader, target) {
-    var color = readUint16(reader);
+addHandler('lclr', hasKey('layerColor'), (reader, target) => {
+    const color = readUint16(reader);
     skipBytes(reader, 6);
     target.layerColor = layerColors[color];
-}, function (writer, target) {
-    var index = layerColors.indexOf(target.layerColor);
+}, (writer, target) => {
+    const index = layerColors.indexOf(target.layerColor);
     writeUint16(writer, index === -1 ? 0 : index);
     writeZeros(writer, 6);
 });
 addHandler('shmd', // Metadata setting
-function (// Metadata setting
-target) { return target.timestamp !== undefined || target.animationFrames !== undefined || target.animationFrameFlags !== undefined || target.timeline !== undefined || target.comps !== undefined; }, function (reader, target, left) {
-    var count = readUint32(reader);
-    var _loop_1 = function (i) {
+// Metadata setting
+target => target.timestamp !== undefined || target.animationFrames !== undefined || target.animationFrameFlags !== undefined || target.timeline !== undefined || target.comps !== undefined, (reader, target, left) => {
+    const count = readUint32(reader);
+    for (let i = 0; i < count; i++) {
         checkSignature(reader, '8BIM');
-        var key = readSignature(reader);
+        const key = readSignature(reader);
         readUint8(reader); // copy
         skipBytes(reader, 3);
-        readSection(reader, 1, function (left) {
+        readSection(reader, 1, left => {
             if (key === 'cust') {
-                var desc = readVersionAndDescriptor(reader);
+                const desc = readVersionAndDescriptor(reader);
                 // console.log('cust', target.name, require('util').inspect(desc, false, 99, true));
                 if (desc.layerTime !== undefined)
                     target.timestamp = desc.layerTime;
             }
             else if (key === 'mlst') {
-                var desc = readVersionAndDescriptor(reader);
+                const desc = readVersionAndDescriptor(reader);
                 // console.log('mlst', target.name, require('util').inspect(desc, false, 99, true));
                 target.animationFrames = [];
-                for (var i_1 = 0; i_1 < desc.LaSt.length; i_1++) {
-                    var f = desc.LaSt[i_1];
-                    var frame = { frames: f.FrLs };
+                for (let i = 0; i < desc.LaSt.length; i++) {
+                    const f = desc.LaSt[i];
+                    const frame = { frames: f.FrLs };
                     if (f.enab !== undefined)
                         frame.enable = f.enab;
                     if (f.Ofst)
@@ -553,8 +537,8 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
             else if (key === 'mdyn') {
                 // frame flags
                 readUint16(reader); // unknown
-                var propagate = readUint8(reader);
-                var flags = readUint8(reader);
+                const propagate = readUint8(reader);
+                const flags = readUint8(reader);
                 target.animationFrameFlags = {
                     propagateFrameOne: !propagate,
                     unifyLayerPosition: (flags & 1) !== 0,
@@ -563,10 +547,10 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
                 };
             }
             else if (key === 'tmln') {
-                var desc = readVersionAndDescriptor(reader);
-                var timeScope = desc.timeScope;
+                const desc = readVersionAndDescriptor(reader);
+                const timeScope = desc.timeScope;
                 // console.log('tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
-                var timeline = {
+                const timeline = {
                     start: frac(timeScope.Strt),
                     duration: frac(timeScope.duration),
                     inTime: frac(timeScope.inTime),
@@ -581,17 +565,16 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
                 // console.log('tmln:result', target.name, target.id, require('util').inspect(timeline, false, 99, true));
             }
             else if (key === 'cmls') {
-                var desc = readVersionAndDescriptor(reader);
+                const desc = readVersionAndDescriptor(reader);
                 // console.log('cmls', require('util').inspect(desc, false, 99, true));
                 target.comps = {
                     settings: [],
                 };
                 if (desc.origFXRefPoint)
                     target.comps.originalEffectsReferencePoint = { x: desc.origFXRefPoint.Hrzn, y: desc.origFXRefPoint.Vrtc };
-                for (var _i = 0, _a = desc.layerSettings; _i < _a.length; _i++) {
-                    var item = _a[_i];
+                for (const item of desc.layerSettings) {
                     target.comps.settings.push({ compList: item.compList });
-                    var t = target.comps.settings[target.comps.settings.length - 1];
+                    const t = target.comps.settings[target.comps.settings.length - 1];
                     if ('enab' in item)
                         t.enabled = item.enab;
                     if (item.Ofst)
@@ -601,7 +584,7 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
                 }
             }
             else if (key === 'extn') {
-                var desc = readVersionAndDescriptor(reader);
+                const desc = readVersionAndDescriptor(reader);
                 // console.log(require('util').inspect(desc, false, 99, true));
                 desc; // TODO: save this
                 reader.logMissingFeatures && reader.log('Unhandled "shmd" section key', key);
@@ -611,14 +594,11 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
             }
             skipBytes(reader, left());
         });
-    };
-    for (var i = 0; i < count; i++) {
-        _loop_1(i);
     }
     skipBytes(reader, left());
-}, function (writer, target, _, options) {
-    var animationFrames = target.animationFrames, animationFrameFlags = target.animationFrameFlags, timestamp = target.timestamp, timeline = target.timeline, comps = target.comps;
-    var count = 0;
+}, (writer, target, _, options) => {
+    const { animationFrames, animationFrameFlags, timestamp, timeline, comps } = target;
+    let count = 0;
     if (animationFrames)
         count++;
     if (animationFrameFlags)
@@ -635,15 +615,15 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
         writeSignature(writer, 'mlst');
         writeUint8(writer, 0); // copy (always false)
         writeZeros(writer, 3);
-        writeSection(writer, 2, function () {
+        writeSection(writer, 2, () => {
             var _a;
-            var desc = {
+            const desc = {
                 LaID: (_a = target.id) !== null && _a !== void 0 ? _a : 0,
                 LaSt: [],
             };
-            for (var i = 0; i < animationFrames.length; i++) {
-                var f = animationFrames[i];
-                var frame = {};
+            for (let i = 0; i < animationFrames.length; i++) {
+                const f = animationFrames[i];
+                const frame = {};
                 if (f.enable !== undefined)
                     frame.enab = f.enable;
                 frame.FrLs = f.frames;
@@ -665,7 +645,7 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
         writeSignature(writer, 'mdyn');
         writeUint8(writer, 0); // copy (always false)
         writeZeros(writer, 3);
-        writeSection(writer, 2, function () {
+        writeSection(writer, 2, () => {
             writeUint16(writer, 0); // unknown
             writeUint8(writer, animationFrameFlags.propagateFrameOne ? 0x0 : 0xf);
             writeUint8(writer, (animationFrameFlags.unifyLayerPosition ? 1 : 0) |
@@ -678,8 +658,8 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
         writeSignature(writer, 'tmln');
         writeUint8(writer, 0); // copy (always false)
         writeZeros(writer, 3);
-        writeSection(writer, 2, function () {
-            var desc = {
+        writeSection(writer, 2, () => {
+            const desc = {
                 Vrsn: 1,
                 timeScope: {
                     Vrsn: 1,
@@ -694,7 +674,7 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
             if (timeline.tracks) {
                 desc.trackList = serializeTrackList(timeline.tracks);
             }
-            var id = options.layerToId.get(target) || target.id;
+            const id = options.layerToId.get(target) || target.id;
             if (!id)
                 throw new Error('You need to provide layer.id value whan writing document with animations');
             desc.LyrI = id;
@@ -707,8 +687,8 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
         writeSignature(writer, 'cust');
         writeUint8(writer, 0); // copy (always false)
         writeZeros(writer, 3);
-        writeSection(writer, 2, function () {
-            var desc = {
+        writeSection(writer, 2, () => {
+            const desc = {
                 layerTime: timestamp,
             };
             writeVersionAndDescriptor(writer, '', 'metadata', desc);
@@ -719,19 +699,18 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
         writeSignature(writer, 'cmls');
         writeUint8(writer, 0); // copy (always false)
         writeZeros(writer, 3);
-        writeSection(writer, 2, function () {
-            var id = options.layerToId.get(target) || target.id;
+        writeSection(writer, 2, () => {
+            const id = options.layerToId.get(target) || target.id;
             if (!id)
                 throw new Error('You need to provide layer.id value whan writing document with layer comps');
-            var desc = {};
+            const desc = {};
             if (comps.originalEffectsReferencePoint) {
                 desc.origFXRefPoint = { Hrzn: comps.originalEffectsReferencePoint.x, Vrtc: comps.originalEffectsReferencePoint.y };
             }
             desc.LyrI = id;
             desc.layerSettings = [];
-            for (var _i = 0, _a = comps.settings; _i < _a.length; _i++) {
-                var item = _a[_i];
-                var t = {};
+            for (const item of comps.settings) {
+                const t = {};
                 if (item.enabled !== undefined)
                     t.enab = item.enabled;
                 if (item.offset)
@@ -746,8 +725,8 @@ target) { return target.timestamp !== undefined || target.animationFrames !== un
         }, true);
     }
 });
-addHandler('PxSc', function () { return false; }, function (reader, target) {
-    var desc = readVersionAndDescriptor(reader, true);
+addHandler('PxSc', () => false, (reader, target) => {
+    const desc = readVersionAndDescriptor(reader, true);
     // console.log('PxSc', require('util').inspect(desc, false, 99, true));
     if (desc.pixelSourceType === 1986285651) {
         target.pixelSource = {
@@ -772,11 +751,11 @@ addHandler('PxSc', function () { return false; }, function (reader, target) {
         };
     }
     else {
-        reader.log("Unknown pixelSourceType");
+        reader.log(`Unknown pixelSourceType`);
     }
-}, function (writer, target) {
-    var source = target.pixelSource;
-    var desc = {
+}, (writer, target) => {
+    const source = target.pixelSource;
+    const desc = {
         _name: '',
         _classID: 'PixelSource',
         pixelSourceType: 1986285651,
@@ -786,7 +765,7 @@ addHandler('PxSc', function () { return false; }, function (reader, target) {
             _name: '',
             _classID: 'footageInterpretation',
             Vrsn: 1,
-            interpretAlpha: "alphaInterpretation.".concat(source.interpretation.interpretAlpha),
+            interpretAlpha: `alphaInterpretation.${source.interpretation.interpretAlpha}`,
             profile: source.interpretation.profile,
         },
         frameReader: {
@@ -810,8 +789,8 @@ addHandler('PxSc', function () { return false; }, function (reader, target) {
     };
     writeVersionAndDescriptor(writer, '', 'PixelSource', desc);
 });
-addHandler('vstk', hasKey('vectorStroke'), function (reader, target, left) {
-    var desc = readVersionAndDescriptor(reader);
+addHandler('vstk', hasKey('vectorStroke'), (reader, target, left) => {
+    const desc = readVersionAndDescriptor(reader);
     // console.log(require('util').inspect(desc, false, 99, true));
     target.vectorStroke = {
         strokeEnabled: desc.strokeEnabled,
@@ -831,10 +810,10 @@ addHandler('vstk', hasKey('vectorStroke'), function (reader, target, left) {
         resolution: desc.strokeStyleResolution,
     };
     skipBytes(reader, left());
-}, function (writer, target) {
+}, (writer, target) => {
     var _a, _b, _c;
-    var stroke = target.vectorStroke;
-    var desc = {
+    const stroke = target.vectorStroke;
+    const desc = {
         strokeStyleVersion: 2,
         strokeEnabled: !!stroke.strokeEnabled,
         fillEnabled: !!stroke.fillEnabled,
@@ -855,9 +834,9 @@ addHandler('vstk', hasKey('vectorStroke'), function (reader, target, left) {
     writeVersionAndDescriptor(writer, '', 'strokeStyle', desc);
 });
 addHandler('artb', // per-layer arboard info
-hasKey('artboard'), function (reader, target, left) {
-    var desc = readVersionAndDescriptor(reader);
-    var rect = desc.artboardRect;
+hasKey('artboard'), (reader, target, left) => {
+    const desc = readVersionAndDescriptor(reader);
+    const rect = desc.artboardRect;
     target.artboard = {
         rect: { top: rect['Top '], left: rect.Left, bottom: rect.Btom, right: rect.Rght },
         guideIndices: desc.guideIndeces,
@@ -866,11 +845,11 @@ hasKey('artboard'), function (reader, target, left) {
         backgroundType: desc.artboardBackgroundType,
     };
     skipBytes(reader, left());
-}, function (writer, target) {
+}, (writer, target) => {
     var _a;
-    var artboard = target.artboard;
-    var rect = artboard.rect;
-    var desc = {
+    const artboard = target.artboard;
+    const rect = artboard.rect;
+    const desc = {
         artboardRect: { 'Top ': rect.top, Left: rect.left, Btom: rect.bottom, Rght: rect.right },
         guideIndeces: artboard.guideIndices || [],
         artboardPresetName: artboard.presetName || '',
@@ -879,11 +858,11 @@ hasKey('artboard'), function (reader, target, left) {
     };
     writeVersionAndDescriptor(writer, '', 'artboard', desc);
 });
-addHandler('sn2P', hasKey('usingAlignedRendering'), function (reader, target) { return target.usingAlignedRendering = !!readUint32(reader); }, function (writer, target) { return writeUint32(writer, target.usingAlignedRendering ? 1 : 0); });
-var placedLayerTypes = ['unknown', 'vector', 'raster', 'image stack'];
+addHandler('sn2P', hasKey('usingAlignedRendering'), (reader, target) => target.usingAlignedRendering = !!readUint32(reader), (writer, target) => writeUint32(writer, target.usingAlignedRendering ? 1 : 0));
+const placedLayerTypes = ['unknown', 'vector', 'raster', 'image stack'];
 function parseWarp(warp) {
     var _a, _b, _c, _d, _e, _f;
-    var result = __assign(__assign({ style: warpStyle.decode(warp.warpStyle) }, (warp.warpValues ? { values: warp.warpValues } : { value: warp.warpValue || 0 })), { perspective: warp.warpPerspective || 0, perspectiveOther: warp.warpPerspectiveOther || 0, rotate: Ornt.decode(warp.warpRotate), bounds: warp.bounds && {
+    const result = Object.assign(Object.assign({ style: warpStyle.decode(warp.warpStyle) }, (warp.warpValues ? { values: warp.warpValues } : { value: warp.warpValue || 0 })), { perspective: warp.warpPerspective || 0, perspectiveOther: warp.warpPerspectiveOther || 0, rotate: Ornt.decode(warp.warpRotate), bounds: warp.bounds && {
             top: parseUnitsOrNumber(warp.bounds['Top ']),
             left: parseUnitsOrNumber(warp.bounds.Left),
             bottom: parseUnitsOrNumber(warp.bounds.Btom),
@@ -893,14 +872,14 @@ function parseWarp(warp) {
         result.deformNumRows = warp.deformNumRows;
         result.deformNumCols = warp.deformNumCols;
     }
-    var envelopeWarp = warp.customEnvelopeWarp;
+    const envelopeWarp = warp.customEnvelopeWarp;
     if (envelopeWarp) {
         result.customEnvelopeWarp = {
             meshPoints: [],
         };
-        var xs = ((_a = envelopeWarp.meshPoints.find(function (i) { return i.type === 'Hrzn'; })) === null || _a === void 0 ? void 0 : _a.values) || [];
-        var ys = ((_b = envelopeWarp.meshPoints.find(function (i) { return i.type === 'Vrtc'; })) === null || _b === void 0 ? void 0 : _b.values) || [];
-        for (var i = 0; i < xs.length; i++) {
+        const xs = ((_a = envelopeWarp.meshPoints.find(i => i.type === 'Hrzn')) === null || _a === void 0 ? void 0 : _a.values) || [];
+        const ys = ((_b = envelopeWarp.meshPoints.find(i => i.type === 'Vrtc')) === null || _b === void 0 ? void 0 : _b.values) || [];
+        for (let i = 0; i < xs.length; i++) {
             result.customEnvelopeWarp.meshPoints.push({ x: xs[i], y: ys[i] });
         }
         if (envelopeWarp.quiltSliceX || envelopeWarp.quiltSliceY) {
@@ -916,8 +895,8 @@ function isQuiltWarp(warp) {
         ((_a = warp.customEnvelopeWarp) === null || _a === void 0 ? void 0 : _a.quiltSliceX) || ((_b = warp.customEnvelopeWarp) === null || _b === void 0 ? void 0 : _b.quiltSliceY);
 }
 function encodeWarp(warp) {
-    var bounds = warp.bounds;
-    var desc = __assign(__assign({ warpStyle: warpStyle.encode(warp.style) }, (warp.values ? { warpValues: warp.values } : { warpValue: warp.value || 0 })), { warpPerspective: warp.perspective || 0, warpPerspectiveOther: warp.perspectiveOther || 0, warpRotate: Ornt.encode(warp.rotate), bounds: /*1 ? { // testing
+    const bounds = warp.bounds;
+    const desc = Object.assign(Object.assign({ warpStyle: warpStyle.encode(warp.style) }, (warp.values ? { warpValues: warp.values } : { warpValue: warp.value || 0 })), { warpPerspective: warp.perspective || 0, warpPerspectiveOther: warp.perspectiveOther || 0, warpRotate: Ornt.encode(warp.rotate), bounds: /*1 ? { // testing
             _classID: 'classFloatRect',
             'Top ': bounds && bounds.top && bounds.top.value || 0,
             Left: bounds && bounds.left && bounds.left.value || 0,
@@ -929,17 +908,17 @@ function encodeWarp(warp) {
             Btom: unitsValue(bounds && bounds.bottom || { units: 'Pixels', value: 0 }, 'bounds.bottom'),
             Rght: unitsValue(bounds && bounds.right || { units: 'Pixels', value: 0 }, 'bounds.right'),
         }, uOrder: warp.uOrder || 0, vOrder: warp.vOrder || 0 });
-    var isQuilt = isQuiltWarp(warp);
+    const isQuilt = isQuiltWarp(warp);
     if (isQuilt) {
-        var desc2 = desc;
+        const desc2 = desc;
         desc2.deformNumRows = warp.deformNumRows || 0;
         desc2.deformNumCols = warp.deformNumCols || 0;
     }
-    var customEnvelopeWarp = warp.customEnvelopeWarp;
+    const customEnvelopeWarp = warp.customEnvelopeWarp;
     if (customEnvelopeWarp) {
-        var meshPoints = customEnvelopeWarp.meshPoints || [];
+        const meshPoints = customEnvelopeWarp.meshPoints || [];
         if (isQuilt) {
-            var desc2 = desc;
+            const desc2 = desc;
             desc2.customEnvelopeWarp = {
                 _name: '',
                 _classID: 'customEnvelopeWarp',
@@ -952,8 +931,8 @@ function encodeWarp(warp) {
                         values: customEnvelopeWarp.quiltSliceY || [],
                     }],
                 meshPoints: [
-                    { type: 'Hrzn', values: meshPoints.map(function (p) { return p.x; }) },
-                    { type: 'Vrtc', values: meshPoints.map(function (p) { return p.y; }) },
+                    { type: 'Hrzn', values: meshPoints.map(p => p.x) },
+                    { type: 'Vrtc', values: meshPoints.map(p => p.y) },
                 ],
             };
         }
@@ -962,46 +941,46 @@ function encodeWarp(warp) {
                 _name: '',
                 _classID: 'customEnvelopeWarp',
                 meshPoints: [
-                    { type: 'Hrzn', values: meshPoints.map(function (p) { return p.x; }) },
-                    { type: 'Vrtc', values: meshPoints.map(function (p) { return p.y; }) },
+                    { type: 'Hrzn', values: meshPoints.map(p => p.x) },
+                    { type: 'Vrtc', values: meshPoints.map(p => p.y) },
                 ],
             };
         }
     }
     return desc;
 }
-addHandler('PlLd', hasKey('placedLayer'), function (reader, target, left) {
+addHandler('PlLd', hasKey('placedLayer'), (reader, target, left) => {
     if (readSignature(reader) !== 'plcL')
-        throw new Error("Invalid PlLd signature");
+        throw new Error(`Invalid PlLd signature`);
     if (readInt32(reader) !== 3)
-        throw new Error("Invalid PlLd version");
-    var id = readPascalString(reader, 1);
-    var pageNumber = readInt32(reader);
-    var totalPages = readInt32(reader); // TODO: check how this works ?
+        throw new Error(`Invalid PlLd version`);
+    const id = readPascalString(reader, 1);
+    const pageNumber = readInt32(reader);
+    const totalPages = readInt32(reader); // TODO: check how this works ?
     readInt32(reader); // anitAliasPolicy 16
-    var placedLayerType = readInt32(reader); // 0 = unknown, 1 = vector, 2 = raster, 3 = image stack
+    const placedLayerType = readInt32(reader); // 0 = unknown, 1 = vector, 2 = raster, 3 = image stack
     if (!placedLayerTypes[placedLayerType])
         throw new Error('Invalid PlLd type');
-    var transform = [];
-    for (var i = 0; i < 8; i++)
+    const transform = [];
+    for (let i = 0; i < 8; i++)
         transform.push(readFloat64(reader)); // x, y of 4 corners of the transform
-    var warpVersion = readInt32(reader);
+    const warpVersion = readInt32(reader);
     if (warpVersion !== 0)
-        throw new Error("Invalid Warp version ".concat(warpVersion));
-    var warp = readVersionAndDescriptor(reader);
+        throw new Error(`Invalid Warp version ${warpVersion}`);
+    const warp = readVersionAndDescriptor(reader);
     target.placedLayer = target.placedLayer || {
-        id: id,
+        id,
         type: placedLayerTypes[placedLayerType],
-        pageNumber: pageNumber,
-        totalPages: totalPages,
-        transform: transform,
+        pageNumber,
+        totalPages,
+        transform,
         warp: parseWarp(warp),
     };
     // console.log('PlLd warp', require('util').inspect(warp, false, 99, true));
     // console.log('PlLd', require('util').inspect(target.placedLayer, false, 99, true));
     skipBytes(reader, left());
-}, function (writer, target) {
-    var placed = target.placedLayer;
+}, (writer, target) => {
+    const placed = target.placedLayer;
     writeSignature(writer, 'plcL');
     writeInt32(writer, 3); // version
     if (!placed.id || typeof placed.id !== 'string' || !/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(placed.id)) {
@@ -1014,12 +993,12 @@ addHandler('PlLd', hasKey('placedLayer'), function (reader, target, left) {
     if (placedLayerTypes.indexOf(placed.type) === -1)
         throw new Error('Invalid placedLayer type');
     writeInt32(writer, placedLayerTypes.indexOf(placed.type));
-    for (var i = 0; i < 8; i++)
+    for (let i = 0; i < 8; i++)
         writeFloat64(writer, placed.transform[i]);
     writeInt32(writer, 0); // warp version
-    var warp = getWarpFromPlacedLayer(placed);
-    var isQuilt = isQuiltWarp(warp);
-    var type = isQuilt ? 'quiltWarp' : 'warp';
+    const warp = getWarpFromPlacedLayer(placed);
+    const isQuilt = isQuiltWarp(warp);
+    const type = isQuilt ? 'quiltWarp' : 'warp';
     writeVersionAndDescriptor(writer, '', type, encodeWarp(warp), type);
 });
 function uint8ToFloat32(array) {
@@ -1032,15 +1011,15 @@ function toUint8(array) {
     return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
 }
 function arrayToPoints(array) {
-    var points = [];
-    for (var i = 0; i < array.length; i += 2) {
+    const points = [];
+    for (let i = 0; i < array.length; i += 2) {
         points.push({ x: array[i], y: array[i + 1] });
     }
     return points;
 }
 function pointsToArray(points) {
-    var array = [];
-    for (var i = 0; i < points.length; i++) {
+    const array = [];
+    for (let i = 0; i < points.length; i++) {
         array.push(points[i].x, points[i].y);
     }
     return array;
@@ -1063,7 +1042,7 @@ function pointToHrznVrtc(point) {
     };
 }
 function parseFilterFXItem(f, options) {
-    var base = {
+    const base = {
         name: f['Nm  '],
         opacity: parsePercent(f.blendOptions.Opct),
         blendMode: BlnM.decode(f.blendOptions['Md  ']),
@@ -1074,36 +1053,36 @@ function parseFilterFXItem(f, options) {
     };
     if ('Fltr' in f) {
         switch (f.Fltr._classID) {
-            case 'boxblur': return __assign(__assign({}, base), { type: 'box blur', filter: {
+            case 'boxblur': return Object.assign(Object.assign({}, base), { type: 'box blur', filter: {
                     radius: parseUnits(f.Fltr['Rds ']),
                 } });
-            case 'GsnB': return __assign(__assign({}, base), { type: 'gaussian blur', filter: {
+            case 'GsnB': return Object.assign(Object.assign({}, base), { type: 'gaussian blur', filter: {
                     radius: parseUnits(f.Fltr['Rds ']),
                 } });
-            case 'MtnB': return __assign(__assign({}, base), { type: 'motion blur', filter: {
+            case 'MtnB': return Object.assign(Object.assign({}, base), { type: 'motion blur', filter: {
                     angle: f.Fltr.Angl,
                     distance: parseUnits(f.Fltr.Dstn),
                 } });
-            case 'RdlB': return __assign(__assign({}, base), { type: 'radial blur', filter: {
+            case 'RdlB': return Object.assign(Object.assign({}, base), { type: 'radial blur', filter: {
                     amount: f.Fltr.Amnt,
                     method: BlrM.decode(f.Fltr.BlrM),
                     quality: BlrQ.decode(f.Fltr.BlrQ),
                 } });
-            case 'shapeBlur': return __assign(__assign({}, base), { type: 'shape blur', filter: {
+            case 'shapeBlur': return Object.assign(Object.assign({}, base), { type: 'shape blur', filter: {
                     radius: parseUnits(f.Fltr['Rds ']),
                     customShape: { name: f.Fltr.customShape['Nm  '], id: f.Fltr.customShape.Idnt },
                 } });
-            case 'SmrB': return __assign(__assign({}, base), { type: 'smart blur', filter: {
+            case 'SmrB': return Object.assign(Object.assign({}, base), { type: 'smart blur', filter: {
                     radius: f.Fltr['Rds '],
                     threshold: f.Fltr.Thsh,
                     quality: SmBQ.decode(f.Fltr.SmBQ),
                     mode: SmBM.decode(f.Fltr.SmBM),
                 } });
-            case 'surfaceBlur': return __assign(__assign({}, base), { type: 'surface blur', filter: {
+            case 'surfaceBlur': return Object.assign(Object.assign({}, base), { type: 'surface blur', filter: {
                     radius: parseUnits(f.Fltr['Rds ']),
                     threshold: f.Fltr.Thsh,
                 } });
-            case 'Dspl': return __assign(__assign({}, base), { type: 'displace', filter: {
+            case 'Dspl': return Object.assign(Object.assign({}, base), { type: 'displace', filter: {
                     horizontalScale: f.Fltr.HrzS,
                     verticalScale: f.Fltr.VrtS,
                     displacementMap: DspM.decode(f.Fltr.DspM),
@@ -1113,30 +1092,30 @@ function parseFilterFXItem(f, options) {
                         path: f.Fltr.DspF.path, // TODO: this is decoded incorrectly ???
                     },
                 } });
-            case 'Pnch': return __assign(__assign({}, base), { type: 'pinch', filter: {
+            case 'Pnch': return Object.assign(Object.assign({}, base), { type: 'pinch', filter: {
                     amount: f.Fltr.Amnt,
                 } });
-            case 'Plr ': return __assign(__assign({}, base), { type: 'polar coordinates', filter: {
+            case 'Plr ': return Object.assign(Object.assign({}, base), { type: 'polar coordinates', filter: {
                     conversion: Cnvr.decode(f.Fltr.Cnvr),
                 } });
-            case 'Rple': return __assign(__assign({}, base), { type: 'ripple', filter: {
+            case 'Rple': return Object.assign(Object.assign({}, base), { type: 'ripple', filter: {
                     amount: f.Fltr.Amnt,
                     size: RplS.decode(f.Fltr.RplS),
                 } });
-            case 'Shr ': return __assign(__assign({}, base), { type: 'shear', filter: {
-                    shearPoints: f.Fltr.ShrP.map(function (p) { return ({ x: p.Hrzn, y: p.Vrtc }); }),
+            case 'Shr ': return Object.assign(Object.assign({}, base), { type: 'shear', filter: {
+                    shearPoints: f.Fltr.ShrP.map(p => ({ x: p.Hrzn, y: p.Vrtc })),
                     shearStart: f.Fltr.ShrS,
                     shearEnd: f.Fltr.ShrE,
                     undefinedAreas: UndA.decode(f.Fltr.UndA),
                 } });
-            case 'Sphr': return __assign(__assign({}, base), { type: 'spherize', filter: {
+            case 'Sphr': return Object.assign(Object.assign({}, base), { type: 'spherize', filter: {
                     amount: f.Fltr.Amnt,
                     mode: SphM.decode(f.Fltr.SphM),
                 } });
-            case 'Twrl': return __assign(__assign({}, base), { type: 'twirl', filter: {
+            case 'Twrl': return Object.assign(Object.assign({}, base), { type: 'twirl', filter: {
                     angle: f.Fltr.Angl,
                 } });
-            case 'Wave': return __assign(__assign({}, base), { type: 'wave', filter: {
+            case 'Wave': return Object.assign(Object.assign({}, base), { type: 'wave', filter: {
                     numberOfGenerators: f.Fltr.NmbG,
                     type: Wvtp.decode(f.Fltr.Wvtp),
                     wavelength: { min: f.Fltr.WLMn, max: f.Fltr.WLMx },
@@ -1145,70 +1124,70 @@ function parseFilterFXItem(f, options) {
                     randomSeed: f.Fltr.RndS,
                     undefinedAreas: UndA.decode(f.Fltr.UndA),
                 } });
-            case 'ZgZg': return __assign(__assign({}, base), { type: 'zigzag', filter: {
+            case 'ZgZg': return Object.assign(Object.assign({}, base), { type: 'zigzag', filter: {
                     amount: f.Fltr.Amnt,
                     ridges: f.Fltr.NmbR,
                     style: ZZTy.decode(f.Fltr.ZZTy),
                 } });
-            case 'AdNs': return __assign(__assign({}, base), { type: 'add noise', filter: {
+            case 'AdNs': return Object.assign(Object.assign({}, base), { type: 'add noise', filter: {
                     amount: parsePercent(f.Fltr.Nose),
                     distribution: Dstr.decode(f.Fltr.Dstr),
                     monochromatic: f.Fltr.Mnch,
                     randomSeed: f.Fltr.FlRs,
                 } });
-            case 'DstS': return __assign(__assign({}, base), { type: 'dust and scratches', filter: {
+            case 'DstS': return Object.assign(Object.assign({}, base), { type: 'dust and scratches', filter: {
                     radius: f.Fltr['Rds '],
                     threshold: f.Fltr.Thsh,
                 } });
-            case 'Mdn ': return __assign(__assign({}, base), { type: 'median', filter: {
+            case 'Mdn ': return Object.assign(Object.assign({}, base), { type: 'median', filter: {
                     radius: parseUnits(f.Fltr['Rds ']),
                 } });
-            case 'denoise': return __assign(__assign({}, base), { type: 'reduce noise', filter: {
+            case 'denoise': return Object.assign(Object.assign({}, base), { type: 'reduce noise', filter: {
                     preset: f.Fltr.preset,
                     removeJpegArtifact: f.Fltr.removeJPEGArtifact,
                     reduceColorNoise: parsePercent(f.Fltr.ClNs),
                     sharpenDetails: parsePercent(f.Fltr.Shrp),
-                    channelDenoise: f.Fltr.channelDenoise.map(function (c) { return (__assign({ channels: c.Chnl.map(Chnl.decode), amount: c.Amnt }, (c.EdgF ? { preserveDetails: c.EdgF } : {}))); }),
+                    channelDenoise: f.Fltr.channelDenoise.map(c => (Object.assign({ channels: c.Chnl.map(Chnl.decode), amount: c.Amnt }, (c.EdgF ? { preserveDetails: c.EdgF } : {})))),
                 } });
-            case 'ClrH': return __assign(__assign({}, base), { type: 'color halftone', filter: {
+            case 'ClrH': return Object.assign(Object.assign({}, base), { type: 'color halftone', filter: {
                     radius: f.Fltr['Rds '],
                     angle1: f.Fltr.Ang1,
                     angle2: f.Fltr.Ang2,
                     angle3: f.Fltr.Ang3,
                     angle4: f.Fltr.Ang4,
                 } });
-            case 'Crst': return __assign(__assign({}, base), { type: 'crystallize', filter: {
+            case 'Crst': return Object.assign(Object.assign({}, base), { type: 'crystallize', filter: {
                     cellSize: f.Fltr.ClSz,
                     randomSeed: f.Fltr.FlRs,
                 } });
-            case 'Mztn': return __assign(__assign({}, base), { type: 'mezzotint', filter: {
+            case 'Mztn': return Object.assign(Object.assign({}, base), { type: 'mezzotint', filter: {
                     type: MztT.decode(f.Fltr.MztT),
                     randomSeed: f.Fltr.FlRs,
                 } });
-            case 'Msc ': return __assign(__assign({}, base), { type: 'mosaic', filter: {
+            case 'Msc ': return Object.assign(Object.assign({}, base), { type: 'mosaic', filter: {
                     cellSize: parseUnits(f.Fltr.ClSz),
                 } });
-            case 'Pntl': return __assign(__assign({}, base), { type: 'pointillize', filter: {
+            case 'Pntl': return Object.assign(Object.assign({}, base), { type: 'pointillize', filter: {
                     cellSize: f.Fltr.ClSz,
                     randomSeed: f.Fltr.FlRs,
                 } });
-            case 'Clds': return __assign(__assign({}, base), { type: 'clouds', filter: {
+            case 'Clds': return Object.assign(Object.assign({}, base), { type: 'clouds', filter: {
                     randomSeed: f.Fltr.FlRs,
                 } });
-            case 'DfrC': return __assign(__assign({}, base), { type: 'difference clouds', filter: {
+            case 'DfrC': return Object.assign(Object.assign({}, base), { type: 'difference clouds', filter: {
                     randomSeed: f.Fltr.FlRs,
                 } });
-            case 'Fbrs': return __assign(__assign({}, base), { type: 'fibers', filter: {
+            case 'Fbrs': return Object.assign(Object.assign({}, base), { type: 'fibers', filter: {
                     variance: f.Fltr.Vrnc,
                     strength: f.Fltr.Strg,
                     randomSeed: f.Fltr.RndS,
                 } });
-            case 'LnsF': return __assign(__assign({}, base), { type: 'lens flare', filter: {
+            case 'LnsF': return Object.assign(Object.assign({}, base), { type: 'lens flare', filter: {
                     brightness: f.Fltr.Brgh,
                     position: { x: f.Fltr.FlrC.Hrzn, y: f.Fltr.FlrC.Vrtc },
                     lensType: Lns.decode(f.Fltr['Lns ']),
                 } });
-            case 'smartSharpen': return __assign(__assign({}, base), { type: 'smart sharpen', filter: {
+            case 'smartSharpen': return Object.assign(Object.assign({}, base), { type: 'smart sharpen', filter: {
                     amount: parsePercent(f.Fltr.Amnt),
                     radius: parseUnits(f.Fltr['Rds ']),
                     threshold: f.Fltr.Thsh,
@@ -1227,21 +1206,21 @@ function parseFilterFXItem(f, options) {
                         radius: f.Fltr.hglM['Rds '],
                     },
                 } });
-            case 'UnsM': return __assign(__assign({}, base), { type: 'unsharp mask', filter: {
+            case 'UnsM': return Object.assign(Object.assign({}, base), { type: 'unsharp mask', filter: {
                     amount: parsePercent(f.Fltr.Amnt),
                     radius: parseUnits(f.Fltr['Rds ']),
                     threshold: f.Fltr.Thsh,
                 } });
-            case 'Dfs ': return __assign(__assign({}, base), { type: 'diffuse', filter: {
+            case 'Dfs ': return Object.assign(Object.assign({}, base), { type: 'diffuse', filter: {
                     mode: DfsM.decode(f.Fltr['Md  ']),
                     randomSeed: f.Fltr.FlRs,
                 } });
-            case 'Embs': return __assign(__assign({}, base), { type: 'emboss', filter: {
+            case 'Embs': return Object.assign(Object.assign({}, base), { type: 'emboss', filter: {
                     angle: f.Fltr.Angl,
                     height: f.Fltr.Hght,
                     amount: f.Fltr.Amnt,
                 } });
-            case 'Extr': return __assign(__assign({}, base), { type: 'extrude', filter: {
+            case 'Extr': return Object.assign(Object.assign({}, base), { type: 'extrude', filter: {
                     type: ExtT.decode(f.Fltr.ExtT),
                     size: f.Fltr.ExtS,
                     depth: f.Fltr.ExtD,
@@ -1250,44 +1229,44 @@ function parseFilterFXItem(f, options) {
                     solidFrontFaces: f.Fltr.ExtF,
                     maskIncompleteBlocks: f.Fltr.ExtM,
                 } });
-            case 'Tls ': return __assign(__assign({}, base), { type: 'tiles', filter: {
+            case 'Tls ': return Object.assign(Object.assign({}, base), { type: 'tiles', filter: {
                     numberOfTiles: f.Fltr.TlNm,
                     maximumOffset: f.Fltr.TlOf,
                     fillEmptyAreaWith: FlCl.decode(f.Fltr.FlCl),
                     randomSeed: f.Fltr.FlRs,
                 } });
-            case 'TrcC': return __assign(__assign({}, base), { type: 'trace contour', filter: {
+            case 'TrcC': return Object.assign(Object.assign({}, base), { type: 'trace contour', filter: {
                     level: f.Fltr['Lvl '],
                     edge: CntE.decode(f.Fltr['Edg ']),
                 } });
-            case 'Wnd ': return __assign(__assign({}, base), { type: 'wind', filter: {
+            case 'Wnd ': return Object.assign(Object.assign({}, base), { type: 'wind', filter: {
                     method: WndM.decode(f.Fltr.WndM),
                     direction: Drct.decode(f.Fltr.Drct),
                 } });
-            case 'Dntr': return __assign(__assign({}, base), { type: 'de-interlace', filter: {
+            case 'Dntr': return Object.assign(Object.assign({}, base), { type: 'de-interlace', filter: {
                     eliminate: IntE.decode(f.Fltr.IntE),
                     newFieldsBy: IntC.decode(f.Fltr.IntC),
                 } });
-            case 'Cstm': return __assign(__assign({}, base), { type: 'custom', filter: {
+            case 'Cstm': return Object.assign(Object.assign({}, base), { type: 'custom', filter: {
                     scale: f.Fltr['Scl '],
                     offset: f.Fltr.Ofst,
                     matrix: f.Fltr.Mtrx,
                 } });
-            case 'HghP': return __assign(__assign({}, base), { type: 'high pass', filter: {
+            case 'HghP': return Object.assign(Object.assign({}, base), { type: 'high pass', filter: {
                     radius: parseUnits(f.Fltr['Rds ']),
                 } });
-            case 'Mxm ': return __assign(__assign({}, base), { type: 'maximum', filter: {
+            case 'Mxm ': return Object.assign(Object.assign({}, base), { type: 'maximum', filter: {
                     radius: parseUnits(f.Fltr['Rds ']),
                 } });
-            case 'Mnm ': return __assign(__assign({}, base), { type: 'minimum', filter: {
+            case 'Mnm ': return Object.assign(Object.assign({}, base), { type: 'minimum', filter: {
                     radius: parseUnits(f.Fltr['Rds ']),
                 } });
-            case 'Ofst': return __assign(__assign({}, base), { type: 'offset', filter: {
+            case 'Ofst': return Object.assign(Object.assign({}, base), { type: 'offset', filter: {
                     horizontal: f.Fltr.Hrzn,
                     vertical: f.Fltr.Vrtc,
                     undefinedAreas: FlMd.decode(f.Fltr['Fl  ']),
                 } });
-            case 'rigidTransform': return __assign(__assign({}, base), { type: 'puppet', filter: {
+            case 'rigidTransform': return Object.assign(Object.assign({}, base), { type: 'puppet', filter: {
                     rigidType: f.Fltr.rigidType,
                     bounds: [
                         { x: f.Fltr.PuX0, y: f.Fltr.PuY0, },
@@ -1295,7 +1274,7 @@ function parseFilterFXItem(f, options) {
                         { x: f.Fltr.PuX2, y: f.Fltr.PuY2, },
                         { x: f.Fltr.PuX3, y: f.Fltr.PuY3, },
                     ],
-                    puppetShapeList: f.Fltr.puppetShapeList.map(function (p) { return ({
+                    puppetShapeList: f.Fltr.puppetShapeList.map(p => ({
                         rigidType: p.rigidType,
                         // TODO: VrsM
                         // TODO: VrsN
@@ -1315,41 +1294,41 @@ function parseFilterFXItem(f, options) {
                         meshRigidity: p.meshRigidity,
                         imageResolution: p.imageResolution,
                         meshBoundaryPath: {
-                            pathComponents: p.meshBoundaryPath.pathComponents.map(function (c) { return ({
+                            pathComponents: p.meshBoundaryPath.pathComponents.map(c => ({
                                 shapeOperation: c.shapeOperation.split('.')[1],
-                                paths: c.SbpL.map(function (t) { return ({
+                                paths: c.SbpL.map(t => ({
                                     closed: t.Clsp,
-                                    points: t['Pts '].map(function (pt) { return ({
+                                    points: t['Pts '].map(pt => ({
                                         anchor: hrznVrtcToPoint(pt.Anch),
                                         forward: hrznVrtcToPoint(pt['Fwd ']),
                                         backward: hrznVrtcToPoint(pt['Bwd ']),
                                         smooth: pt.Smoo,
-                                    }); }),
-                                }); }),
-                            }); }),
+                                    })),
+                                })),
+                            })),
                         },
-                    }); }),
+                    })),
                 } });
             case 'PbPl': {
-                var parameters = [];
-                var Flrt = f.Fltr;
-                for (var i = 0; i < fromAtoZ.length; i++) {
-                    if (!Flrt["PN".concat(fromAtoZ[i], "a")])
+                const parameters = [];
+                const Flrt = f.Fltr;
+                for (let i = 0; i < fromAtoZ.length; i++) {
+                    if (!Flrt[`PN${fromAtoZ[i]}a`])
                         break;
-                    for (var j = 0; j < fromAtoZ.length; j++) {
-                        if (!Flrt["PN".concat(fromAtoZ[i]).concat(fromAtoZ[j])])
+                    for (let j = 0; j < fromAtoZ.length; j++) {
+                        if (!Flrt[`PN${fromAtoZ[i]}${fromAtoZ[j]}`])
                             break;
                         parameters.push({
-                            name: Flrt["PN".concat(fromAtoZ[i]).concat(fromAtoZ[j])],
-                            value: Flrt["PF".concat(fromAtoZ[i]).concat(fromAtoZ[j])]
+                            name: Flrt[`PN${fromAtoZ[i]}${fromAtoZ[j]}`],
+                            value: Flrt[`PF${fromAtoZ[i]}${fromAtoZ[j]}`]
                         });
                     }
                 }
-                return __assign(__assign({}, base), { type: 'oil paint plugin', filter: {
+                return Object.assign(Object.assign({}, base), { type: 'oil paint plugin', filter: {
                         name: f.Fltr.KnNm,
                         gpu: f.Fltr.GpuY,
                         lighting: f.Fltr.LIWy,
-                        parameters: parameters,
+                        parameters,
                     } });
             }
             // case 2089: return {
@@ -1364,11 +1343,11 @@ function parseFilterFXItem(f, options) {
             // 		imageY: f.Fltr.imgY,
             // 	},
             // };
-            case 'HsbP': return __assign(__assign({}, base), { type: 'hsb/hsl', filter: {
+            case 'HsbP': return Object.assign(Object.assign({}, base), { type: 'hsb/hsl', filter: {
                     inputMode: ClrS.decode(f.Fltr.Inpt),
                     rowOrder: ClrS.decode(f.Fltr.Otpt),
                 } });
-            case 'oilPaint': return __assign(__assign({}, base), { type: 'oil paint', filter: {
+            case 'oilPaint': return Object.assign(Object.assign({}, base), { type: 'oil paint', filter: {
                     lightingOn: f.Fltr.lightingOn,
                     stylization: f.Fltr.stylization,
                     cleanliness: f.Fltr.cleanliness,
@@ -1379,30 +1358,30 @@ function parseFilterFXItem(f, options) {
                 } });
             case 'LqFy':
                 {
-                    return __assign(__assign({}, base), { type: 'liquify', filter: {
+                    return Object.assign(Object.assign({}, base), { type: 'liquify', filter: {
                             liquifyMesh: f.Fltr.LqMe,
                         } });
                 }
                 ;
             case 'perspectiveWarpTransform':
                 {
-                    return __assign(__assign({}, base), { type: 'perspective warp', filter: {
+                    return Object.assign(Object.assign({}, base), { type: 'perspective warp', filter: {
                             vertices: f.Fltr.vertices.map(hrznVrtcToPoint),
                             warpedVertices: f.Fltr.warpedVertices.map(hrznVrtcToPoint),
-                            quads: f.Fltr.quads.map(function (q) { return q.indices; }),
+                            quads: f.Fltr.quads.map(q => q.indices),
                         } });
                 }
                 ;
             case 'Crvs':
                 {
-                    return __assign(__assign({}, base), { type: 'curves', filter: __assign({ presetKind: presetKindType.decode(f.Fltr.presetKind) }, (f.Fltr.Adjs ? {
-                            adjustments: f.Fltr.Adjs.map(function (a) {
-                                var channels = a.Chnl.map(Chnl.decode);
+                    return Object.assign(Object.assign({}, base), { type: 'curves', filter: Object.assign({ presetKind: presetKindType.decode(f.Fltr.presetKind) }, (f.Fltr.Adjs ? {
+                            adjustments: f.Fltr.Adjs.map(a => {
+                                const channels = a.Chnl.map(Chnl.decode);
                                 if (a['Crv ']) {
                                     return {
-                                        channels: channels,
-                                        curve: a['Crv '].map(function (c) {
-                                            var point = { x: c.Hrzn, y: c.Vrtc };
+                                        channels,
+                                        curve: a['Crv '].map(c => {
+                                            const point = { x: c.Hrzn, y: c.Vrtc };
                                             if (c.Cnty)
                                                 point.curved = true;
                                             return point;
@@ -1410,10 +1389,10 @@ function parseFilterFXItem(f, options) {
                                     };
                                 }
                                 else if (a.Mpng) {
-                                    return { channels: channels, values: a.Mpng };
+                                    return { channels, values: a.Mpng };
                                 }
                                 else {
-                                    throw new Error("Unknown curve adjustment");
+                                    throw new Error(`Unknown curve adjustment`);
                                 }
                             })
                         } : {})) });
@@ -1421,7 +1400,7 @@ function parseFilterFXItem(f, options) {
                 ;
             case 'BrgC':
                 {
-                    return __assign(__assign({}, base), { type: 'brightness/contrast', filter: {
+                    return Object.assign(Object.assign({}, base), { type: 'brightness/contrast', filter: {
                             brightness: f.Fltr.Brgh,
                             contrast: f.Fltr.Cntr,
                             useLegacy: !!f.Fltr.useLegacy,
@@ -1431,30 +1410,30 @@ function parseFilterFXItem(f, options) {
             default:
                 if (options.throwForMissingFeatures) {
                     // console.log('FILTER', require('util').inspect(f, false, 99, true));
-                    throw new Error("Unknown filter classId: ".concat(f.Fltr._classID));
+                    throw new Error(`Unknown filter classId: ${f.Fltr._classID}`);
                 }
                 return undefined;
         }
     }
     else {
         switch (f.filterID) {
-            case 1098281575: return __assign(__assign({}, base), { type: 'average' });
-            case 1114403360: return __assign(__assign({}, base), { type: 'blur' });
-            case 1114403405: return __assign(__assign({}, base), { type: 'blur more' });
-            case 1148416099: return __assign(__assign({}, base), { type: 'despeckle' });
-            case 1180922912: return __assign(__assign({}, base), { type: 'facet' });
-            case 1181902701: return __assign(__assign({}, base), { type: 'fragment' });
-            case 1399353968: return __assign(__assign({}, base), { type: 'sharpen' });
-            case 1399353925: return __assign(__assign({}, base), { type: 'sharpen edges' });
-            case 1399353933: return __assign(__assign({}, base), { type: 'sharpen more' });
-            case 1181639749: return __assign(__assign({}, base), { type: 'find edges' });
-            case 1399616122: return __assign(__assign({}, base), { type: 'solarize' });
-            case 1314149187: return __assign(__assign({}, base), { type: 'ntsc colors' });
-            case 1231976050: return __assign(__assign({}, base), { type: 'invert' });
+            case 1098281575: return Object.assign(Object.assign({}, base), { type: 'average' });
+            case 1114403360: return Object.assign(Object.assign({}, base), { type: 'blur' });
+            case 1114403405: return Object.assign(Object.assign({}, base), { type: 'blur more' });
+            case 1148416099: return Object.assign(Object.assign({}, base), { type: 'despeckle' });
+            case 1180922912: return Object.assign(Object.assign({}, base), { type: 'facet' });
+            case 1181902701: return Object.assign(Object.assign({}, base), { type: 'fragment' });
+            case 1399353968: return Object.assign(Object.assign({}, base), { type: 'sharpen' });
+            case 1399353925: return Object.assign(Object.assign({}, base), { type: 'sharpen edges' });
+            case 1399353933: return Object.assign(Object.assign({}, base), { type: 'sharpen more' });
+            case 1181639749: return Object.assign(Object.assign({}, base), { type: 'find edges' });
+            case 1399616122: return Object.assign(Object.assign({}, base), { type: 'solarize' });
+            case 1314149187: return Object.assign(Object.assign({}, base), { type: 'ntsc colors' });
+            case 1231976050: return Object.assign(Object.assign({}, base), { type: 'invert' });
             default:
                 if (options.throwForMissingFeatures) {
                     // console.log('FILTER', require('util').inspect(f, false, 99, true));
-                    throw new Error("Unknown filterID: ".concat(f.filterID));
+                    throw new Error(`Unknown filterID: ${f.filterID}`);
                 }
         }
     }
@@ -1466,14 +1445,14 @@ function parseFilterFX(desc, options) {
         maskEnabled: desc.filterMaskEnable,
         maskLinked: desc.filterMaskLinked,
         maskExtendWithWhite: desc.filterMaskExtendWithWhite,
-        list: desc.filterFXList.map(function (x) { return parseFilterFXItem(x, options); }).filter(function (x) { return !!x; }),
+        list: desc.filterFXList.map(x => parseFilterFXItem(x, options)).filter((x) => !!x),
     };
 }
 function uvRadius(t) {
     return unitsValue(t.radius, 'radius');
 }
 function serializeFilterFXItem(f) {
-    var base = {
+    const base = {
         _name: '',
         _classID: 'filterFX',
         'Nm  ': f.name,
@@ -1489,34 +1468,34 @@ function serializeFilterFXItem(f) {
         BckC: serializeColor(f.backgroundColor),
     };
     switch (f.type) {
-        case 'average': return __assign(__assign({}, base), { filterID: 1098281575 });
-        case 'blur': return __assign(__assign({}, base), { filterID: 1114403360 });
-        case 'blur more': return __assign(__assign({}, base), { filterID: 1114403405 });
-        case 'box blur': return __assign(__assign({}, base), { Fltr: {
+        case 'average': return Object.assign(Object.assign({}, base), { filterID: 1098281575 });
+        case 'blur': return Object.assign(Object.assign({}, base), { filterID: 1114403360 });
+        case 'blur more': return Object.assign(Object.assign({}, base), { filterID: 1114403405 });
+        case 'box blur': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Box Blur',
                 _classID: 'boxblur',
                 'Rds ': uvRadius(f.filter),
             }, filterID: 697 });
-        case 'gaussian blur': return __assign(__assign({}, base), { Fltr: {
+        case 'gaussian blur': return Object.assign(Object.assign({}, base), { Fltr: {
                 // _name: '高斯模糊', // Testing
                 _name: 'Gaussian Blur',
                 _classID: 'GsnB',
                 'Rds ': uvRadius(f.filter),
             }, filterID: 1198747202 });
-        case 'motion blur': return __assign(__assign({}, base), { Fltr: {
+        case 'motion blur': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Motion Blur',
                 _classID: 'MtnB',
                 Angl: f.filter.angle,
                 Dstn: unitsValue(f.filter.distance, 'distance'),
             }, filterID: 1299476034 });
-        case 'radial blur': return __assign(__assign({}, base), { Fltr: {
+        case 'radial blur': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Radial Blur',
                 _classID: 'RdlB',
                 Amnt: f.filter.amount,
                 BlrM: BlrM.encode(f.filter.method),
                 BlrQ: BlrQ.encode(f.filter.quality),
             }, filterID: 1382313026 });
-        case 'shape blur': return __assign(__assign({}, base), { Fltr: {
+        case 'shape blur': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Shape Blur',
                 _classID: 'shapeBlur',
                 'Rds ': uvRadius(f.filter),
@@ -1527,7 +1506,7 @@ function serializeFilterFXItem(f) {
                     Idnt: f.filter.customShape.id,
                 }
             }, filterID: 702 });
-        case 'smart blur': return __assign(__assign({}, base), { Fltr: {
+        case 'smart blur': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Smart Blur',
                 _classID: 'SmrB',
                 'Rds ': f.filter.radius,
@@ -1535,13 +1514,13 @@ function serializeFilterFXItem(f) {
                 SmBQ: SmBQ.encode(f.filter.quality),
                 SmBM: SmBM.encode(f.filter.mode),
             }, filterID: 1399681602 });
-        case 'surface blur': return __assign(__assign({}, base), { Fltr: {
+        case 'surface blur': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Surface Blur',
                 _classID: 'surfaceBlur',
                 'Rds ': uvRadius(f.filter),
                 Thsh: f.filter.threshold,
             }, filterID: 701 });
-        case 'displace': return __assign(__assign({}, base), { Fltr: {
+        case 'displace': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Displace',
                 _classID: 'Dspl',
                 HrzS: f.filter.horizontalScale,
@@ -1553,42 +1532,42 @@ function serializeFilterFXItem(f) {
                     path: f.filter.displacementFile.path,
                 },
             }, filterID: 1148416108 });
-        case 'pinch': return __assign(__assign({}, base), { Fltr: {
+        case 'pinch': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Pinch',
                 _classID: 'Pnch',
                 Amnt: f.filter.amount,
             }, filterID: 1349411688 });
-        case 'polar coordinates': return __assign(__assign({}, base), { Fltr: {
+        case 'polar coordinates': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Polar Coordinates',
                 _classID: 'Plr ',
                 Cnvr: Cnvr.encode(f.filter.conversion),
             }, filterID: 1349284384 });
-        case 'ripple': return __assign(__assign({}, base), { Fltr: {
+        case 'ripple': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Ripple',
                 _classID: 'Rple',
                 Amnt: f.filter.amount,
                 RplS: RplS.encode(f.filter.size),
             }, filterID: 1383099493 });
-        case 'shear': return __assign(__assign({}, base), { Fltr: {
+        case 'shear': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Shear',
                 _classID: 'Shr ',
-                ShrP: f.filter.shearPoints.map(function (p) { return ({ _name: '', _classID: 'Pnt ', Hrzn: p.x, Vrtc: p.y }); }),
+                ShrP: f.filter.shearPoints.map(p => ({ _name: '', _classID: 'Pnt ', Hrzn: p.x, Vrtc: p.y })),
                 UndA: UndA.encode(f.filter.undefinedAreas),
                 ShrS: f.filter.shearStart,
                 ShrE: f.filter.shearEnd,
             }, filterID: 1399353888 });
-        case 'spherize': return __assign(__assign({}, base), { Fltr: {
+        case 'spherize': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Spherize',
                 _classID: 'Sphr',
                 Amnt: f.filter.amount,
                 SphM: SphM.encode(f.filter.mode),
             }, filterID: 1399875698 });
-        case 'twirl': return __assign(__assign({}, base), { Fltr: {
+        case 'twirl': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Twirl',
                 _classID: 'Twrl',
                 Angl: f.filter.angle,
             }, filterID: 1417114220 });
-        case 'wave': return __assign(__assign({}, base), { Fltr: {
+        case 'wave': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Wave',
                 _classID: 'Wave',
                 Wvtp: Wvtp.encode(f.filter.type),
@@ -1602,14 +1581,14 @@ function serializeFilterFXItem(f) {
                 UndA: UndA.encode(f.filter.undefinedAreas),
                 RndS: f.filter.randomSeed,
             }, filterID: 1466005093 });
-        case 'zigzag': return __assign(__assign({}, base), { Fltr: {
+        case 'zigzag': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'ZigZag',
                 _classID: 'ZgZg',
                 Amnt: f.filter.amount,
                 NmbR: f.filter.ridges,
                 ZZTy: ZZTy.encode(f.filter.style),
             }, filterID: 1516722791 });
-        case 'add noise': return __assign(__assign({}, base), { Fltr: {
+        case 'add noise': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Add Noise',
                 _classID: 'AdNs',
                 Dstr: Dstr.encode(f.filter.distribution),
@@ -1617,28 +1596,28 @@ function serializeFilterFXItem(f) {
                 Mnch: f.filter.monochromatic,
                 FlRs: f.filter.randomSeed,
             }, filterID: 1097092723 });
-        case 'despeckle': return __assign(__assign({}, base), { filterID: 1148416099 });
-        case 'dust and scratches': return __assign(__assign({}, base), { Fltr: {
+        case 'despeckle': return Object.assign(Object.assign({}, base), { filterID: 1148416099 });
+        case 'dust and scratches': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Dust & Scratches',
                 _classID: 'DstS',
                 'Rds ': f.filter.radius,
                 Thsh: f.filter.threshold,
             }, filterID: 1148417107 });
-        case 'median': return __assign(__assign({}, base), { Fltr: {
+        case 'median': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Median',
                 _classID: 'Mdn ',
                 'Rds ': uvRadius(f.filter),
             }, filterID: 1298427424 });
-        case 'reduce noise': return __assign(__assign({}, base), { Fltr: {
+        case 'reduce noise': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Reduce Noise',
                 _classID: 'denoise',
                 ClNs: unitsPercentF(f.filter.reduceColorNoise),
                 Shrp: unitsPercentF(f.filter.sharpenDetails),
                 removeJPEGArtifact: f.filter.removeJpegArtifact,
-                channelDenoise: f.filter.channelDenoise.map(function (c) { return (__assign({ _name: '', _classID: 'channelDenoiseParams', Chnl: c.channels.map(function (i) { return Chnl.encode(i); }), Amnt: c.amount }, (c.preserveDetails ? { EdgF: c.preserveDetails } : {}))); }),
+                channelDenoise: f.filter.channelDenoise.map(c => (Object.assign({ _name: '', _classID: 'channelDenoiseParams', Chnl: c.channels.map(i => Chnl.encode(i)), Amnt: c.amount }, (c.preserveDetails ? { EdgF: c.preserveDetails } : {})))),
                 preset: f.filter.preset,
             }, filterID: 633 });
-        case 'color halftone': return __assign(__assign({}, base), { Fltr: {
+        case 'color halftone': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Color Halftone',
                 _classID: 'ClrH',
                 'Rds ': f.filter.radius,
@@ -1647,49 +1626,49 @@ function serializeFilterFXItem(f) {
                 Ang3: f.filter.angle3,
                 Ang4: f.filter.angle4,
             }, filterID: 1131180616 });
-        case 'crystallize': return __assign(__assign({}, base), { Fltr: {
+        case 'crystallize': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Crystallize',
                 _classID: 'Crst',
                 ClSz: f.filter.cellSize,
                 FlRs: f.filter.randomSeed,
             }, filterID: 1131574132 });
-        case 'facet': return __assign(__assign({}, base), { filterID: 1180922912 });
-        case 'fragment': return __assign(__assign({}, base), { filterID: 1181902701 });
-        case 'mezzotint': return __assign(__assign({}, base), { Fltr: {
+        case 'facet': return Object.assign(Object.assign({}, base), { filterID: 1180922912 });
+        case 'fragment': return Object.assign(Object.assign({}, base), { filterID: 1181902701 });
+        case 'mezzotint': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Mezzotint',
                 _classID: 'Mztn',
                 MztT: MztT.encode(f.filter.type),
                 FlRs: f.filter.randomSeed,
             }, filterID: 1299870830 });
-        case 'mosaic': return __assign(__assign({}, base), { Fltr: {
+        case 'mosaic': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Mosaic',
                 _classID: 'Msc ',
                 ClSz: unitsValue(f.filter.cellSize, 'cellSize'),
             }, filterID: 1299407648 });
-        case 'pointillize': return __assign(__assign({}, base), { Fltr: {
+        case 'pointillize': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Pointillize',
                 _classID: 'Pntl',
                 ClSz: f.filter.cellSize,
                 FlRs: f.filter.randomSeed,
             }, filterID: 1349416044 });
-        case 'clouds': return __assign(__assign({}, base), { Fltr: {
+        case 'clouds': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Clouds',
                 _classID: 'Clds',
                 FlRs: f.filter.randomSeed,
             }, filterID: 1131177075 });
-        case 'difference clouds': return __assign(__assign({}, base), { Fltr: {
+        case 'difference clouds': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Difference Clouds',
                 _classID: 'DfrC',
                 FlRs: f.filter.randomSeed,
             }, filterID: 1147564611 });
-        case 'fibers': return __assign(__assign({}, base), { Fltr: {
+        case 'fibers': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Fibers',
                 _classID: 'Fbrs',
                 Vrnc: f.filter.variance,
                 Strg: f.filter.strength,
                 RndS: f.filter.randomSeed,
             }, filterID: 1180856947 });
-        case 'lens flare': return __assign(__assign({}, base), { Fltr: {
+        case 'lens flare': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Lens Flare',
                 _classID: 'LnsF',
                 Brgh: f.filter.brightness,
@@ -1701,10 +1680,10 @@ function serializeFilterFXItem(f) {
                 },
                 'Lns ': Lns.encode(f.filter.lensType),
             }, filterID: 1282306886 });
-        case 'sharpen': return __assign(__assign({}, base), { filterID: 1399353968 });
-        case 'sharpen edges': return __assign(__assign({}, base), { filterID: 1399353925 });
-        case 'sharpen more': return __assign(__assign({}, base), { filterID: 1399353933 });
-        case 'smart sharpen': return __assign(__assign({}, base), { Fltr: {
+        case 'sharpen': return Object.assign(Object.assign({}, base), { filterID: 1399353968 });
+        case 'sharpen edges': return Object.assign(Object.assign({}, base), { filterID: 1399353925 });
+        case 'sharpen more': return Object.assign(Object.assign({}, base), { filterID: 1399353933 });
+        case 'smart sharpen': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Smart Sharpen',
                 _classID: 'smartSharpen',
                 Amnt: unitsPercentF(f.filter.amount),
@@ -1729,27 +1708,27 @@ function serializeFilterFXItem(f) {
                     'Rds ': f.filter.highlight.radius,
                 },
             }, filterID: 698 });
-        case 'unsharp mask': return __assign(__assign({}, base), { Fltr: {
+        case 'unsharp mask': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Unsharp Mask',
                 _classID: 'UnsM',
                 Amnt: unitsPercentF(f.filter.amount),
                 'Rds ': uvRadius(f.filter),
                 Thsh: f.filter.threshold,
             }, filterID: 1433301837 });
-        case 'diffuse': return __assign(__assign({}, base), { Fltr: {
+        case 'diffuse': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Diffuse',
                 _classID: 'Dfs ',
                 'Md  ': DfsM.encode(f.filter.mode),
                 FlRs: f.filter.randomSeed,
             }, filterID: 1147564832 });
-        case 'emboss': return __assign(__assign({}, base), { Fltr: {
+        case 'emboss': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Emboss',
                 _classID: 'Embs',
                 Angl: f.filter.angle,
                 Hght: f.filter.height,
                 Amnt: f.filter.amount,
             }, filterID: 1164796531 });
-        case 'extrude': return __assign(__assign({}, base), { Fltr: {
+        case 'extrude': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Extrude',
                 _classID: 'Extr',
                 ExtS: f.filter.size,
@@ -1760,9 +1739,9 @@ function serializeFilterFXItem(f) {
                 ExtR: ExtR.encode(f.filter.depthMode),
                 FlRs: f.filter.randomSeed,
             }, filterID: 1165522034 });
-        case 'find edges': return __assign(__assign({}, base), { filterID: 1181639749 });
-        case 'solarize': return __assign(__assign({}, base), { filterID: 1399616122 });
-        case 'tiles': return __assign(__assign({}, base), { Fltr: {
+        case 'find edges': return Object.assign(Object.assign({}, base), { filterID: 1181639749 });
+        case 'solarize': return Object.assign(Object.assign({}, base), { filterID: 1399616122 });
+        case 'tiles': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Tiles',
                 _classID: 'Tls ',
                 TlNm: f.filter.numberOfTiles,
@@ -1770,61 +1749,61 @@ function serializeFilterFXItem(f) {
                 FlCl: FlCl.encode(f.filter.fillEmptyAreaWith),
                 FlRs: f.filter.randomSeed,
             }, filterID: 1416393504 });
-        case 'trace contour': return __assign(__assign({}, base), { Fltr: {
+        case 'trace contour': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Trace Contour',
                 _classID: 'TrcC',
                 'Lvl ': f.filter.level,
                 'Edg ': CntE.encode(f.filter.edge),
             }, filterID: 1416782659 });
-        case 'wind': return __assign(__assign({}, base), { Fltr: {
+        case 'wind': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Wind',
                 _classID: 'Wnd ',
                 WndM: WndM.encode(f.filter.method),
                 Drct: Drct.encode(f.filter.direction),
             }, filterID: 1466852384 });
-        case 'de-interlace': return __assign(__assign({}, base), { Fltr: {
+        case 'de-interlace': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'De-Interlace',
                 _classID: 'Dntr',
                 IntE: IntE.encode(f.filter.eliminate),
                 IntC: IntC.encode(f.filter.newFieldsBy),
             }, filterID: 1148089458 });
-        case 'ntsc colors': return __assign(__assign({}, base), { filterID: 1314149187 });
-        case 'invert': return __assign(__assign({}, base), { filterID: 1231976050 });
-        case 'custom': return __assign(__assign({}, base), { Fltr: {
+        case 'ntsc colors': return Object.assign(Object.assign({}, base), { filterID: 1314149187 });
+        case 'invert': return Object.assign(Object.assign({}, base), { filterID: 1231976050 });
+        case 'custom': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Custom',
                 _classID: 'Cstm',
                 'Scl ': f.filter.scale,
                 Ofst: f.filter.offset,
                 Mtrx: f.filter.matrix,
             }, filterID: 1131639917 });
-        case 'high pass': return __assign(__assign({}, base), { Fltr: {
+        case 'high pass': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'High Pass',
                 _classID: 'HghP',
                 'Rds ': uvRadius(f.filter),
             }, filterID: 1214736464 });
-        case 'maximum': return __assign(__assign({}, base), { Fltr: {
+        case 'maximum': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Maximum',
                 _classID: 'Mxm ',
                 'Rds ': uvRadius(f.filter),
             }, filterID: 1299737888 });
-        case 'minimum': return __assign(__assign({}, base), { Fltr: {
+        case 'minimum': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Minimum',
                 _classID: 'Mnm ',
                 'Rds ': uvRadius(f.filter),
             }, filterID: 1299082528 });
-        case 'offset': return __assign(__assign({}, base), { Fltr: {
+        case 'offset': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Offset',
                 _classID: 'Ofst',
                 Hrzn: f.filter.horizontal,
                 Vrtc: f.filter.vertical,
                 'Fl  ': FlMd.encode(f.filter.undefinedAreas),
             }, filterID: 1332114292 });
-        case 'puppet': return __assign(__assign({}, base), { Fltr: {
+        case 'puppet': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Rigid Transform',
                 _classID: 'rigidTransform',
                 'null': ['Ordn.Trgt'],
                 rigidType: f.filter.rigidType,
-                puppetShapeList: f.filter.puppetShapeList.map(function (p) { return ({
+                puppetShapeList: f.filter.puppetShapeList.map(p => ({
                     _name: '',
                     _classID: 'puppetShape',
                     rigidType: p.rigidType,
@@ -1847,27 +1826,27 @@ function serializeFilterFXItem(f) {
                     meshBoundaryPath: {
                         _name: '',
                         _classID: 'pathClass',
-                        pathComponents: p.meshBoundaryPath.pathComponents.map(function (c) { return ({
+                        pathComponents: p.meshBoundaryPath.pathComponents.map(c => ({
                             _name: '',
                             _classID: 'PaCm',
-                            shapeOperation: "shapeOperation.".concat(c.shapeOperation),
-                            SbpL: c.paths.map(function (path) { return ({
+                            shapeOperation: `shapeOperation.${c.shapeOperation}`,
+                            SbpL: c.paths.map(path => ({
                                 _name: '',
                                 _classID: 'Sbpl',
                                 Clsp: path.closed,
-                                'Pts ': path.points.map(function (pt) { return ({
+                                'Pts ': path.points.map(pt => ({
                                     _name: '',
                                     _classID: 'Pthp',
                                     Anch: pointToHrznVrtc(pt.anchor),
                                     'Fwd ': pointToHrznVrtc(pt.forward),
                                     'Bwd ': pointToHrznVrtc(pt.backward),
                                     Smoo: pt.smooth,
-                                }); }),
-                            }); }),
-                        }); }),
+                                })),
+                            })),
+                        })),
                     },
                     selectedPin: p.selectedPin,
-                }); }),
+                })),
                 PuX0: f.filter.bounds[0].x,
                 PuX1: f.filter.bounds[1].x,
                 PuX2: f.filter.bounds[2].x,
@@ -1878,17 +1857,17 @@ function serializeFilterFXItem(f) {
                 PuY3: f.filter.bounds[3].y,
             }, filterID: 991 });
         case 'oil paint plugin': {
-            var params = {};
-            for (var i = 0; i < f.filter.parameters.length; i++) {
-                var _a = f.filter.parameters[i], name_1 = _a.name, value = _a.value;
-                var suffix = "".concat(fromAtoZ[Math.floor(i / fromAtoZ.length)]).concat(fromAtoZ[i % fromAtoZ.length]);
-                params["PN".concat(suffix)] = name_1;
-                params["PT".concat(suffix)] = 0;
-                params["PF".concat(suffix)] = value;
+            const params = {};
+            for (let i = 0; i < f.filter.parameters.length; i++) {
+                const { name, value } = f.filter.parameters[i];
+                const suffix = `${fromAtoZ[Math.floor(i / fromAtoZ.length)]}${fromAtoZ[i % fromAtoZ.length]}`;
+                params[`PN${suffix}`] = name;
+                params[`PT${suffix}`] = 0;
+                params[`PF${suffix}`] = value;
             }
-            return __assign(__assign({}, base), { Fltr: __assign({ _name: 'Oil Paint Plugin', _classID: 'PbPl', KnNm: f.filter.name, GpuY: f.filter.gpu, LIWy: f.filter.lighting, FPth: '1' }, params), filterID: 1348620396 });
+            return Object.assign(Object.assign({}, base), { Fltr: Object.assign({ _name: 'Oil Paint Plugin', _classID: 'PbPl', KnNm: f.filter.name, GpuY: f.filter.gpu, LIWy: f.filter.lighting, FPth: '1' }, params), filterID: 1348620396 });
         }
-        case 'oil paint': return __assign(__assign({}, base), { Fltr: {
+        case 'oil paint': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Oil Paint',
                 _classID: 'oilPaint',
                 lightingOn: f.filter.lightingOn,
@@ -1899,32 +1878,32 @@ function serializeFilterFXItem(f) {
                 LghD: f.filter.lightDirection,
                 specularity: f.filter.specularity,
             }, filterID: 1122 });
-        case 'liquify': return __assign(__assign({}, base), { Fltr: {
+        case 'liquify': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Liquify',
                 _classID: 'LqFy',
                 LqMe: f.filter.liquifyMesh,
             }, filterID: 1282492025 });
-        case 'perspective warp': return __assign(__assign({}, base), { Fltr: {
+        case 'perspective warp': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Perspective Warp',
                 _classID: 'perspectiveWarpTransform',
                 vertices: f.filter.vertices.map(pointToHrznVrtc),
                 warpedVertices: f.filter.warpedVertices.map(pointToHrznVrtc),
-                quads: f.filter.quads.map(function (indices) { return ({ indices: indices }); }),
+                quads: f.filter.quads.map(indices => ({ indices })),
             }, filterID: 442 });
-        case 'curves': return __assign(__assign({}, base), { Fltr: __assign({ _name: 'Curves', _classID: 'Crvs', presetKind: presetKindType.encode(f.filter.presetKind) }, (f.filter.adjustments ? {
-                Adjs: f.filter.adjustments.map(function (a) { return 'curve' in a ? {
+        case 'curves': return Object.assign(Object.assign({}, base), { Fltr: Object.assign({ _name: 'Curves', _classID: 'Crvs', presetKind: presetKindType.encode(f.filter.presetKind) }, (f.filter.adjustments ? {
+                Adjs: f.filter.adjustments.map(a => 'curve' in a ? {
                     _name: '',
                     _classID: 'CrvA',
                     Chnl: a.channels.map(Chnl.encode),
-                    'Crv ': a.curve.map(function (c) { return (__assign({ _name: '', _classID: 'Pnt ', Hrzn: c.x, Vrtc: c.y }, (c.curved ? { Cnty: true } : {}))); }),
+                    'Crv ': a.curve.map(c => (Object.assign({ _name: '', _classID: 'Pnt ', Hrzn: c.x, Vrtc: c.y }, (c.curved ? { Cnty: true } : {})))),
                 } : {
                     _name: '',
                     _classID: 'CrvA',
                     Chnl: a.channels.map(Chnl.encode),
                     Mpng: a.values,
-                }; })
+                })
             } : {})), filterID: 1131574899 });
-        case 'brightness/contrast': return __assign(__assign({}, base), { Fltr: {
+        case 'brightness/contrast': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Brightness/Contrast',
                 _classID: 'BrgC',
                 Brgh: f.filter.brightness,
@@ -1934,7 +1913,7 @@ function serializeFilterFXItem(f) {
         // case 'hsb/hsl': return {
         // TODO: ...
         // };
-        default: throw new Error("Unknow filter type: ".concat(f.type));
+        default: throw new Error(`Unknow filter type: ${f.type}`);
     }
 }
 // let t: any;
@@ -1943,10 +1922,10 @@ function getWarpFromPlacedLayer(placed) {
         return placed.warp;
     if (!placed.width || !placed.height)
         throw new Error('You must provide width and height of the linked image in placedLayer');
-    var w = placed.width;
-    var h = placed.height;
-    var x0 = 0, x1 = w / 3, x2 = w * 2 / 3, x3 = w;
-    var y0 = 0, y1 = h / 3, y2 = h * 2 / 3, y3 = h;
+    const w = placed.width;
+    const h = placed.height;
+    const x0 = 0, x1 = w / 3, x2 = w * 2 / 3, x3 = w;
+    const y0 = 0, y1 = h / 3, y2 = h * 2 / 3, y3 = h;
     return {
         style: 'custom',
         value: 0,
@@ -1971,13 +1950,13 @@ function getWarpFromPlacedLayer(placed) {
         },
     };
 }
-addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
+addHandler('SoLd', hasKey('placedLayer'), (reader, target, left) => {
     if (readSignature(reader) !== 'soLD')
-        throw new Error("Invalid SoLd type");
-    var version = readInt32(reader);
+        throw new Error(`Invalid SoLd type`);
+    const version = readInt32(reader);
     if (version !== 4 && version !== 5)
-        throw new Error("Invalid SoLd version");
-    var desc = readVersionAndDescriptor(reader, true);
+        throw new Error(`Invalid SoLd version`);
+    const desc = readVersionAndDescriptor(reader, true);
     // console.log('SoLd', require('util').inspect(desc, false, 99, true));
     // console.log('SoLd.warp', require('util').inspect(desc.warp, false, 99, true));
     // console.log('SoLd.quiltWarp', require('util').inspect(desc.quiltWarp, false, 99, true));
@@ -2000,7 +1979,7 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
         resolution: parseUnits(desc.Rslt),
         warp: parseWarp((desc.quiltWarp || desc.warp)),
     };
-    if (desc.nonAffineTransform && desc.nonAffineTransform.some(function (x, i) { return x !== desc.Trnf[i]; })) {
+    if (desc.nonAffineTransform && desc.nonAffineTransform.some((x, i) => x !== desc.Trnf[i])) {
         target.placedLayer.nonAffineTransform = desc.nonAffineTransform;
     }
     if (desc.Crop)
@@ -2017,15 +1996,15 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
         target.placedLayer.filter = parseFilterFX(desc.filterFX, reader);
     // console.log('filter', require('util').inspect(target.placedLayer.filter, false, 99, true));
     skipBytes(reader, left()); // HACK
-}, function (writer, target) {
+}, (writer, target) => {
     var _a, _b;
     writeSignature(writer, 'soLD');
     writeInt32(writer, 4); // version
-    var placed = target.placedLayer;
+    const placed = target.placedLayer;
     if (!placed.id || typeof placed.id !== 'string' || !/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(placed.id)) {
         throw new Error('Placed layer ID must be in a GUID format (example: 20953ddb-9391-11ec-b4f1-c15674f50bc4)');
     }
-    var desc = __assign(__assign({ Idnt: placed.id, placed: (_a = placed.placed) !== null && _a !== void 0 ? _a : placed.id, PgNm: placed.pageNumber || 1, totalPages: placed.totalPages || 1 }, (placed.crop ? { Crop: placed.crop } : {})), { frameStep: placed.frameStep || { numerator: 0, denominator: 600 }, duration: placed.duration || { numerator: 0, denominator: 600 }, frameCount: placed.frameCount || 0, Annt: 16, Type: placedLayerTypes.indexOf(placed.type), Trnf: placed.transform, nonAffineTransform: (_b = placed.nonAffineTransform) !== null && _b !== void 0 ? _b : placed.transform, 
+    const desc = Object.assign(Object.assign({ Idnt: placed.id, placed: (_a = placed.placed) !== null && _a !== void 0 ? _a : placed.id, PgNm: placed.pageNumber || 1, totalPages: placed.totalPages || 1 }, (placed.crop ? { Crop: placed.crop } : {})), { frameStep: placed.frameStep || { numerator: 0, denominator: 600 }, duration: placed.duration || { numerator: 0, denominator: 600 }, frameCount: placed.frameCount || 0, Annt: 16, Type: placedLayerTypes.indexOf(placed.type), Trnf: placed.transform, nonAffineTransform: (_b = placed.nonAffineTransform) !== null && _b !== void 0 ? _b : placed.transform, 
         // quiltWarp: {} as any,
         warp: encodeWarp(getWarpFromPlacedLayer(placed)), 'Sz  ': {
             _name: '',
@@ -2042,7 +2021,7 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
             filterMaskEnable: placed.filter.maskEnabled,
             filterMaskLinked: placed.filter.maskLinked,
             filterMaskExtendWithWhite: placed.filter.maskExtendWithWhite,
-            filterFXList: placed.filter.list.map(function (f) { return serializeFilterFXItem(f); }),
+            filterFXList: placed.filter.list.map(f => serializeFilterFXItem(f)),
         };
     }
     // TODO:
@@ -2060,7 +2039,7 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
     // 	// throw new Error('DIFFERENT');
     // }
     if (placed.warp && isQuiltWarp(placed.warp)) {
-        var quiltWarp = encodeWarp(placed.warp);
+        const quiltWarp = encodeWarp(placed.warp);
         desc.quiltWarp = quiltWarp;
         desc.warp = {
             warpStyle: 'warpStyle.warpNone',
@@ -2083,61 +2062,64 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
     writeVersionAndDescriptor(writer, '', 'null', desc, desc.quiltWarp ? 'quiltWarp' : 'warp');
 });
 addHandlerAlias('SoLE', 'SoLd');
-addHandler('fxrp', hasKey('referencePoint'), function (reader, target) {
+addHandler('fxrp', hasKey('referencePoint'), (reader, target) => {
     target.referencePoint = {
         x: readFloat64(reader),
         y: readFloat64(reader),
     };
-}, function (writer, target) {
+}, (writer, target) => {
     writeFloat64(writer, target.referencePoint.x);
     writeFloat64(writer, target.referencePoint.y);
 });
-addHandler('Lr16', function () { return false; }, function (reader, _target, _left, psd, imageResources) {
+addHandler('Lr16', () => false, (reader, _target, _left, psd, imageResources) => {
     readLayerInfo(reader, psd, imageResources);
-}, function (_writer, _target) {
+}, (_writer, _target) => {
 });
-addHandler('Lr32', function () { return false; }, function (reader, _target, _left, psd, imageResources) {
+addHandler('Lr32', () => false, (reader, _target, _left, psd, imageResources) => {
     readLayerInfo(reader, psd, imageResources);
-}, function (_writer, _target) {
+}, (_writer, _target) => {
 });
-addHandler('LMsk', hasKey('userMask'), function (reader, target) {
+addHandler('LMsk', hasKey('userMask'), (reader, target) => {
     target.userMask = {
         colorSpace: readColor(reader),
         opacity: readUint16(reader) / 0xff,
     };
-    var flag = readUint8(reader);
+    const flag = readUint8(reader);
     if (flag !== 128)
         throw new Error('Invalid flag value');
     skipBytes(reader, 1);
-}, function (writer, target) {
-    var userMask = target.userMask;
+}, (writer, target) => {
+    const userMask = target.userMask;
     writeColor(writer, userMask.colorSpace);
     writeUint16(writer, clamp(userMask.opacity, 0, 1) * 0xff);
     writeUint8(writer, 128);
     writeZeros(writer, 1);
 });
 if (MOCK_HANDLERS) {
-    addHandler('Patt', function (target) { return target._Patt !== undefined; }, function (reader, target, left) {
+    addHandler('Patt', target => target._Patt !== undefined, (reader, target, left) => {
         // console.log('additional info: Patt');
         target._Patt = readBytes(reader, left());
-    }, function (writer, target) { return false && writeBytes(writer, target._Patt); });
+    }, (writer, target) => false && writeBytes(writer, target._Patt));
 }
 else {
     addHandler('Patt', // TODO: handle also Pat2 & Pat3
-    function (// TODO: handle also Pat2 & Pat3
-    target) { return !target; }, function (reader, target, left) {
-        if (!left())
-            return;
-        skipBytes(reader, left());
-        return; // not supported yet
-        target;
-        readPattern;
-        // if (!target.patterns) target.patterns = [];
-        // target.patterns.push(readPattern(reader));
-        // skipBytes(reader, left());
-    }, function (_writer, _target) {
+    // TODO: handle also Pat2 & Pat3
+    target => !!(target.patterns && target.patterns.length > 0), (reader, target, left) => {
+        while (left() > 0) {
+            const pattern = readPattern(reader);
+            if (target.patterns === undefined)
+                target.patterns = [];
+            target.patterns.push(pattern);
+        }
+    }, (writer, target, _, _options) => {
+        const patterns = target.patterns || [];
+        for (const pattern of patterns) {
+            writePattern(writer, pattern);
+        }
     });
 }
+addHandlerAlias('Pat2', 'Patt');
+addHandlerAlias('Pat3', 'Patt');
 /*
 interface CAIDesc {
     _name: '';
@@ -2161,9 +2143,9 @@ addHandler(
 );
 // */
 if (MOCK_HANDLERS) {
-    addHandler('CAI ', function (target) { return target._CAI_ !== undefined; }, function (reader, target, left) {
+    addHandler('CAI ', target => target._CAI_ !== undefined, (reader, target, left) => {
         target._CAI_ = readBytes(reader, left());
-    }, function (writer, target) {
+    }, (writer, target) => {
         writeBytes(writer, target._CAI_);
     });
 }
@@ -2180,12 +2162,12 @@ if (MOCK_HANDLERS) {
 // }
 if (MOCK_HANDLERS) {
     addHandler('OCIO', // document color management info
-    function (// document color management info
-    target) { return target._OCIO !== undefined; }, function (reader, target, left) {
+    // document color management info
+    target => target._OCIO !== undefined, (reader, target, left) => {
         // const desc = readVersionAndDescriptor(reader, true) as OCIODescriptor;
         // console.log('OCIO', require('util').inspect(desc, false, 99, true));
         target._OCIO = readBytes(reader, left());
-    }, function (writer, target) {
+    }, (writer, target) => {
         writeBytes(writer, target._OCIO);
     });
 }
@@ -2197,21 +2179,21 @@ if (MOCK_HANDLERS) {
 // }
 if (MOCK_HANDLERS) {
     addHandler('GenI', // generative tech
-    function (// generative tech
-    target) { return target._GenI !== undefined; }, function (reader, target, left) {
-        var desc = readVersionAndDescriptor(reader, true); // as GenIDescriptor;
+    // generative tech
+    target => target._GenI !== undefined, (reader, target, left) => {
+        const desc = readVersionAndDescriptor(reader, true); // as GenIDescriptor;
         console.log('GenI', require('util').inspect(desc, false, 99, true));
         target._GenI = readBytes(reader, left());
-    }, function (writer, target) {
+    }, (writer, target) => {
         writeBytes(writer, target._GenI);
     });
 }
 function readRect(reader) {
-    var top = readInt32(reader);
-    var left = readInt32(reader);
-    var bottom = readInt32(reader);
-    var right = readInt32(reader);
-    return { top: top, left: left, bottom: bottom, right: right };
+    const top = readInt32(reader);
+    const left = readInt32(reader);
+    const bottom = readInt32(reader);
+    const right = readInt32(reader);
+    return { top, left, bottom, right };
 }
 function writeRect(writer, rect) {
     writeInt32(writer, rect.top);
@@ -2219,29 +2201,29 @@ function writeRect(writer, rect) {
     writeInt32(writer, rect.bottom);
     writeInt32(writer, rect.right);
 }
-addHandler('Anno', function (target) { return target.annotations !== undefined; }, function (reader, target, left) {
-    var major = readUint16(reader);
-    var minor = readUint16(reader);
+addHandler('Anno', target => target.annotations !== undefined, (reader, target, left) => {
+    const major = readUint16(reader);
+    const minor = readUint16(reader);
     if (major !== 2 || minor !== 1)
         throw new Error('Invalid Anno version');
-    var count = readUint32(reader);
-    var annotations = [];
-    for (var i = 0; i < count; i++) {
+    const count = readUint32(reader);
+    const annotations = [];
+    for (let i = 0; i < count; i++) {
         /*const length =*/ readUint32(reader);
-        var type = readSignature(reader);
-        var open_1 = !!readUint8(reader);
+        const type = readSignature(reader);
+        const open = !!readUint8(reader);
         /*const flags =*/ readUint8(reader); // always 28
         /*const optionalBlocks =*/ readUint16(reader);
-        var iconLocation = readRect(reader);
-        var popupLocation = readRect(reader);
-        var color = readColor(reader);
-        var author = readPascalString(reader, 2);
-        var name_2 = readPascalString(reader, 2);
-        var date = readPascalString(reader, 2);
+        const iconLocation = readRect(reader);
+        const popupLocation = readRect(reader);
+        const color = readColor(reader);
+        const author = readPascalString(reader, 2);
+        const name = readPascalString(reader, 2);
+        const date = readPascalString(reader, 2);
         /*const contentLength =*/ readUint32(reader);
         /*const dataType =*/ readSignature(reader);
-        var dataLength = readUint32(reader);
-        var data = void 0;
+        const dataLength = readUint32(reader);
+        let data;
         if (type === 'txtA') {
             if (dataLength >= 2 && readUint16(reader) === 0xfeff) {
                 data = readUnicodeStringWithLength(reader, (dataLength - 2) / 2);
@@ -2259,32 +2241,23 @@ addHandler('Anno', function (target) { return target.annotations !== undefined;
             throw new Error('Unknown annotation type');
         }
         annotations.push({
-            type: type === 'txtA' ? 'text' : 'sound',
-            open: open_1,
-            iconLocation: iconLocation,
-            popupLocation: popupLocation,
-            color: color,
-            author: author,
-            name: name_2,
-            date: date,
-            data: data,
+            type: type === 'txtA' ? 'text' : 'sound', open, iconLocation, popupLocation, color, author, name, date, data,
         });
     }
     target.annotations = annotations;
     skipBytes(reader, left());
-}, function (writer, target) {
-    var annotations = target.annotations;
+}, (writer, target) => {
+    const annotations = target.annotations;
     writeUint16(writer, 2);
     writeUint16(writer, 1);
     writeUint32(writer, annotations.length);
-    for (var _i = 0, annotations_1 = annotations; _i < annotations_1.length; _i++) {
-        var annotation = annotations_1[_i];
-        var sound = annotation.type === 'sound';
+    for (const annotation of annotations) {
+        const sound = annotation.type === 'sound';
         if (sound && !(annotation.data instanceof Uint8Array))
             throw new Error('Sound annotation data should be Uint8Array');
         if (!sound && typeof annotation.data !== 'string')
             throw new Error('Text annotation data should be string');
-        var lengthOffset = writer.offset;
+        const lengthOffset = writer.offset;
         writeUint32(writer, 0); // length
         writeSignature(writer, sound ? 'sndA' : 'txtA');
         writeUint8(writer, annotation.open ? 1 : 0);
@@ -2296,18 +2269,18 @@ addHandler('Anno', function (target) { return target.annotations !== undefined;
         writePascalString(writer, annotation.author || '', 2);
         writePascalString(writer, annotation.name || '', 2);
         writePascalString(writer, annotation.date || '', 2);
-        var contentOffset = writer.offset;
+        const contentOffset = writer.offset;
         writeUint32(writer, 0); // content length
         writeSignature(writer, sound ? 'sndM' : 'txtC');
         writeUint32(writer, 0); // data length
-        var dataOffset = writer.offset;
+        const dataOffset = writer.offset;
         if (sound) {
             writeBytes(writer, annotation.data);
         }
         else {
             writeUint16(writer, 0xfeff); // unicode string indicator
-            var text = annotation.data.replace(/\n/g, '\r');
-            for (var i = 0; i < text.length; i++)
+            const text = annotation.data.replace(/\n/g, '\r');
+            for (let i = 0; i < text.length; i++)
                 writeUint16(writer, text.charCodeAt(i));
         }
         writer.view.setUint32(lengthOffset, writer.offset - lengthOffset, false);
@@ -2316,33 +2289,33 @@ addHandler('Anno', function (target) { return target.annotations !== undefined;
     }
 });
 function createLnkHandler(tag) {
-    addHandler(tag, function (target) {
-        var psd = target;
+    addHandler(tag, (target) => {
+        const psd = target;
         if (!psd.linkedFiles || !psd.linkedFiles.length)
             return false;
-        if (tag === 'lnkE' && !psd.linkedFiles.some(function (f) { return f.linkedFile; }))
+        if (tag === 'lnkE' && !psd.linkedFiles.some(f => f.linkedFile))
             return false;
         return true;
-    }, function (reader, target, left, _psd) {
-        var psd = target;
+    }, (reader, target, left, _psd) => {
+        const psd = target;
         psd.linkedFiles = psd.linkedFiles || [];
         while (left() > 8) {
-            var size = readLength64(reader);
-            var startOffset = reader.offset;
-            var type = readSignature(reader);
+            let size = readLength64(reader);
+            const startOffset = reader.offset;
+            const type = readSignature(reader);
             // liFD - linked file data
             // liFE - linked file external
             // liFA - linked file alias
-            var version = readInt32(reader);
-            var id = readPascalString(reader, 1);
-            var name_3 = readUnicodeString(reader);
-            var fileType = readSignature(reader).trim(); // '    ' if empty
-            var fileCreator = readSignature(reader).trim(); // '    ' or '\0\0\0\0' if empty
-            var dataSize = readLength64(reader);
-            var hasFileOpenDescriptor = readUint8(reader);
-            var fileOpenDescriptor = hasFileOpenDescriptor ? readVersionAndDescriptor(reader) : undefined;
-            var linkedFileDescriptor = type === 'liFE' ? readVersionAndDescriptor(reader) : undefined;
-            var file = { id: id, name: name_3 };
+            const version = readInt32(reader);
+            const id = readPascalString(reader, 1);
+            const name = readUnicodeString(reader);
+            const fileType = readSignature(reader).trim(); // '    ' if empty
+            const fileCreator = readSignature(reader).trim(); // '    ' or '\0\0\0\0' if empty
+            const dataSize = readLength64(reader);
+            const hasFileOpenDescriptor = readUint8(reader);
+            const fileOpenDescriptor = hasFileOpenDescriptor ? readVersionAndDescriptor(reader) : undefined;
+            const linkedFileDescriptor = type === 'liFE' ? readVersionAndDescriptor(reader) : undefined;
+            const file = { id, name };
             if (fileType)
                 file.type = fileType;
             if (fileCreator)
@@ -2356,17 +2329,17 @@ function createLnkHandler(tag) {
                 };
             }
             if (type === 'liFE' && version > 3) {
-                var year = readInt32(reader);
-                var month = readUint8(reader);
-                var day = readUint8(reader);
-                var hour = readUint8(reader);
-                var minute = readUint8(reader);
-                var seconds = readFloat64(reader);
-                var wholeSeconds = Math.floor(seconds);
-                var ms = (seconds - wholeSeconds) * 1000;
+                const year = readInt32(reader);
+                const month = readUint8(reader);
+                const day = readUint8(reader);
+                const hour = readUint8(reader);
+                const minute = readUint8(reader);
+                const seconds = readFloat64(reader);
+                const wholeSeconds = Math.floor(seconds);
+                const ms = (seconds - wholeSeconds) * 1000;
                 file.time = (new Date(Date.UTC(year, month, day, hour, minute, wholeSeconds, ms))).toISOString();
             }
-            var fileSize = type === 'liFE' ? readLength64(reader) : 0;
+            const fileSize = type === 'liFE' ? readLength64(reader) : 0;
             if (type === 'liFA')
                 skipBytes(reader, 8);
             if (type === 'liFD')
@@ -2383,7 +2356,7 @@ function createLnkHandler(tag) {
                 file.data = undefined;
             if (tag === 'lnkE') {
                 file.linkedFile = {
-                    fileSize: fileSize,
+                    fileSize,
                     name: (linkedFileDescriptor === null || linkedFileDescriptor === void 0 ? void 0 : linkedFileDescriptor['Nm  ']) || '',
                     fullPath: (linkedFileDescriptor === null || linkedFileDescriptor === void 0 ? void 0 : linkedFileDescriptor.fullPath) || '',
                     originalPath: (linkedFileDescriptor === null || linkedFileDescriptor === void 0 ? void 0 : linkedFileDescriptor.originalPath) || '',
@@ -2396,14 +2369,13 @@ function createLnkHandler(tag) {
             reader.offset = startOffset + size;
         }
         skipBytes(reader, left()); // ?
-    }, function (writer, target) {
+    }, (writer, target) => {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        var psd = target;
-        for (var _i = 0, _k = psd.linkedFiles; _i < _k.length; _i++) {
-            var file = _k[_i];
+        const psd = target;
+        for (const file of psd.linkedFiles) {
             if ((tag === 'lnkE') !== !!file.linkedFile)
                 continue;
-            var version = 2;
+            let version = 2;
             if (file.assetLockedState != null)
                 version = 7;
             else if (file.assetModTime != null)
@@ -2413,7 +2385,7 @@ function createLnkHandler(tag) {
             else if (tag === 'lnkE')
                 version = 3;
             writeLength64(writer, 0);
-            var sizeOffset = writer.offset;
+            const sizeOffset = writer.offset;
             writeSignature(writer, (tag === 'lnkE') ? 'liFE' : (file.data ? 'liFD' : 'liFA'));
             writeInt32(writer, version);
             if (!file.id || typeof file.id !== 'string' || !/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(file.id)) {
@@ -2421,11 +2393,11 @@ function createLnkHandler(tag) {
             }
             writePascalString(writer, file.id, 1);
             writeUnicodeStringWithPadding(writer, file.name || '');
-            writeSignature(writer, file.type ? "".concat(file.type, "    ").substring(0, 4) : '    ');
-            writeSignature(writer, file.creator ? "".concat(file.creator, "    ").substring(0, 4) : '\0\0\0\0');
+            writeSignature(writer, file.type ? `${file.type}    `.substring(0, 4) : '    ');
+            writeSignature(writer, file.creator ? `${file.creator}    `.substring(0, 4) : '\0\0\0\0');
             writeLength64(writer, file.data ? file.data.byteLength : 0);
             if (file.descriptor && file.descriptor.compInfo) {
-                var desc = {
+                const desc = {
                     compInfo: {
                         compID: file.descriptor.compInfo.compID,
                         originalCompID: file.descriptor.compInfo.originalCompID,
@@ -2438,7 +2410,7 @@ function createLnkHandler(tag) {
                 writeUint8(writer, 0);
             }
             if (tag === 'lnkE') {
-                var desc = {
+                const desc = {
                     descVersion: 2,
                     'Nm  ': (_b = (_a = file.linkedFile) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '',
                     fullPath: (_d = (_c = file.linkedFile) === null || _c === void 0 ? void 0 : _c.fullPath) !== null && _d !== void 0 ? _d : '',
@@ -2446,7 +2418,7 @@ function createLnkHandler(tag) {
                     relPath: (_h = (_g = file.linkedFile) === null || _g === void 0 ? void 0 : _g.relativePath) !== null && _h !== void 0 ? _h : '',
                 };
                 writeVersionAndDescriptor(writer, '', 'ExternalFileLink', desc);
-                var time = file.time ? new Date(file.time) : new Date();
+                const time = file.time ? new Date(file.time) : new Date();
                 writeInt32(writer, time.getUTCFullYear());
                 writeUint8(writer, time.getUTCMonth());
                 writeUint8(writer, time.getUTCDate());
@@ -2466,7 +2438,7 @@ function createLnkHandler(tag) {
                 writeFloat64(writer, file.assetModTime || 0);
             if (version >= 7)
                 writeUint8(writer, file.assetLockedState || 0);
-            var size = writer.offset - sizeOffset;
+            let size = writer.offset - sizeOffset;
             writer.view.setUint32(sizeOffset - 4, size, false); // write size
             while (size % 4) {
                 size++;
@@ -2479,20 +2451,20 @@ createLnkHandler('lnk2');
 createLnkHandler('lnkE');
 addHandlerAlias('lnkD', 'lnk2');
 addHandlerAlias('lnk3', 'lnk2');
-addHandler('pths', hasKey('pathList'), function (reader, target) {
-    var desc = readVersionAndDescriptor(reader, true);
+addHandler('pths', hasKey('pathList'), (reader, target) => {
+    const desc = readVersionAndDescriptor(reader, true);
     // console.log(require('util').inspect(desc, false, 99, true));
     // if (options.throwForMissingFeatures && desc?.pathList?.length) throw new Error('non-empty pathList in `pths`');
     desc;
     target.pathList = []; // TODO: read paths
-}, function (writer, _target) {
-    var desc = {
+}, (writer, _target) => {
+    const desc = {
         pathList: [], // TODO: write paths
     };
     writeVersionAndDescriptor(writer, '', 'pathsDataClass', desc);
 });
-addHandler('lyvr', hasKey('version'), function (reader, target) { return target.version = readUint32(reader); }, function (writer, target) { return writeUint32(writer, target.version); });
-addHandler('lfxs', function () { return false; }, // TODO: not sure when we actually need to write this section
+addHandler('lyvr', hasKey('version'), (reader, target) => target.version = readUint32(reader), (writer, target) => writeUint32(writer, target.version));
+addHandler('lfxs', () => false, // TODO: not sure when we actually need to write this section
 // NOTE: this might be insufficient
 // target => target.effects !== undefined && (
 // 	!!target.effects.dropShadow?.some(e => e.choke) ||
@@ -2500,22 +2472,22 @@ addHandler('lfxs', function () { return false; }, // TODO: not sure when we actu
 // 	!!target.effects.outerGlow?.choke ||
 // 	!!target.effects.innerGlow?.choke
 // ),
-function (reader, target, left) {
-    var version = readUint32(reader);
+(reader, target, left) => {
+    const version = readUint32(reader);
     if (version !== 0)
-        throw new Error("Invalid lfxs version");
-    var desc = readVersionAndDescriptor(reader);
+        throw new Error(`Invalid lfxs version`);
+    const desc = readVersionAndDescriptor(reader);
     target.effects = parseEffects(desc, !!reader.logMissingFeatures);
     skipBytes(reader, left());
-}, function (writer, target, _, options) {
-    var desc = serializeEffects(target.effects, !!options.logMissingFeatures, true);
+}, (writer, target, _, options) => {
+    const desc = serializeEffects(target.effects, !!options.logMissingFeatures, true);
     writeUint32(writer, 0); // version
     writeVersionAndDescriptor(writer, '', 'null', desc);
 });
 function adjustmentType(type) {
-    return function (target) { return !!target.adjustment && target.adjustment.type === type; };
+    return (target) => !!target.adjustment && target.adjustment.type === type;
 }
-addHandler('brit', adjustmentType('brightness/contrast'), function (reader, target, left) {
+addHandler('brit', adjustmentType('brightness/contrast'), (reader, target, left) => {
     if (!target.adjustment) { // ignore if got one from CgEd block
         target.adjustment = {
             type: 'brightness/contrast',
@@ -2527,9 +2499,9 @@ addHandler('brit', adjustmentType('brightness/contrast'), function (reader, targ
         };
     }
     skipBytes(reader, left());
-}, function (writer, target) {
+}, (writer, target) => {
     var _a;
-    var info = target.adjustment;
+    const info = target.adjustment;
     writeInt16(writer, info.brightness || 0);
     writeInt16(writer, info.contrast || 0);
     writeInt16(writer, (_a = info.meanValue) !== null && _a !== void 0 ? _a : 127);
@@ -2537,12 +2509,12 @@ addHandler('brit', adjustmentType('brightness/contrast'), function (reader, targ
     writeZeros(writer, 1);
 });
 function readLevelsChannel(reader) {
-    var shadowInput = readInt16(reader);
-    var highlightInput = readInt16(reader);
-    var shadowOutput = readInt16(reader);
-    var highlightOutput = readInt16(reader);
-    var midtoneInput = readInt16(reader) / 100;
-    return { shadowInput: shadowInput, highlightInput: highlightInput, shadowOutput: shadowOutput, highlightOutput: highlightOutput, midtoneInput: midtoneInput };
+    const shadowInput = readInt16(reader);
+    const highlightInput = readInt16(reader);
+    const shadowOutput = readInt16(reader);
+    const highlightOutput = readInt16(reader);
+    const midtoneInput = readInt16(reader) / 100;
+    return { shadowInput, highlightInput, shadowOutput, highlightOutput, midtoneInput };
 }
 function writeLevelsChannel(writer, channel) {
     writeInt16(writer, channel.shadowInput);
@@ -2551,14 +2523,14 @@ function writeLevelsChannel(writer, channel) {
     writeInt16(writer, channel.highlightOutput);
     writeInt16(writer, Math.round(channel.midtoneInput * 100));
 }
-addHandler('levl', adjustmentType('levels'), function (reader, target, left) {
+addHandler('levl', adjustmentType('levels'), (reader, target, left) => {
     if (readUint16(reader) !== 2)
         throw new Error('Invalid levl version');
-    target.adjustment = __assign(__assign({}, target.adjustment), { type: 'levels', rgb: readLevelsChannel(reader), red: readLevelsChannel(reader), green: readLevelsChannel(reader), blue: readLevelsChannel(reader) });
+    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'levels', rgb: readLevelsChannel(reader), red: readLevelsChannel(reader), green: readLevelsChannel(reader), blue: readLevelsChannel(reader) });
     skipBytes(reader, left());
-}, function (writer, target) {
-    var info = target.adjustment;
-    var defaultChannel = {
+}, (writer, target) => {
+    const info = target.adjustment;
+    const defaultChannel = {
         shadowInput: 0,
         highlightInput: 255,
         shadowOutput: 0,
@@ -2570,34 +2542,33 @@ addHandler('levl', adjustmentType('levels'), function (reader, target, left) {
     writeLevelsChannel(writer, info.red || defaultChannel);
     writeLevelsChannel(writer, info.blue || defaultChannel);
     writeLevelsChannel(writer, info.green || defaultChannel);
-    for (var i = 0; i < 59; i++)
+    for (let i = 0; i < 59; i++)
         writeLevelsChannel(writer, defaultChannel);
 });
 function readCurveChannel(reader) {
-    var nodes = readUint16(reader);
-    var channel = [];
-    for (var j = 0; j < nodes; j++) {
-        var output = readInt16(reader);
-        var input = readInt16(reader);
-        channel.push({ input: input, output: output });
+    const nodes = readUint16(reader);
+    const channel = [];
+    for (let j = 0; j < nodes; j++) {
+        const output = readInt16(reader);
+        const input = readInt16(reader);
+        channel.push({ input, output });
     }
     return channel;
 }
 function writeCurveChannel(writer, channel) {
     writeUint16(writer, channel.length);
-    for (var _i = 0, channel_1 = channel; _i < channel_1.length; _i++) {
-        var n = channel_1[_i];
+    for (const n of channel) {
         writeUint16(writer, n.output);
         writeUint16(writer, n.input);
     }
 }
-addHandler('curv', adjustmentType('curves'), function (reader, target, left) {
+addHandler('curv', adjustmentType('curves'), (reader, target, left) => {
     readUint8(reader);
     if (readUint16(reader) !== 1)
         throw new Error('Invalid curv version');
     readUint16(reader);
-    var channels = readUint16(reader);
-    var info = { type: 'curves' };
+    const channels = readUint16(reader);
+    const info = { type: 'curves' };
     if (channels & 1)
         info.rgb = readCurveChannel(reader);
     if (channels & 2)
@@ -2606,7 +2577,7 @@ addHandler('curv', adjustmentType('curves'), function (reader, target, left) {
         info.green = readCurveChannel(reader);
     if (channels & 8)
         info.blue = readCurveChannel(reader);
-    target.adjustment = __assign(__assign({}, target.adjustment), info);
+    target.adjustment = Object.assign(Object.assign({}, target.adjustment), info);
     // ignoring, duplicate information
     // checkSignature(reader, 'Crv ');
     // const cVersion = readUint16(reader);
@@ -2621,11 +2592,11 @@ addHandler('curv', adjustmentType('curves'), function (reader, target, left) {
     // 	}
     // }
     skipBytes(reader, left());
-}, function (writer, target) {
-    var info = target.adjustment;
-    var rgb = info.rgb, red = info.red, green = info.green, blue = info.blue;
-    var channels = 0;
-    var channelCount = 0;
+}, (writer, target) => {
+    const info = target.adjustment;
+    const { rgb, red, green, blue } = info;
+    let channels = 0;
+    let channelCount = 0;
     if (rgb && rgb.length) {
         channels |= 1;
         channelCount++;
@@ -2675,30 +2646,30 @@ addHandler('curv', adjustmentType('curves'), function (reader, target, left) {
         writeCurveChannel(writer, blue);
     }
 });
-addHandler('expA', adjustmentType('exposure'), function (reader, target, left) {
+addHandler('expA', adjustmentType('exposure'), (reader, target, left) => {
     if (readUint16(reader) !== 1)
         throw new Error('Invalid expA version');
-    target.adjustment = __assign(__assign({}, target.adjustment), { type: 'exposure', exposure: readFloat32(reader), offset: readFloat32(reader), gamma: readFloat32(reader) });
+    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'exposure', exposure: readFloat32(reader), offset: readFloat32(reader), gamma: readFloat32(reader) });
     skipBytes(reader, left());
-}, function (writer, target) {
-    var info = target.adjustment;
+}, (writer, target) => {
+    const info = target.adjustment;
     writeUint16(writer, 1); // version
     writeFloat32(writer, info.exposure);
     writeFloat32(writer, info.offset);
     writeFloat32(writer, info.gamma);
     writeZeros(writer, 2);
 });
-addHandler('vibA', adjustmentType('vibrance'), function (reader, target, left) {
-    var desc = readVersionAndDescriptor(reader);
+addHandler('vibA', adjustmentType('vibrance'), (reader, target, left) => {
+    const desc = readVersionAndDescriptor(reader);
     target.adjustment = { type: 'vibrance' };
     if (desc.vibrance !== undefined)
         target.adjustment.vibrance = desc.vibrance;
     if (desc.Strt !== undefined)
         target.adjustment.saturation = desc.Strt;
     skipBytes(reader, left());
-}, function (writer, target) {
-    var info = target.adjustment;
-    var desc = {};
+}, (writer, target) => {
+    const info = target.adjustment;
+    const desc = {};
     if (info.vibrance !== undefined)
         desc.vibrance = info.vibrance;
     if (info.saturation !== undefined)
@@ -2717,7 +2688,7 @@ function readHueChannel(reader) {
     };
 }
 function writeHueChannel(writer, channel) {
-    var c = channel || {};
+    const c = channel || {};
     writeInt16(writer, c.a || 0);
     writeInt16(writer, c.b || 0);
     writeInt16(writer, c.c || 0);
@@ -2726,13 +2697,13 @@ function writeHueChannel(writer, channel) {
     writeInt16(writer, c.saturation || 0);
     writeInt16(writer, c.lightness || 0);
 }
-addHandler('hue2', adjustmentType('hue/saturation'), function (reader, target, left) {
+addHandler('hue2', adjustmentType('hue/saturation'), (reader, target, left) => {
     if (readUint16(reader) !== 2)
         throw new Error('Invalid hue2 version');
-    target.adjustment = __assign(__assign({}, target.adjustment), { type: 'hue/saturation', master: readHueChannel(reader), reds: readHueChannel(reader), yellows: readHueChannel(reader), greens: readHueChannel(reader), cyans: readHueChannel(reader), blues: readHueChannel(reader), magentas: readHueChannel(reader) });
+    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'hue/saturation', master: readHueChannel(reader), reds: readHueChannel(reader), yellows: readHueChannel(reader), greens: readHueChannel(reader), cyans: readHueChannel(reader), blues: readHueChannel(reader), magentas: readHueChannel(reader) });
     skipBytes(reader, left());
-}, function (writer, target) {
-    var info = target.adjustment;
+}, (writer, target) => {
+    const info = target.adjustment;
     writeUint16(writer, 2); // version
     writeHueChannel(writer, info.master);
     writeHueChannel(writer, info.reds);
@@ -2754,7 +2725,7 @@ function writeColorBalance(writer, value) {
     writeInt16(writer, value.magentaGreen || 0);
     writeInt16(writer, value.yellowBlue || 0);
 }
-addHandler('blnc', adjustmentType('color balance'), function (reader, target, left) {
+addHandler('blnc', adjustmentType('color balance'), (reader, target, left) => {
     target.adjustment = {
         type: 'color balance',
         shadows: readColorBalance(reader),
@@ -2763,16 +2734,16 @@ addHandler('blnc', adjustmentType('color balance'), function (reader, target, le
         preserveLuminosity: !!readUint8(reader),
     };
     skipBytes(reader, left());
-}, function (writer, target) {
-    var info = target.adjustment;
+}, (writer, target) => {
+    const info = target.adjustment;
     writeColorBalance(writer, info.shadows || {});
     writeColorBalance(writer, info.midtones || {});
     writeColorBalance(writer, info.highlights || {});
     writeUint8(writer, info.preserveLuminosity ? 1 : 0);
     writeZeros(writer, 1);
 });
-addHandler('blwh', adjustmentType('black & white'), function (reader, target, left) {
-    var desc = readVersionAndDescriptor(reader);
+addHandler('blwh', adjustmentType('black & white'), (reader, target, left) => {
+    const desc = readVersionAndDescriptor(reader);
     target.adjustment = {
         type: 'black & white',
         reds: desc['Rd  '],
@@ -2788,9 +2759,9 @@ addHandler('blwh', adjustmentType('black & white'), function (reader, target, le
     if (desc.tintColor !== undefined)
         target.adjustment.tintColor = parseColor(desc.tintColor);
     skipBytes(reader, left());
-}, function (writer, target) {
-    var info = target.adjustment;
-    var desc = {
+}, (writer, target) => {
+    const info = target.adjustment;
+    const desc = {
         'Rd  ': info.reds || 0,
         Yllw: info.yellows || 0,
         'Grn ': info.greens || 0,
@@ -2804,11 +2775,11 @@ addHandler('blwh', adjustmentType('black & white'), function (reader, target, le
     };
     writeVersionAndDescriptor(writer, '', 'null', desc);
 });
-addHandler('phfl', adjustmentType('photo filter'), function (reader, target, left) {
-    var version = readUint16(reader);
+addHandler('phfl', adjustmentType('photo filter'), (reader, target, left) => {
+    const version = readUint16(reader);
     if (version !== 2 && version !== 3)
         throw new Error('Invalid phfl version');
-    var color;
+    let color;
     if (version === 2) {
         color = readColor(reader);
     }
@@ -2822,13 +2793,13 @@ addHandler('phfl', adjustmentType('photo filter'), function (reader, target, lef
     }
     target.adjustment = {
         type: 'photo filter',
-        color: color,
+        color,
         density: readUint32(reader) / 100,
         preserveLuminosity: !!readUint8(reader),
     };
     skipBytes(reader, left());
-}, function (writer, target) {
-    var info = target.adjustment;
+}, (writer, target) => {
+    const info = target.adjustment;
     writeUint16(writer, 2); // version
     writeColor(writer, info.color || { l: 0, a: 0, b: 0 });
     writeUint32(writer, (info.density || 0) * 100);
@@ -2836,25 +2807,25 @@ addHandler('phfl', adjustmentType('photo filter'), function (reader, target, lef
     writeZeros(writer, 3);
 });
 function readMixrChannel(reader) {
-    var red = readInt16(reader);
-    var green = readInt16(reader);
-    var blue = readInt16(reader);
+    const red = readInt16(reader);
+    const green = readInt16(reader);
+    const blue = readInt16(reader);
     skipBytes(reader, 2);
-    var constant = readInt16(reader);
-    return { red: red, green: green, blue: blue, constant: constant };
+    const constant = readInt16(reader);
+    return { red, green, blue, constant };
 }
 function writeMixrChannel(writer, channel) {
-    var c = channel || {};
+    const c = channel || {};
     writeInt16(writer, c.red);
     writeInt16(writer, c.green);
     writeInt16(writer, c.blue);
     writeZeros(writer, 2);
     writeInt16(writer, c.constant);
 }
-addHandler('mixr', adjustmentType('channel mixer'), function (reader, target, left) {
+addHandler('mixr', adjustmentType('channel mixer'), (reader, target, left) => {
     if (readUint16(reader) !== 1)
         throw new Error('Invalid mixr version');
-    var adjustment = target.adjustment = __assign(__assign({}, target.adjustment), { type: 'channel mixer', monochrome: !!readUint16(reader) });
+    const adjustment = target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'channel mixer', monochrome: !!readUint16(reader) });
     if (!adjustment.monochrome) {
         adjustment.red = readMixrChannel(reader);
         adjustment.green = readMixrChannel(reader);
@@ -2862,8 +2833,8 @@ addHandler('mixr', adjustmentType('channel mixer'), function (reader, target, le
     }
     adjustment.gray = readMixrChannel(reader);
     skipBytes(reader, left());
-}, function (writer, target) {
-    var info = target.adjustment;
+}, (writer, target) => {
+    const info = target.adjustment;
     writeUint16(writer, 1); // version
     writeUint16(writer, info.monochrome ? 1 : 0);
     if (info.monochrome) {
@@ -2877,26 +2848,26 @@ addHandler('mixr', adjustmentType('channel mixer'), function (reader, target, le
         writeMixrChannel(writer, info.gray);
     }
 });
-var colorLookupType = createEnum('colorLookupType', '3DLUT', {
+const colorLookupType = createEnum('colorLookupType', '3DLUT', {
     '3dlut': '3DLUT',
     abstractProfile: 'abstractProfile',
     deviceLinkProfile: 'deviceLinkProfile',
 });
-var LUTFormatType = createEnum('LUTFormatType', 'look', {
+const LUTFormatType = createEnum('LUTFormatType', 'look', {
     look: 'LUTFormatLOOK',
     cube: 'LUTFormatCUBE',
     '3dl': 'LUTFormat3DL',
 });
-var colorLookupOrder = createEnum('colorLookupOrder', 'rgb', {
+const colorLookupOrder = createEnum('colorLookupOrder', 'rgb', {
     rgb: 'rgbOrder',
     bgr: 'bgrOrder',
 });
-addHandler('clrL', adjustmentType('color lookup'), function (reader, target, left) {
+addHandler('clrL', adjustmentType('color lookup'), (reader, target, left) => {
     if (readUint16(reader) !== 1)
         throw new Error('Invalid clrL version');
-    var desc = readVersionAndDescriptor(reader);
+    const desc = readVersionAndDescriptor(reader);
     target.adjustment = { type: 'color lookup' };
-    var info = target.adjustment;
+    const info = target.adjustment;
     if (desc.lookupType !== undefined)
         info.lookupType = colorLookupType.decode(desc.lookupType);
     if (desc['Nm  '] !== undefined)
@@ -2916,9 +2887,9 @@ addHandler('clrL', adjustmentType('color lookup'), function (reader, target, lef
     if (desc.LUT3DFileName !== undefined)
         info.lut3DFileName = desc.LUT3DFileName;
     skipBytes(reader, left());
-}, function (writer, target) {
-    var info = target.adjustment;
-    var desc = {};
+}, (writer, target) => {
+    const info = target.adjustment;
+    const desc = {};
     if (info.lookupType !== undefined)
         desc.lookupType = colorLookupType.encode(info.lookupType);
     if (info.name !== undefined)
@@ -2940,58 +2911,58 @@ addHandler('clrL', adjustmentType('color lookup'), function (reader, target, lef
     writeUint16(writer, 1); // version
     writeVersionAndDescriptor(writer, '', 'null', desc);
 });
-addHandler('nvrt', adjustmentType('invert'), function (reader, target, left) {
+addHandler('nvrt', adjustmentType('invert'), (reader, target, left) => {
     target.adjustment = { type: 'invert' };
     skipBytes(reader, left());
-}, function () {
+}, () => {
     // nothing to write here
 });
-addHandler('post', adjustmentType('posterize'), function (reader, target, left) {
+addHandler('post', adjustmentType('posterize'), (reader, target, left) => {
     target.adjustment = {
         type: 'posterize',
         levels: readUint16(reader),
     };
     skipBytes(reader, left());
-}, function (writer, target) {
+}, (writer, target) => {
     var _a;
-    var info = target.adjustment;
+    const info = target.adjustment;
     writeUint16(writer, (_a = info.levels) !== null && _a !== void 0 ? _a : 4);
     writeZeros(writer, 2);
 });
-addHandler('thrs', adjustmentType('threshold'), function (reader, target, left) {
+addHandler('thrs', adjustmentType('threshold'), (reader, target, left) => {
     target.adjustment = {
         type: 'threshold',
         level: readUint16(reader),
     };
     skipBytes(reader, left());
-}, function (writer, target) {
+}, (writer, target) => {
     var _a;
-    var info = target.adjustment;
+    const info = target.adjustment;
     writeUint16(writer, (_a = info.level) !== null && _a !== void 0 ? _a : 128);
     writeZeros(writer, 2);
 });
-var grdmColorModels = ['', '', '', 'rgb', 'hsb', '', 'lab'];
-addHandler('grdm', adjustmentType('gradient map'), function (reader, target, left) {
-    var version = readUint16(reader);
+const grdmColorModels = ['', '', '', 'rgb', 'hsb', '', 'lab'];
+addHandler('grdm', adjustmentType('gradient map'), (reader, target, left) => {
+    const version = readUint16(reader);
     if (version !== 1 && version !== 3)
         throw new Error('Invalid grdm version');
-    var info = {
+    const info = {
         type: 'gradient map',
         gradientType: 'solid',
     };
     info.reverse = !!readUint8(reader);
     info.dither = !!readUint8(reader);
-    var hasMethod = !!readUint8(reader);
+    const hasMethod = !!readUint8(reader);
     reader.offset--;
     if (hasMethod) {
-        var method = readSignature(reader);
+        const method = readSignature(reader);
         info.method = gradientInterpolationMethodType.decode(method);
     }
     info.name = readUnicodeString(reader);
     info.colorStops = [];
     info.opacityStops = [];
-    var stopsCount = readUint16(reader);
-    for (var i = 0; i < stopsCount; i++) {
+    const stopsCount = readUint16(reader);
+    for (let i = 0; i < stopsCount; i++) {
         info.colorStops.push({
             location: readUint32(reader),
             midpoint: readUint32(reader) / 100,
@@ -2999,20 +2970,20 @@ addHandler('grdm', adjustmentType('gradient map'), function (reader, target, lef
         });
         skipBytes(reader, 2);
     }
-    var opacityStopsCount = readUint16(reader);
-    for (var i = 0; i < opacityStopsCount; i++) {
+    const opacityStopsCount = readUint16(reader);
+    for (let i = 0; i < opacityStopsCount; i++) {
         info.opacityStops.push({
             location: readUint32(reader),
             midpoint: readUint32(reader) / 100,
             opacity: readUint16(reader) / 0xff,
         });
     }
-    var expansionCount = readUint16(reader);
+    const expansionCount = readUint16(reader);
     if (expansionCount !== 2)
         throw new Error('Invalid grdm expansion count');
-    var interpolation = readUint16(reader);
+    const interpolation = readUint16(reader);
     info.smoothness = interpolation / 4096;
-    var length = readUint16(reader);
+    const length = readUint16(reader);
     if (length !== 32)
         throw new Error('Invalid grdm length');
     info.gradientType = readUint16(reader) ? 'noise' : 'solid';
@@ -3034,18 +3005,14 @@ addHandler('grdm', adjustmentType('gradient map'), function (reader, target, lef
         readUint16(reader) / 0x8000,
     ];
     skipBytes(reader, left());
-    for (var _i = 0, _a = info.colorStops; _i < _a.length; _i++) {
-        var s = _a[_i];
+    for (const s of info.colorStops)
         s.location /= interpolation;
-    }
-    for (var _b = 0, _c = info.opacityStops; _b < _c.length; _b++) {
-        var s = _c[_b];
+    for (const s of info.opacityStops)
         s.location /= interpolation;
-    }
     target.adjustment = info;
-}, function (writer, target) {
+}, (writer, target) => {
     var _a, _b, _c;
-    var info = target.adjustment;
+    const info = target.adjustment;
     writeUint16(writer, info.method !== undefined ? 3 : 1); // version
     writeUint8(writer, info.reverse ? 1 : 0);
     writeUint8(writer, info.dither ? 1 : 0);
@@ -3054,17 +3021,15 @@ addHandler('grdm', adjustmentType('gradient map'), function (reader, target, lef
     }
     writeUnicodeStringWithPadding(writer, info.name || '');
     writeUint16(writer, info.colorStops && info.colorStops.length || 0);
-    var interpolation = Math.round(((_a = info.smoothness) !== null && _a !== void 0 ? _a : 1) * 4096);
-    for (var _i = 0, _d = info.colorStops || []; _i < _d.length; _i++) {
-        var s = _d[_i];
+    const interpolation = Math.round(((_a = info.smoothness) !== null && _a !== void 0 ? _a : 1) * 4096);
+    for (const s of info.colorStops || []) {
         writeUint32(writer, Math.round(s.location * interpolation));
         writeUint32(writer, Math.round(s.midpoint * 100));
         writeColor(writer, s.color);
         writeZeros(writer, 2);
     }
     writeUint16(writer, info.opacityStops && info.opacityStops.length || 0);
-    for (var _e = 0, _f = info.opacityStops || []; _e < _f.length; _e++) {
-        var s = _f[_e];
+    for (const s of info.opacityStops || []) {
         writeUint32(writer, Math.round(s.location * interpolation));
         writeUint32(writer, Math.round(s.midpoint * 100));
         writeUint16(writer, Math.round(s.opacity * 0xff));
@@ -3077,11 +3042,11 @@ addHandler('grdm', adjustmentType('gradient map'), function (reader, target, lef
     writeUint16(writer, info.addTransparency ? 1 : 0);
     writeUint16(writer, info.restrictColors ? 1 : 0);
     writeUint32(writer, Math.round(((_b = info.roughness) !== null && _b !== void 0 ? _b : 1) * 4096));
-    var colorModel = grdmColorModels.indexOf((_c = info.colorModel) !== null && _c !== void 0 ? _c : 'rgb');
+    const colorModel = grdmColorModels.indexOf((_c = info.colorModel) !== null && _c !== void 0 ? _c : 'rgb');
     writeUint16(writer, colorModel === -1 ? 3 : colorModel);
-    for (var i = 0; i < 4; i++)
+    for (let i = 0; i < 4; i++)
         writeUint16(writer, Math.round((info.min && info.min[i] || 0) * 0x8000));
-    for (var i = 0; i < 4; i++)
+    for (let i = 0; i < 4; i++)
         writeUint16(writer, Math.round((info.max && info.max[i] || 0) * 0x8000));
     writeZeros(writer, 4);
 });
@@ -3094,20 +3059,20 @@ function readSelectiveColors(reader) {
     };
 }
 function writeSelectiveColors(writer, cmyk) {
-    var c = cmyk || {};
+    const c = cmyk || {};
     writeInt16(writer, c.c);
     writeInt16(writer, c.m);
     writeInt16(writer, c.y);
     writeInt16(writer, c.k);
 }
-addHandler('selc', adjustmentType('selective color'), function (reader, target) {
+addHandler('selc', adjustmentType('selective color'), (reader, target) => {
     if (readUint16(reader) !== 1)
         throw new Error('Invalid selc version');
-    var mode = readUint16(reader) ? 'absolute' : 'relative';
+    const mode = readUint16(reader) ? 'absolute' : 'relative';
     skipBytes(reader, 8);
     target.adjustment = {
         type: 'selective color',
-        mode: mode,
+        mode,
         reds: readSelectiveColors(reader),
         yellows: readSelectiveColors(reader),
         greens: readSelectiveColors(reader),
@@ -3118,8 +3083,8 @@ addHandler('selc', adjustmentType('selective color'), function (reader, target)
         neutrals: readSelectiveColors(reader),
         blacks: readSelectiveColors(reader),
     };
-}, function (writer, target) {
-    var info = target.adjustment;
+}, (writer, target) => {
+    const info = target.adjustment;
     writeUint16(writer, 1); // version
     writeUint16(writer, info.mode === 'absolute' ? 1 : 0);
     writeZeros(writer, 8);
@@ -3133,26 +3098,26 @@ addHandler('selc', adjustmentType('selective color'), function (reader, target)
     writeSelectiveColors(writer, info.neutrals);
     writeSelectiveColors(writer, info.blacks);
 });
-addHandler('CgEd', function (target) {
-    var a = target.adjustment;
+addHandler('CgEd', target => {
+    const a = target.adjustment;
     if (!a)
         return false;
     return (a.type === 'brightness/contrast' && !a.useLegacy) ||
         ((a.type === 'levels' || a.type === 'curves' || a.type === 'exposure' || a.type === 'channel mixer' ||
             a.type === 'hue/saturation') && a.presetFileName !== undefined);
-}, function (reader, target, left) {
-    var desc = readVersionAndDescriptor(reader);
+}, (reader, target, left) => {
+    const desc = readVersionAndDescriptor(reader);
     if (desc.Vrsn !== 1)
         throw new Error('Invalid CgEd version');
     // this section can specify preset file name for other adjustment types
     if ('presetFileName' in desc) {
-        target.adjustment = __assign(__assign({}, target.adjustment), { presetKind: desc.presetKind, presetFileName: desc.presetFileName });
+        target.adjustment = Object.assign(Object.assign({}, target.adjustment), { presetKind: desc.presetKind, presetFileName: desc.presetFileName });
     }
     else if ('curvesPresetFileName' in desc) {
-        target.adjustment = __assign(__assign({}, target.adjustment), { presetKind: desc.curvesPresetKind, presetFileName: desc.curvesPresetFileName });
+        target.adjustment = Object.assign(Object.assign({}, target.adjustment), { presetKind: desc.curvesPresetKind, presetFileName: desc.curvesPresetFileName });
     }
     else if ('mixerPresetFileName' in desc) {
-        target.adjustment = __assign(__assign({}, target.adjustment), { presetKind: desc.mixerPresetKind, presetFileName: desc.mixerPresetFileName });
+        target.adjustment = Object.assign(Object.assign({}, target.adjustment), { presetKind: desc.mixerPresetKind, presetFileName: desc.mixerPresetFileName });
     }
     else {
         target.adjustment = {
@@ -3166,11 +3131,11 @@ addHandler('CgEd', function (target) {
         };
     }
     skipBytes(reader, left());
-}, function (writer, target) {
+}, (writer, target) => {
     var _a, _b, _c, _d;
-    var info = target.adjustment;
+    const info = target.adjustment;
     if (info.type === 'levels' || info.type === 'exposure' || info.type === 'hue/saturation') {
-        var desc = {
+        const desc = {
             Vrsn: 1,
             presetKind: (_a = info.presetKind) !== null && _a !== void 0 ? _a : 1,
             presetFileName: info.presetFileName || '',
@@ -3178,7 +3143,7 @@ addHandler('CgEd', function (target) {
         writeVersionAndDescriptor(writer, '', 'null', desc);
     }
     else if (info.type === 'curves') {
-        var desc = {
+        const desc = {
             Vrsn: 1,
             curvesPresetKind: (_b = info.presetKind) !== null && _b !== void 0 ? _b : 1,
             curvesPresetFileName: info.presetFileName || '',
@@ -3186,7 +3151,7 @@ addHandler('CgEd', function (target) {
         writeVersionAndDescriptor(writer, '', 'null', desc);
     }
     else if (info.type === 'channel mixer') {
-        var desc = {
+        const desc = {
             Vrsn: 1,
             mixerPresetKind: (_c = info.presetKind) !== null && _c !== void 0 ? _c : 1,
             mixerPresetFileName: info.presetFileName || '',
@@ -3194,7 +3159,7 @@ addHandler('CgEd', function (target) {
         writeVersionAndDescriptor(writer, '', 'null', desc);
     }
     else if (info.type === 'brightness/contrast') {
-        var desc = {
+        const desc = {
             Vrsn: 1,
             Brgh: info.brightness || 0,
             Cntr: info.contrast || 0,
@@ -3210,12 +3175,11 @@ addHandler('CgEd', function (target) {
     }
 });
 function getTextLayersSortedByIndex(psd) {
-    var layers = [];
+    const layers = [];
     function collect(layer) {
         var _a;
         if (layer.children) {
-            for (var _i = 0, _b = layer.children; _i < _b.length; _i++) {
-                var child = _b[_i];
+            for (const child of layer.children) {
                 if (((_a = child.text) === null || _a === void 0 ? void 0 : _a.index) !== undefined) {
                     layers[child.text.index] = child;
                 }
@@ -3226,16 +3190,16 @@ function getTextLayersSortedByIndex(psd) {
     collect(psd);
     return layers;
 }
-addHandler('Txt2', hasKey('engineData'), function (reader, target, left, psd) {
-    var data = readBytes(reader, left());
+addHandler('Txt2', hasKey('engineData'), (reader, target, left, psd) => {
+    const data = readBytes(reader, left());
     target.engineData = fromByteArray(data);
-    var layersByIndex = getTextLayersSortedByIndex(psd);
-    var engineData = parseEngineData(data);
-    var engineData2 = decodeEngineData2(engineData);
-    var TextFrameSet = engineData2.ResourceDict.TextFrameSet;
+    const layersByIndex = getTextLayersSortedByIndex(psd);
+    const engineData = parseEngineData(data);
+    const engineData2 = decodeEngineData2(engineData);
+    const TextFrameSet = engineData2.ResourceDict.TextFrameSet;
     if (TextFrameSet) {
-        for (var i = 0; i < TextFrameSet.length; i++) {
-            var layer = layersByIndex[i];
+        for (let i = 0; i < TextFrameSet.length; i++) {
+            const layer = layersByIndex[i];
             if (TextFrameSet[i].path && (layer === null || layer === void 0 ? void 0 : layer.text)) {
                 layer.text.textPath = TextFrameSet[i].path;
             }
@@ -3245,94 +3209,93 @@ addHandler('Txt2', hasKey('engineData'), function (reader, target, left, psd) {
     // require('fs').writeFileSync('test_data.bin', data);
     // require('fs').writeFileSync('test_data.txt', require('util').inspect(engineData, false, 99, false), 'utf8');
     // require('fs').writeFileSync('test_data.json', JSON.stringify(engineData2, null, 2), 'utf8');
-}, function (writer, target) {
-    var buffer = toByteArray(target.engineData);
+}, (writer, target) => {
+    const buffer = toByteArray(target.engineData);
     writeBytes(writer, buffer);
 });
-addHandler('FEid', hasKey('filterEffectsMasks'), function (reader, target, leftBytes) {
-    var version = readInt32(reader);
+addHandler('FEid', hasKey('filterEffectsMasks'), (reader, target, leftBytes) => {
+    const version = readInt32(reader);
     if (version < 1 || version > 3)
-        throw new Error("Invalid filterEffects version ".concat(version));
+        throw new Error(`Invalid filterEffects version ${version}`);
     target.filterEffectsMasks = [];
     while (leftBytes() > 8) {
         if (readUint32(reader))
             throw new Error('filterEffects: 64 bit length is not supported');
-        var length_2 = readUint32(reader);
-        var end = reader.offset + length_2;
-        var id = readPascalString(reader, 1);
-        var effectVersion = readInt32(reader);
+        const length = readUint32(reader);
+        const end = reader.offset + length;
+        const id = readPascalString(reader, 1);
+        const effectVersion = readInt32(reader);
         if (effectVersion !== 1)
-            throw new Error("Invalid filterEffect version ".concat(effectVersion));
+            throw new Error(`Invalid filterEffect version ${effectVersion}`);
         if (readUint32(reader))
             throw new Error('filterEffect: 64 bit length is not supported');
         /*const effectLength =*/ readUint32(reader);
         // const endOfEffect = reader.offset + effectLength;
-        var top_2 = readInt32(reader);
-        var left = readInt32(reader);
-        var bottom = readInt32(reader);
-        var right = readInt32(reader);
-        var depth = readInt32(reader);
-        var maxChannels = readInt32(reader);
-        var channels = [];
+        const top = readInt32(reader);
+        const left = readInt32(reader);
+        const bottom = readInt32(reader);
+        const right = readInt32(reader);
+        const depth = readInt32(reader);
+        const maxChannels = readInt32(reader);
+        const channels = [];
         // 0 -> R, 1 -> G, 2 -> B, 25 -> A
-        for (var i = 0; i < (maxChannels + 2); i++) { // channels + user mask + sheet mask
-            var exists = readInt32(reader);
+        for (let i = 0; i < (maxChannels + 2); i++) { // channels + user mask + sheet mask
+            const exists = readInt32(reader);
             if (exists) {
                 if (readUint32(reader))
                     throw new Error('filterEffect: 64 bit length is not supported');
-                var channelLength = readUint32(reader);
+                const channelLength = readUint32(reader);
                 if (!channelLength)
                     throw new Error('filterEffect: Empty channel');
-                var compressionMode = readUint16(reader);
-                var data = readBytes(reader, channelLength - 2);
-                channels.push({ compressionMode: compressionMode, data: data });
+                const compressionMode = readUint16(reader);
+                const data = readBytes(reader, channelLength - 2);
+                channels.push({ compressionMode, data });
             }
             else {
                 channels.push(undefined);
             }
         }
-        target.filterEffectsMasks.push({ id: id, top: top_2, left: left, bottom: bottom, right: right, depth: depth, channels: channels });
+        target.filterEffectsMasks.push({ id, top, left, bottom, right, depth, channels });
         if (reader.offset < end && readUint8(reader)) {
-            var top_3 = readInt32(reader);
-            var left_1 = readInt32(reader);
-            var bottom_1 = readInt32(reader);
-            var right_1 = readInt32(reader);
+            const top = readInt32(reader);
+            const left = readInt32(reader);
+            const bottom = readInt32(reader);
+            const right = readInt32(reader);
             if (readUint32(reader))
                 throw new Error('filterEffect: 64 bit length is not supported');
-            var extraLength = readUint32(reader);
-            var compressionMode = readUint16(reader);
-            var data = readBytes(reader, extraLength - 2);
-            target.filterEffectsMasks[target.filterEffectsMasks.length - 1].extra = { top: top_3, left: left_1, bottom: bottom_1, right: right_1, compressionMode: compressionMode, data: data };
+            const extraLength = readUint32(reader);
+            const compressionMode = readUint16(reader);
+            const data = readBytes(reader, extraLength - 2);
+            target.filterEffectsMasks[target.filterEffectsMasks.length - 1].extra = { top, left, bottom, right, compressionMode, data };
         }
         reader.offset = end;
-        var len = length_2;
+        let len = length;
         while (len % 4) {
             reader.offset++;
             len++;
         }
     }
-}, function (writer, target) {
+}, (writer, target) => {
     var _a;
     writeInt32(writer, 3); // version
-    for (var _i = 0, _b = target.filterEffectsMasks; _i < _b.length; _i++) {
-        var mask = _b[_i];
+    for (const mask of target.filterEffectsMasks) {
         writeUint32(writer, 0);
         writeUint32(writer, 0);
-        var lengthOffset = writer.offset;
+        const lengthOffset = writer.offset;
         writePascalString(writer, mask.id, 1);
         writeInt32(writer, 1); // version
         writeUint32(writer, 0);
         writeUint32(writer, 0);
-        var length2Offset = writer.offset;
+        const length2Offset = writer.offset;
         writeInt32(writer, mask.top);
         writeInt32(writer, mask.left);
         writeInt32(writer, mask.bottom);
         writeInt32(writer, mask.right);
         writeInt32(writer, mask.depth);
-        var maxChannels = Math.max(0, mask.channels.length - 2);
+        const maxChannels = Math.max(0, mask.channels.length - 2);
         writeInt32(writer, maxChannels);
-        for (var i = 0; i < (maxChannels + 2); i++) {
-            var channel = mask.channels[i];
+        for (let i = 0; i < (maxChannels + 2); i++) {
+            const channel = mask.channels[i];
             writeInt32(writer, channel ? 1 : 0);
             if (channel) {
                 writeUint32(writer, 0);
@@ -3342,7 +3305,7 @@ addHandler('FEid', hasKey('filterEffectsMasks'), function (reader, target, leftB
             }
         }
         writer.view.setUint32(length2Offset - 4, writer.offset - length2Offset, false);
-        var extra = (_a = target.filterEffectsMasks[target.filterEffectsMasks.length - 1]) === null || _a === void 0 ? void 0 : _a.extra;
+        const extra = (_a = target.filterEffectsMasks[target.filterEffectsMasks.length - 1]) === null || _a === void 0 ? void 0 : _a.extra;
         if (extra) {
             writeUint8(writer, 1);
             writeInt32(writer, extra.top);
@@ -3354,29 +3317,29 @@ addHandler('FEid', hasKey('filterEffectsMasks'), function (reader, target, leftB
             writeUint16(writer, extra.compressionMode);
             writeBytes(writer, extra.data);
         }
-        var length_3 = writer.offset - lengthOffset;
-        writer.view.setUint32(lengthOffset - 4, length_3, false);
-        while (length_3 % 4) {
+        let length = writer.offset - lengthOffset;
+        writer.view.setUint32(lengthOffset - 4, length, false);
+        while (length % 4) {
             writeZeros(writer, 1);
-            length_3++;
+            length++;
         }
     }
 });
 addHandlerAlias('FXid', 'FEid');
-addHandler('FMsk', hasKey('filterMask'), function (reader, target) {
+addHandler('FMsk', hasKey('filterMask'), (reader, target) => {
     target.filterMask = {
         colorSpace: readColor(reader),
         opacity: readUint16(reader) / 0xff,
     };
-}, function (writer, target) {
+}, (writer, target) => {
     var _a;
     writeColor(writer, target.filterMask.colorSpace);
     writeUint16(writer, clamp((_a = target.filterMask.opacity) !== null && _a !== void 0 ? _a : 1, 0, 1) * 0xff);
 });
 addHandler('artd', // document-wide artboard info
-function (// document-wide artboard info
-target) { return target.artboards !== undefined; }, function (reader, target, left) {
-    var desc = readVersionAndDescriptor(reader);
+// document-wide artboard info
+target => target.artboards !== undefined, (reader, target, left) => {
+    const desc = readVersionAndDescriptor(reader);
     target.artboards = {
         count: desc['Cnt '],
         autoExpandOffset: { horizontal: desc.autoExpandOffset.Hrzn, vertical: desc.autoExpandOffset.Vrtc },
@@ -3389,10 +3352,10 @@ target) { return target.artboards !== undefined; }, function (reader, target, le
         docDefaultNewArtboardBackgroundType: desc.docDefaultNewArtboardBackgroundType,
     };
     skipBytes(reader, left());
-}, function (writer, target) {
+}, (writer, target) => {
     var _a, _b, _c, _d, _e;
-    var artb = target.artboards;
-    var desc = {
+    const artb = target.artboards;
+    const desc = {
         'Cnt ': artb.count,
         autoExpandOffset: artb.autoExpandOffset ? { Hrzn: artb.autoExpandOffset.horizontal, Vrtc: artb.autoExpandOffset.vertical } : { Hrzn: 0, Vrtc: 0 },
         origin: artb.origin ? { Hrzn: artb.origin.horizontal, Vrtc: artb.origin.vertical } : { Hrzn: 0, Vrtc: 0 },
@@ -3406,26 +3369,26 @@ target) { return target.artboards !== undefined; }, function (reader, target, le
     writeVersionAndDescriptor(writer, '', 'null', desc, 'artd');
 });
 export function hasMultiEffects(effects) {
-    return Object.keys(effects).map(function (key) { return effects[key]; }).some(function (v) { return Array.isArray(v) && v.length > 1; });
+    return Object.keys(effects).map(key => effects[key]).some(v => Array.isArray(v) && v.length > 1);
 }
-addHandler('lfx2', function (target) { return target.effects !== undefined && !hasMultiEffects(target.effects); }, function (reader, target, left) {
-    var version = readUint32(reader);
+addHandler('lfx2', target => target.effects !== undefined && !hasMultiEffects(target.effects), (reader, target, left) => {
+    const version = readUint32(reader);
     if (version !== 0)
-        throw new Error("Invalid lfx2 version");
-    var desc = readVersionAndDescriptor(reader);
+        throw new Error(`Invalid lfx2 version`);
+    const desc = readVersionAndDescriptor(reader);
     // console.log('READ', require('util').inspect(desc, false, 99, true));
     // TODO: don't discard if we got it from lmfx
     // discard if read in 'lrFX' section
     target.effects = parseEffects(desc, !!reader.logMissingFeatures);
     skipBytes(reader, left());
-}, function (writer, target, _, options) {
-    var desc = serializeEffects(target.effects, !!options.logMissingFeatures, true);
+}, (writer, target, _, options) => {
+    const desc = serializeEffects(target.effects, !!options.logMissingFeatures, true);
     // console.log('WRITE', require('util').inspect(desc, false, 99, true));
     writeUint32(writer, 0); // version
     writeVersionAndDescriptor(writer, '', 'null', desc);
 });
-addHandler('cinf', hasKey('compositorUsed'), function (reader, target, left) {
-    var desc = readVersionAndDescriptor(reader);
+addHandler('cinf', hasKey('compositorUsed'), (reader, target, left) => {
+    const desc = readVersionAndDescriptor(reader);
     // console.log(require('util').inspect(desc, false, 99, true));
     function enumValue(desc) {
         return desc.split('.')[1];
@@ -3450,61 +3413,60 @@ addHandler('cinf', hasKey('compositorUsed'), function (reader, target, left) {
     if (desc.compCoreGPUSupport)
         target.compositorUsed.compCoreGPUSupport = enumValue(desc.compCoreGPUSupport);
     skipBytes(reader, left());
-}, function (writer, target) {
-    var cinf = target.compositorUsed;
-    var desc = {
+}, (writer, target) => {
+    const cinf = target.compositorUsed;
+    const desc = {
         Vrsn: cinf.version || { major: 1, minor: 0, fix: 0 },
     };
     if (cinf.photoshopVersion)
         desc.psVersion = cinf.photoshopVersion;
     desc.description = cinf.description;
     desc.reason = cinf.reason;
-    desc.Engn = "Engn.".concat(cinf.engine);
+    desc.Engn = `Engn.${cinf.engine}`;
     if (cinf.enableCompCore)
-        desc.enableCompCore = "enable.".concat(cinf.enableCompCore);
+        desc.enableCompCore = `enable.${cinf.enableCompCore}`;
     if (cinf.enableCompCoreGPU)
-        desc.enableCompCoreGPU = "enable.".concat(cinf.enableCompCoreGPU);
+        desc.enableCompCoreGPU = `enable.${cinf.enableCompCoreGPU}`;
     if (cinf.enableCompCoreThreads)
-        desc.enableCompCoreThreads = "enable.".concat(cinf.enableCompCoreThreads);
+        desc.enableCompCoreThreads = `enable.${cinf.enableCompCoreThreads}`;
     if (cinf.compCoreSupport)
-        desc.compCoreSupport = "reason.".concat(cinf.compCoreSupport);
+        desc.compCoreSupport = `reason.${cinf.compCoreSupport}`;
     if (cinf.compCoreGPUSupport)
-        desc.compCoreGPUSupport = "reason.".concat(cinf.compCoreGPUSupport);
+        desc.compCoreGPUSupport = `reason.${cinf.compCoreGPUSupport}`;
     writeVersionAndDescriptor(writer, '', 'null', desc);
 });
 // extension settings ?, ignore it
-addHandler('extn', function (target) { return target._extn !== undefined; }, function (reader, target) {
-    var desc = readVersionAndDescriptor(reader);
+addHandler('extn', target => target._extn !== undefined, (reader, target) => {
+    const desc = readVersionAndDescriptor(reader);
     // console.log(require('util').inspect(desc, false, 99, true));
     if (MOCK_HANDLERS)
         target._extn = desc;
-}, function (writer, target) {
+}, (writer, target) => {
     // TODO: need to add correct types for desc fields (resources/src.psd)
     if (MOCK_HANDLERS)
         writeVersionAndDescriptor(writer, '', 'null', target._extn);
 });
-addHandler('iOpa', hasKey('fillOpacity'), function (reader, target) {
+addHandler('iOpa', hasKey('fillOpacity'), (reader, target) => {
     target.fillOpacity = readUint8(reader) / 0xff;
     skipBytes(reader, 3);
-}, function (writer, target) {
+}, (writer, target) => {
     writeUint8(writer, target.fillOpacity * 0xff);
     writeZeros(writer, 3);
 });
-addHandler('brst', hasKey('channelBlendingRestrictions'), function (reader, target, left) {
+addHandler('brst', hasKey('channelBlendingRestrictions'), (reader, target, left) => {
     target.channelBlendingRestrictions = [];
     while (left() > 4) {
         target.channelBlendingRestrictions.push(readInt32(reader));
     }
-}, function (writer, target) {
-    for (var _i = 0, _a = target.channelBlendingRestrictions; _i < _a.length; _i++) {
-        var channel = _a[_i];
+}, (writer, target) => {
+    for (const channel of target.channelBlendingRestrictions) {
         writeInt32(writer, channel);
     }
 });
-addHandler('tsly', hasKey('transparencyShapesLayer'), function (reader, target) {
+addHandler('tsly', hasKey('transparencyShapesLayer'), (reader, target) => {
     target.transparencyShapesLayer = !!readUint8(reader);
     skipBytes(reader, 3);
-}, function (writer, target) {
+}, (writer, target) => {
     writeUint8(writer, target.transparencyShapesLayer ? 1 : 0);
     writeZeros(writer, 3);
 });