ag-psd 15.1.0 → 15.3.0

package/dist/bundle.js

@@ -346,13 +346,15 @@ addHandler('TySh', hasKey('text'), function (reader, target, leftBytes) {
         },
     };
     if (text.EngineData) {
-        var engineData = (0, text_1.decodeEngineData)((0, engineData_1.parseEngineData)(text.EngineData));
+        var engineData = (0, engineData_1.parseEngineData)(text.EngineData);
+        var textData = (0, text_1.decodeEngineData)(engineData);
+        // require('fs').writeFileSync(`layer-${target.name}.txt`, require('util').inspect(engineData, false, 99, false), 'utf8');
         // const before = parseEngineData(text.EngineData);
         // const after = encodeEngineData(engineData);
         // 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), engineData);
+        target.text = __assign(__assign({}, target.text), textData);
         // console.log(require('util').inspect(target.text, false, 99, true));
     }
     (0, psdReader_1.skipBytes)(reader, leftBytes());
@@ -1134,6 +1136,173 @@ addHandler('PlLd', hasKey('placedLayer'), function (reader, target, left) {
     var type = isQuilt ? 'quiltWarp' : 'warp';
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', type, encodeWarp(placed.warp || {}), type);
 });
+function uint8ToFloat32(array) {
+    return new Float32Array(array.buffer.slice(array.byteOffset), 0, array.byteLength / 4);
+}
+function uint8ToUint32(array) {
+    return new Uint32Array(array.buffer.slice(array.byteOffset), 0, array.byteLength / 4);
+}
+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) {
+        points.push({ x: array[i], y: array[i + 1] });
+    }
+    return points;
+}
+function pointsToArray(points) {
+    var array = [];
+    for (var i = 0; i < points.length; i++) {
+        array.push(points[i].x, points[i].y);
+    }
+    return array;
+}
+function uin8ToPoints(array) {
+    return arrayToPoints(uint8ToFloat32(array));
+}
+function hrznVrtcToPoint(desc) {
+    return {
+        x: (0, descriptor_1.parseUnits)(desc.Hrzn),
+        y: (0, descriptor_1.parseUnits)(desc.Vrtc),
+    };
+}
+function pointToHrznVrtc(point) {
+    return {
+        Hrzn: (0, descriptor_1.unitsValue)(point.x, 'x'),
+        Vrtc: (0, descriptor_1.unitsValue)(point.y, 'y'),
+    };
+}
+function parseFilterFX(desc) {
+    return {
+        enabled: desc.enab,
+        validAtPosition: desc.validAtPosition,
+        maskEnabled: desc.filterMaskEnable,
+        maskLinked: desc.filterMaskLinked,
+        maskExtendWithWhite: desc.filterMaskExtendWithWhite,
+        list: desc.filterFXList.map(function (f) { return ({
+            id: f.filterID,
+            name: f['Nm  '],
+            opacity: (0, descriptor_1.parsePercent)(f.blendOptions.Opct),
+            blendMode: descriptor_1.BlnM.decode(f.blendOptions['Md  ']),
+            enabled: f.enab,
+            hasOptions: f.hasoptions,
+            foregroundColor: (0, descriptor_1.parseColor)(f.FrgC),
+            backgroundColor: (0, descriptor_1.parseColor)(f.BckC),
+            filter: {
+                rigidType: f.Fltr.rigidType,
+                bounds: [
+                    { x: f.Fltr.PuX0, y: f.Fltr.PuY0, },
+                    { x: f.Fltr.PuX1, y: f.Fltr.PuY1, },
+                    { x: f.Fltr.PuX2, y: f.Fltr.PuY2, },
+                    { x: f.Fltr.PuX3, y: f.Fltr.PuY3, },
+                ],
+                puppetShapeList: f.Fltr.puppetShapeList.map(function (p) { return ({
+                    rigidType: p.rigidType,
+                    // TODO: VrsM
+                    // TODO: VrsN
+                    originalVertexArray: uin8ToPoints(p.originalVertexArray),
+                    deformedVertexArray: uin8ToPoints(p.deformedVertexArray),
+                    indexArray: Array.from(uint8ToUint32(p.indexArray)),
+                    pinOffsets: arrayToPoints(p.pinOffsets),
+                    posFinalPins: arrayToPoints(p.posFinalPins),
+                    pinVertexIndices: p.pinVertexIndices,
+                    selectedPin: p.selectedPin,
+                    pinPosition: arrayToPoints(p.PinP),
+                    pinRotation: p.PnRt,
+                    pinOverlay: p.PnOv,
+                    pinDepth: p.PnDp,
+                    meshQuality: p.meshQuality,
+                    meshExpansion: p.meshExpansion,
+                    meshRigidity: p.meshRigidity,
+                    imageResolution: p.imageResolution,
+                    meshBoundaryPath: {
+                        pathComponents: p.meshBoundaryPath.pathComponents.map(function (c) { return ({
+                            shapeOperation: c.shapeOperation.split('.')[1],
+                            paths: c.SbpL.map(function (t) { return ({
+                                closed: t.Clsp,
+                                points: t['Pts '].map(function (pt) { return ({
+                                    anchor: hrznVrtcToPoint(pt.Anch),
+                                    forward: hrznVrtcToPoint(pt['Fwd ']),
+                                    backward: hrznVrtcToPoint(pt['Bwd ']),
+                                    smooth: pt.Smoo,
+                                }); }),
+                            }); }),
+                        }); }),
+                    },
+                }); }),
+            },
+        }); }),
+    };
+}
+function serializeFilterFX(filter) {
+    return {
+        enab: filter.enabled,
+        validAtPosition: filter.validAtPosition,
+        filterMaskEnable: filter.maskEnabled,
+        filterMaskLinked: filter.maskLinked,
+        filterMaskExtendWithWhite: filter.maskExtendWithWhite,
+        filterFXList: filter.list.map(function (f) { return ({
+            'Nm  ': f.name,
+            blendOptions: {
+                Opct: (0, descriptor_1.unitsPercent)(f.opacity),
+                'Md  ': descriptor_1.BlnM.encode(f.blendMode),
+            },
+            enab: f.enabled,
+            hasoptions: f.hasOptions,
+            FrgC: (0, descriptor_1.serializeColor)(f.foregroundColor),
+            BckC: (0, descriptor_1.serializeColor)(f.backgroundColor),
+            Fltr: {
+                'null': ['Ordn.Trgt'],
+                rigidType: f.filter.rigidType,
+                puppetShapeList: f.filter.puppetShapeList.map(function (p) { return ({
+                    rigidType: p.rigidType,
+                    VrsM: 1,
+                    VrsN: 0,
+                    originalVertexArray: toUint8(new Float32Array(pointsToArray(p.originalVertexArray))),
+                    deformedVertexArray: toUint8(new Float32Array(pointsToArray(p.deformedVertexArray))),
+                    indexArray: toUint8(new Uint32Array(p.indexArray)),
+                    pinOffsets: pointsToArray(p.pinOffsets),
+                    posFinalPins: pointsToArray(p.posFinalPins),
+                    selectedPin: p.selectedPin,
+                    pinVertexIndices: p.pinVertexIndices,
+                    PinP: pointsToArray(p.pinPosition),
+                    PnRt: p.pinRotation,
+                    PnOv: p.pinOverlay,
+                    PnDp: p.pinDepth,
+                    meshQuality: p.meshQuality,
+                    meshExpansion: p.meshExpansion,
+                    meshRigidity: p.meshRigidity,
+                    imageResolution: p.imageResolution,
+                    meshBoundaryPath: {
+                        pathComponents: p.meshBoundaryPath.pathComponents.map(function (c) { return ({
+                            shapeOperation: "shapeOperation.".concat(c.shapeOperation),
+                            SbpL: c.paths.map(function (path) { return ({
+                                Clsp: path.closed,
+                                'Pts ': path.points.map(function (pt) { return ({
+                                    Anch: pointToHrznVrtc(pt.anchor),
+                                    'Fwd ': pointToHrznVrtc(pt.forward),
+                                    'Bwd ': pointToHrznVrtc(pt.backward),
+                                    Smoo: pt.smooth,
+                                }); }),
+                            }); }),
+                        }); }),
+                    },
+                }); }),
+                PuX0: f.filter.bounds[0].x,
+                PuX1: f.filter.bounds[1].x,
+                PuX2: f.filter.bounds[2].x,
+                PuX3: f.filter.bounds[3].x,
+                PuY0: f.filter.bounds[0].y,
+                PuY1: f.filter.bounds[1].y,
+                PuY2: f.filter.bounds[2].y,
+                PuY3: f.filter.bounds[3].y,
+            },
+            filterID: f.id,
+        }); }),
+    };
+}
 addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
     if ((0, psdReader_1.readSignature)(reader) !== 'soLD')
         throw new Error("Invalid SoLd type");
@@ -1144,6 +1313,8 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
     // 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));
+    // desc.filterFX!.filterFXList[0].Fltr.puppetShapeList[0].meshBoundaryPath.pathComponents[0].SbpL[0]['Pts '] = [];
+    // console.log('filterFX', require('util').inspect(desc.filterFX, false, 99, true));
     target.placedLayer = {
         id: desc.Idnt,
         placed: desc.placed,
@@ -1168,6 +1339,8 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
         target.placedLayer.comp = desc.comp;
     if (desc.compInfo)
         target.placedLayer.compInfo = desc.compInfo;
+    if (desc.filterFX)
+        target.placedLayer.filter = parseFilterFX(desc.filterFX);
     (0, psdReader_1.skipBytes)(reader, left()); // HACK
 }, function (writer, target) {
     var _a, _b;
@@ -1178,6 +1351,8 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
             Wdth: placed.width || 0,
             Hght: placed.height || 0, // TODO: find size ?
         }, Rslt: placed.resolution ? (0, descriptor_1.unitsValue)(placed.resolution, 'resolution') : { units: 'Density', value: 72 } });
+    if (placed.filter)
+        desc.filterFX = serializeFilterFX(placed.filter);
     if (placed.warp && isQuiltWarp(placed.warp)) {
         var quiltWarp = encodeWarp(placed.warp);
         desc.quiltWarp = quiltWarp;
@@ -2289,6 +2464,87 @@ addHandler('tsly', hasKey('transparencyShapesLayer'), function (reader, target)
     (0, psdWriter_1.writeUint8)(writer, target.transparencyShapesLayer ? 1 : 0);
     (0, psdWriter_1.writeZeros)(writer, 3);
 });
+/*addHandler(
+    'FEid',
+    hasKey('filterEffects'),
+    (reader, _target) => {
+        const version = readInt32(reader);
+        if (version < 1 || version > 3) throw new Error(`Invalid filterEffects version ${version}`);
+
+        if (readUint32(reader)) throw new Error('filterEffects: 64 bit length is not supported');
+        const length = readUint32(reader);
+        const end = reader.offset + length;
+
+        while (reader.offset < end) {
+            console.log('bytes to go', end - reader.offset, 'at', reader.offset.toString(16));
+            //
+            const id = readPascalString(reader, 1);
+            const effectVersion = readInt32(reader);
+            if (effectVersion !== 1) 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;
+            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: any[] = [];
+
+            for (let i = 0; i < (maxChannels + 2); i++) {
+                const exists = readInt32(reader);
+                if (exists) {
+                    if (readUint32(reader)) throw new Error('filterEffect: 64 bit length is not supported');
+                    const channelLength = readUint32(reader);
+                    const compressionMode = readUint16(reader);
+                    const data = readBytes(reader, channelLength - 2);
+                    channels.push({ channelLength, compressionMode, data: data?.length + ' bytes' });
+                    // if (c < 3 || c == 25) e_ = _F.Cn(!0, rL, m, b.rect.F, b.rect.V, X, rp);
+                    // if (c == 0) _c.S = e_;
+                    // if (c == 1) _c.v = e_;
+                    // if (c == 2) _c.e = e_;
+                    // if (c == 25) _c.w = e_;
+                } else {
+                    channels.push(undefined);
+                }
+            }
+
+            console.log('left at the end', endOfEffect - reader.offset);
+            if (endOfEffect > reader.offset) {
+                if (readUint8(reader)) {
+                    const compressionMode = readUint16(reader);
+                    const data = endOfEffect > reader.offset ? readBytes(reader, endOfEffect - reader.offset) : undefined;
+                    console.log('extra data', { compressionMode, data: data?.length + ' bytes' });
+                } else {
+                    console.log('no extra');
+                }
+            }
+
+            console.log('effect', {
+                id,
+                effectVersion,
+                effectLength,
+                top,
+                left,
+                bottom,
+                right,
+                depth,
+                maxChannels,
+                channels,
+            });
+
+            console.log('bytes left after effect', endOfEffect - reader.offset);
+            // if (length % 4) skipBytes(reader, 4 - length % 4);
+        }
+
+        console.log({ version, length });
+    },
+    (_writer, _target) => {
+    },
+);
+
+addHandlerAlias('FXid', 'FEid');*/
 
 },{"./descriptor":4,"./effectsHelpers":5,"./engineData":6,"./helpers":7,"./psdReader":11,"./psdWriter":12,"./text":13,"base64-js":15}],3:[function(require,module,exports){
 "use strict";
@@ -2451,6 +2707,15 @@ var fieldToExtType = {
     'Lnk ': makeType('', 'ExternalFileLink'),
     frameReader: makeType('', 'FrameReader'),
     effectParams: makeType('', 'motionTrackEffectParams'),
+    Impr: makeType('None', 'none'),
+    Anch: makeType('', 'Pnt '),
+    'Fwd ': makeType('', 'Pnt '),
+    'Bwd ': makeType('', 'Pnt '),
+    meshBoundaryPath: makeType('', 'pathClass'),
+    filterFX: makeType('', 'filterFXStyle'),
+    Fltr: makeType('', 'rigidTransform'),
+    FrgC: makeType('', 'RGBC'),
+    BckC: makeType('', 'RGBC'),
 };
 var fieldToArrayExtType = {
     'Crv ': makeType('', 'CrPt'),
@@ -2474,6 +2739,11 @@ var fieldToArrayExtType = {
     countObjectList: makeType('', 'countObject'),
     countGroupList: makeType('', 'countGroup'),
     slices: makeType('', 'slice'),
+    'Pts ': makeType('', 'Pthp'),
+    SbpL: makeType('', 'SbpL'),
+    pathComponents: makeType('', 'PaCm'),
+    filterFXList: makeType('', 'filterFX'),
+    puppetShapeList: makeType('', 'puppetShape'),
 };
 var typeToField = {
     'TEXT': [
@@ -2482,7 +2752,7 @@ var typeToField = {
         'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
         'altTag', 'url', 'cellText',
     ],
-    'tdta': ['EngineData', 'LUT3DFileData'],
+    'tdta': ['EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray'],
     'long': [
         'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
         'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'presetKind', 'comp', 'compID', 'originalCompID',
@@ -2492,7 +2762,8 @@ var typeToField = {
         'numModifyingFX', 'deformNumRows', 'deformNumCols', 'FrID', 'FrDl', 'FsID', 'LCnt', 'AFrm', 'AFSt',
         'numBefore', 'numAfter', 'Spcn', 'minOpacity', 'maxOpacity', 'BlnM', 'sheetID', 'gblA', 'globalAltitude',
         'descVersion', 'frameReaderType', 'LyrI', 'zoomOrigin', 'fontSize', 'Rds ', 'sliceID',
-        'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset',
+        'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset', 'filterID', 'meshQuality',
+        'meshExpansion', 'meshRigidity', 'VrsM', 'VrsN',
     ],
     'enum': [
         'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS',
@@ -2501,7 +2772,7 @@ var typeToField = {
         'strokeStyleBlendMode', 'PntT', 'Styl', 'lookupType', 'LUTFormat', 'dataOrder',
         'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
         'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
-        'vertAlign', 'bgColorType',
+        'vertAlign', 'bgColorType', 'shapeOperation',
     ],
     'bool': [
         'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -2512,13 +2783,15 @@ var typeToField = {
         'autoExpandEnabled', 'autoNestEnabled', 'autoPositionEnabled', 'shrinkwrapOnSaveEnabled',
         'present', 'showInDialog', 'overprint', 'sheetDisclosed', 'lightsDisclosed', 'meshesDisclosed',
         'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
-        'cellTextIsHTML',
+        'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
+        'filterMaskLinked', 'filterMaskExtendWithWhite',
     ],
     'doub': [
         'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
         'strokeStyleMiterLimit', 'strokeStyleResolution', 'layerTime', 'keyOriginResolution',
         'xx', 'xy', 'yx', 'yy', 'tx', 'ty', 'FrGA', 'frameRate', 'audioLevel', 'rotation',
-        'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat',
+        'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat', 'imageResolution',
+        'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3'
     ],
     'UntF': [
         'Scl ', 'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
@@ -2531,7 +2804,8 @@ var typeToField = {
         'LaSt', 'Trnf', 'nonAffineTransform', 'keyDescriptorList', 'guideIndeces', 'gradientFillMulti',
         'solidFillMulti', 'frameFXMulti', 'innerShadowMulti', 'dropShadowMulti', 'FrIn', 'FSts', 'FsFr',
         'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
-        'warpValues',
+        'warpValues', 'selectedPin', 'Pts ', 'SbpL', 'pathComponents', 'pinOffsets', 'posFinalPins',
+        'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList',
     ],
     'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
     'obj ': ['null'],
@@ -2542,24 +2816,37 @@ var channels = [
 var fieldToArrayType = {
     'Mnm ': 'long',
     'Mxm ': 'long',
-    'FrLs': 'long',
-    'strokeStyleLineDashSet': 'UntF',
-    'Trnf': 'doub',
-    'nonAffineTransform': 'doub',
-    'keyDescriptorList': 'Objc',
-    'gradientFillMulti': 'Objc',
-    'solidFillMulti': 'Objc',
-    'frameFXMulti': 'Objc',
-    'innerShadowMulti': 'Objc',
-    'dropShadowMulti': 'Objc',
-    'LaSt': 'Objc',
-    'FrIn': 'Objc',
-    'FSts': 'Objc',
-    'FsFr': 'long',
-    'blendOptions': 'Objc',
-    'sheetTimelineOptions': 'Objc',
-    'keyList': 'Objc',
-    'warpValues': 'doub',
+    FrLs: 'long',
+    strokeStyleLineDashSet: 'UntF',
+    Trnf: 'doub',
+    nonAffineTransform: 'doub',
+    keyDescriptorList: 'Objc',
+    gradientFillMulti: 'Objc',
+    solidFillMulti: 'Objc',
+    frameFXMulti: 'Objc',
+    innerShadowMulti: 'Objc',
+    dropShadowMulti: 'Objc',
+    LaSt: 'Objc',
+    FrIn: 'Objc',
+    FSts: 'Objc',
+    FsFr: 'long',
+    blendOptions: 'Objc',
+    sheetTimelineOptions: 'Objc',
+    keyList: 'Objc',
+    warpValues: 'doub',
+    selectedPin: 'long',
+    'Pts ': 'Objc',
+    SbpL: 'Objc',
+    pathComponents: 'Objc',
+    pinOffsets: 'doub',
+    posFinalPins: 'doub',
+    pinVertexIndices: 'long',
+    PinP: 'doub',
+    PnRt: 'long',
+    PnOv: 'bool',
+    PnDp: 'doub',
+    filterFXList: 'Objc',
+    puppetShapeList: 'Objc',
 };
 var fieldToType = {};
 for (var _i = 0, _a = Object.keys(typeToField); _i < _a.length; _i++) {
@@ -2832,7 +3119,7 @@ function writeOSType(writer, type, value, key, extType, root) {
             for (var i = 0; i < value.length; i++) {
                 var type_3 = fieldToArrayType[key];
                 (0, psdWriter_1.writeSignature)(writer, type_3 || 'long');
-                writeOSType(writer, type_3 || 'long', value[i], '', fieldToArrayExtType[key], root);
+                writeOSType(writer, type_3 || 'long', value[i], "".concat(key, "[]"), fieldToArrayExtType[key], root);
                 if (logErrors && !type_3)
                     console.log("Missing descriptor array type for: '".concat(key, "' in"), value);
             }
@@ -8140,6 +8427,8 @@ function decodeEngineData(engineData) {
     for (var i = 0; i < styleRun.RunArray.length; i++) {
         var length_2 = styleRun.RunLengthArray[i];
         var style = decodeStyle(styleRun.RunArray[i].StyleSheet.StyleSheetData, fonts);
+        if (!style.font)
+            style.font = fonts[0];
         result.styleRuns.push({ length: length_2, style: style });
     }
     for (var counter = removedCharacters; result.styleRuns.length && counter > 0; counter--) {

package/dist/descriptor.js

@@ -109,6 +109,15 @@ var fieldToExtType = {
     'Lnk ': makeType('', 'ExternalFileLink'),
     frameReader: makeType('', 'FrameReader'),
     effectParams: makeType('', 'motionTrackEffectParams'),
+    Impr: makeType('None', 'none'),
+    Anch: makeType('', 'Pnt '),
+    'Fwd ': makeType('', 'Pnt '),
+    'Bwd ': makeType('', 'Pnt '),
+    meshBoundaryPath: makeType('', 'pathClass'),
+    filterFX: makeType('', 'filterFXStyle'),
+    Fltr: makeType('', 'rigidTransform'),
+    FrgC: makeType('', 'RGBC'),
+    BckC: makeType('', 'RGBC'),
 };
 var fieldToArrayExtType = {
     'Crv ': makeType('', 'CrPt'),
@@ -132,6 +141,11 @@ var fieldToArrayExtType = {
     countObjectList: makeType('', 'countObject'),
     countGroupList: makeType('', 'countGroup'),
     slices: makeType('', 'slice'),
+    'Pts ': makeType('', 'Pthp'),
+    SbpL: makeType('', 'SbpL'),
+    pathComponents: makeType('', 'PaCm'),
+    filterFXList: makeType('', 'filterFX'),
+    puppetShapeList: makeType('', 'puppetShape'),
 };
 var typeToField = {
     'TEXT': [
@@ -140,7 +154,7 @@ var typeToField = {
         'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
         'altTag', 'url', 'cellText',
     ],
-    'tdta': ['EngineData', 'LUT3DFileData'],
+    'tdta': ['EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray'],
     'long': [
         'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
         'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'presetKind', 'comp', 'compID', 'originalCompID',
@@ -150,7 +164,8 @@ var typeToField = {
         'numModifyingFX', 'deformNumRows', 'deformNumCols', 'FrID', 'FrDl', 'FsID', 'LCnt', 'AFrm', 'AFSt',
         'numBefore', 'numAfter', 'Spcn', 'minOpacity', 'maxOpacity', 'BlnM', 'sheetID', 'gblA', 'globalAltitude',
         'descVersion', 'frameReaderType', 'LyrI', 'zoomOrigin', 'fontSize', 'Rds ', 'sliceID',
-        'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset',
+        'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset', 'filterID', 'meshQuality',
+        'meshExpansion', 'meshRigidity', 'VrsM', 'VrsN',
     ],
     'enum': [
         'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS',
@@ -159,7 +174,7 @@ var typeToField = {
         'strokeStyleBlendMode', 'PntT', 'Styl', 'lookupType', 'LUTFormat', 'dataOrder',
         'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
         'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
-        'vertAlign', 'bgColorType',
+        'vertAlign', 'bgColorType', 'shapeOperation',
     ],
     'bool': [
         'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -170,13 +185,15 @@ var typeToField = {
         'autoExpandEnabled', 'autoNestEnabled', 'autoPositionEnabled', 'shrinkwrapOnSaveEnabled',
         'present', 'showInDialog', 'overprint', 'sheetDisclosed', 'lightsDisclosed', 'meshesDisclosed',
         'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
-        'cellTextIsHTML',
+        'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
+        'filterMaskLinked', 'filterMaskExtendWithWhite',
     ],
     'doub': [
         'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
         'strokeStyleMiterLimit', 'strokeStyleResolution', 'layerTime', 'keyOriginResolution',
         'xx', 'xy', 'yx', 'yy', 'tx', 'ty', 'FrGA', 'frameRate', 'audioLevel', 'rotation',
-        'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat',
+        'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat', 'imageResolution',
+        'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3'
     ],
     'UntF': [
         'Scl ', 'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
@@ -189,7 +206,8 @@ var typeToField = {
         'LaSt', 'Trnf', 'nonAffineTransform', 'keyDescriptorList', 'guideIndeces', 'gradientFillMulti',
         'solidFillMulti', 'frameFXMulti', 'innerShadowMulti', 'dropShadowMulti', 'FrIn', 'FSts', 'FsFr',
         'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
-        'warpValues',
+        'warpValues', 'selectedPin', 'Pts ', 'SbpL', 'pathComponents', 'pinOffsets', 'posFinalPins',
+        'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList',
     ],
     'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
     'obj ': ['null'],
@@ -200,24 +218,37 @@ var channels = [
 var fieldToArrayType = {
     'Mnm ': 'long',
     'Mxm ': 'long',
-    'FrLs': 'long',
-    'strokeStyleLineDashSet': 'UntF',
-    'Trnf': 'doub',
-    'nonAffineTransform': 'doub',
-    'keyDescriptorList': 'Objc',
-    'gradientFillMulti': 'Objc',
-    'solidFillMulti': 'Objc',
-    'frameFXMulti': 'Objc',
-    'innerShadowMulti': 'Objc',
-    'dropShadowMulti': 'Objc',
-    'LaSt': 'Objc',
-    'FrIn': 'Objc',
-    'FSts': 'Objc',
-    'FsFr': 'long',
-    'blendOptions': 'Objc',
-    'sheetTimelineOptions': 'Objc',
-    'keyList': 'Objc',
-    'warpValues': 'doub',
+    FrLs: 'long',
+    strokeStyleLineDashSet: 'UntF',
+    Trnf: 'doub',
+    nonAffineTransform: 'doub',
+    keyDescriptorList: 'Objc',
+    gradientFillMulti: 'Objc',
+    solidFillMulti: 'Objc',
+    frameFXMulti: 'Objc',
+    innerShadowMulti: 'Objc',
+    dropShadowMulti: 'Objc',
+    LaSt: 'Objc',
+    FrIn: 'Objc',
+    FSts: 'Objc',
+    FsFr: 'long',
+    blendOptions: 'Objc',
+    sheetTimelineOptions: 'Objc',
+    keyList: 'Objc',
+    warpValues: 'doub',
+    selectedPin: 'long',
+    'Pts ': 'Objc',
+    SbpL: 'Objc',
+    pathComponents: 'Objc',
+    pinOffsets: 'doub',
+    posFinalPins: 'doub',
+    pinVertexIndices: 'long',
+    PinP: 'doub',
+    PnRt: 'long',
+    PnOv: 'bool',
+    PnDp: 'doub',
+    filterFXList: 'Objc',
+    puppetShapeList: 'Objc',
 };
 var fieldToType = {};
 for (var _i = 0, _a = Object.keys(typeToField); _i < _a.length; _i++) {
@@ -490,7 +521,7 @@ function writeOSType(writer, type, value, key, extType, root) {
             for (var i = 0; i < value.length; i++) {
                 var type_3 = fieldToArrayType[key];
                 (0, psdWriter_1.writeSignature)(writer, type_3 || 'long');
-                writeOSType(writer, type_3 || 'long', value[i], '', fieldToArrayExtType[key], root);
+                writeOSType(writer, type_3 || 'long', value[i], "".concat(key, "[]"), fieldToArrayExtType[key], root);
                 if (logErrors && !type_3)
                     console.log("Missing descriptor array type for: '".concat(key, "' in"), value);
             }