ag-psd 16.0.0 → 17.0.0

package/dist-es/psd.d.ts

@@ -659,86 +659,444 @@ export interface LinkedFile {
     assetModTime?: number;
     assetLockedState?: number;
 }
-export interface PlacedLayerPuppetFilter {
-    rigidType: boolean;
-    bounds: {
-        x: number;
-        y: number;
-    }[];
-    puppetShapeList: {
-        rigidType: boolean;
-        originalVertexArray: {
-            x: number;
-            y: number;
-        }[];
-        deformedVertexArray: {
+type FilterVariant = {
+    type: 'average' | 'blur' | 'blur more';
+} | {
+    type: 'box blur';
+    filter: {
+        radius: UnitsValue;
+    };
+} | {
+    type: 'gaussian blur';
+    filter: {
+        radius: UnitsValue;
+    };
+} | {
+    type: 'motion blur';
+    filter: {
+        angle: number;
+        distance: UnitsValue;
+    };
+} | {
+    type: 'radial blur';
+    filter: {
+        amount: number;
+        method: 'spin' | 'zoom';
+        quality: 'draft' | 'good' | 'best';
+    };
+} | {
+    type: 'shape blur';
+    filter: {
+        radius: UnitsValue;
+        customShape: {
+            name: string;
+            id: string;
+        };
+    };
+} | {
+    type: 'smart blur';
+    filter: {
+        radius: number;
+        threshold: number;
+        quality: 'low' | 'medium' | 'high';
+        mode: 'normal' | 'edge only' | 'overlay edge';
+    };
+} | {
+    type: 'surface blur';
+    filter: {
+        radius: UnitsValue;
+        threshold: number;
+    };
+} | {
+    type: 'displace';
+    filter: {
+        horizontalScale: number;
+        verticalScale: number;
+        displacementMap: 'stretch to fit' | 'tile';
+        undefinedAreas: 'wrap around' | 'repeat edge pixels';
+        displacementFile: {
+            signature: string;
+            path: string;
+        };
+    };
+} | {
+    type: 'pinch';
+    filter: {
+        amount: number;
+    };
+} | {
+    type: 'polar coordinates';
+    filter: {
+        conversion: 'rectangular to polar' | 'polar to rectangular';
+    };
+} | {
+    type: 'ripple';
+    filter: {
+        amount: number;
+        size: 'small' | 'medium' | 'large';
+    };
+} | {
+    type: 'shear';
+    filter: {
+        shearPoints: {
             x: number;
             y: number;
         }[];
-        indexArray: number[];
-        pinOffsets: {
+        shearStart: number;
+        shearEnd: number;
+        undefinedAreas: 'wrap around' | 'repeat edge pixels';
+    };
+} | {
+    type: 'spherize';
+    filter: {
+        amount: number;
+        mode: 'normal' | 'horizontal only' | 'vertical only';
+    };
+} | {
+    type: 'twirl';
+    filter: {
+        angle: number;
+    };
+} | {
+    type: 'wave';
+    filter: {
+        numberOfGenerators: number;
+        type: 'sine' | 'triangle' | 'square';
+        wavelength: {
+            min: number;
+            max: number;
+        };
+        amplitude: {
+            min: number;
+            max: number;
+        };
+        scale: {
             x: number;
             y: number;
+        };
+        randomSeed: number;
+        undefinedAreas: 'wrap around' | 'repeat edge pixels';
+    };
+} | {
+    type: 'zigzag';
+    filter: {
+        amount: number;
+        ridges: number;
+        style: 'around center' | 'out from center' | 'pond ripples';
+    };
+} | {
+    type: 'add noise';
+    filter: {
+        amount: number;
+        distribution: 'uniform' | 'gaussian';
+        monochromatic: boolean;
+        randomSeed: number;
+    };
+} | {
+    type: 'despeckle';
+} | {
+    type: 'dust and scratches';
+    filter: {
+        radius: number;
+        threshold: number;
+    };
+} | {
+    type: 'median';
+    filter: {
+        radius: UnitsValue;
+    };
+} | {
+    type: 'reduce noise';
+    filter: {
+        preset: string;
+        removeJpegArtifact: boolean;
+        reduceColorNoise: number;
+        sharpenDetails: number;
+        channelDenoise: {
+            channels: ('red' | 'green' | 'blue' | 'composite')[];
+            amount: number;
+            preserveDetails?: number;
         }[];
-        posFinalPins: {
+    };
+} | {
+    type: 'color halftone';
+    filter: {
+        radius: number;
+        angle1: number;
+        angle2: number;
+        angle3: number;
+        angle4: number;
+    };
+} | {
+    type: 'crystallize';
+    filter: {
+        cellSize: number;
+        randomSeed: number;
+    };
+} | {
+    type: 'facet' | 'fragment';
+} | {
+    type: 'mezzotint';
+    filter: {
+        type: 'fine dots' | 'medium dots' | 'grainy dots' | 'coarse dots' | 'short lines' | 'medium lines' | 'long lines' | 'short strokes' | 'medium strokes' | 'long strokes';
+        randomSeed: number;
+    };
+} | {
+    type: 'mosaic';
+    filter: {
+        cellSize: UnitsValue;
+    };
+} | {
+    type: 'pointillize';
+    filter: {
+        cellSize: number;
+        randomSeed: number;
+    };
+} | {
+    type: 'clouds';
+    filter: {
+        randomSeed: number;
+    };
+} | {
+    type: 'difference clouds';
+    filter: {
+        randomSeed: number;
+    };
+} | {
+    type: 'fibers';
+    filter: {
+        variance: number;
+        strength: number;
+        randomSeed: number;
+    };
+} | {
+    type: 'lens flare';
+    filter: {
+        brightness: number;
+        position: {
             x: number;
             y: number;
-        }[];
-        pinVertexIndices: number[];
-        selectedPin: number[];
-        pinPosition: {
+        };
+        lensType: '50-300mm zoom' | '32mm prime' | '105mm prime' | 'movie prime';
+    };
+} | {
+    type: 'sharpen' | 'sharpen edges' | 'sharpen more';
+} | {
+    type: 'smart sharpen';
+    filter: {
+        amount: number;
+        radius: UnitsValue;
+        threshold: number;
+        angle: number;
+        moreAccurate: boolean;
+        blur: 'gaussian blur' | 'lens blur' | 'motion blur';
+        preset: string;
+        shadow: {
+            fadeAmount: number;
+            tonalWidth: number;
+            radius: number;
+        };
+        highlight: {
+            fadeAmount: number;
+            tonalWidth: number;
+            radius: number;
+        };
+    };
+} | {
+    type: 'unsharp mask';
+    filter: {
+        amount: number;
+        radius: UnitsValue;
+        threshold: number;
+    };
+} | {
+    type: 'diffuse';
+    filter: {
+        mode: 'normal' | 'darken only' | 'lighten only' | 'anisotropic';
+        randomSeed: number;
+    };
+} | {
+    type: 'emboss';
+    filter: {
+        angle: number;
+        height: number;
+        amount: number;
+    };
+} | {
+    type: 'extrude';
+    filter: {
+        type: 'blocks' | 'pyramids';
+        size: number;
+        depth: number;
+        depthMode: 'random' | 'level-based';
+        randomSeed: number;
+        solidFrontFaces: boolean;
+        maskIncompleteBlocks: boolean;
+    };
+} | {
+    type: 'find edges' | 'solarize';
+} | {
+    type: 'tiles';
+    filter: {
+        numberOfTiles: number;
+        maximumOffset: number;
+        fillEmptyAreaWith: 'background color' | 'foreground color' | 'inverse image' | 'unaltered image';
+        randomSeed: number;
+    };
+} | {
+    type: 'trace contour';
+    filter: {
+        level: number;
+        edge: 'lower' | 'upper';
+    };
+} | {
+    type: 'wind';
+    filter: {
+        method: 'wind' | 'blast' | 'stagger';
+        direction: 'left' | 'right';
+    };
+} | {
+    type: 'de-interlace';
+    filter: {
+        eliminate: 'odd lines' | 'even lines';
+        newFieldsBy: 'duplication' | 'interpolation';
+    };
+} | {
+    type: 'ntsc colors';
+} | {
+    type: 'custom';
+    filter: {
+        scale: number;
+        offset: number;
+        matrix: number[];
+    };
+} | {
+    type: 'high pass' | 'maximum' | 'minimum';
+    filter: {
+        radius: UnitsValue;
+    };
+} | {
+    type: 'offset';
+    filter: {
+        horizontal: number;
+        vertical: number;
+        undefinedAreas: 'set to transparent' | 'repeat edge pixels' | 'wrap around';
+    };
+} | {
+    type: 'puppet';
+    filter: {
+        rigidType: boolean;
+        bounds: {
             x: number;
             y: number;
         }[];
-        pinRotation: number[];
-        pinOverlay: boolean[];
-        pinDepth: number[];
-        meshQuality: number;
-        meshExpansion: number;
-        meshRigidity: number;
-        imageResolution: number;
-        meshBoundaryPath: {
-            pathComponents: {
-                shapeOperation: string;
-                paths: {
-                    closed: boolean;
-                    points: {
-                        anchor: {
-                            x: UnitsValue;
-                            y: UnitsValue;
-                        };
-                        forward: {
-                            x: UnitsValue;
-                            y: UnitsValue;
-                        };
-                        backward: {
-                            x: UnitsValue;
-                            y: UnitsValue;
-                        };
-                        smooth: boolean;
+        puppetShapeList: {
+            rigidType: boolean;
+            originalVertexArray: {
+                x: number;
+                y: number;
+            }[];
+            deformedVertexArray: {
+                x: number;
+                y: number;
+            }[];
+            indexArray: number[];
+            pinOffsets: {
+                x: number;
+                y: number;
+            }[];
+            posFinalPins: {
+                x: number;
+                y: number;
+            }[];
+            pinVertexIndices: number[];
+            selectedPin: number[];
+            pinPosition: {
+                x: number;
+                y: number;
+            }[];
+            pinRotation: number[];
+            pinOverlay: boolean[];
+            pinDepth: number[];
+            meshQuality: number;
+            meshExpansion: number;
+            meshRigidity: number;
+            imageResolution: number;
+            meshBoundaryPath: {
+                pathComponents: {
+                    shapeOperation: string;
+                    paths: {
+                        closed: boolean;
+                        points: {
+                            anchor: {
+                                x: UnitsValue;
+                                y: UnitsValue;
+                            };
+                            forward: {
+                                x: UnitsValue;
+                                y: UnitsValue;
+                            };
+                            backward: {
+                                x: UnitsValue;
+                                y: UnitsValue;
+                            };
+                            smooth: boolean;
+                        }[];
                     }[];
                 }[];
-            }[];
-        };
-    }[];
-}
+            };
+        }[];
+    };
+} | {
+    type: 'oil paint plugin';
+    filter: {
+        name: string;
+        gpu: boolean;
+        lighting: boolean;
+        parameters: {
+            name: string;
+            value: number;
+        }[];
+    };
+} | {
+    type: 'hsb/hsl';
+    filter: {
+        inputMode: 'rgb' | 'hsb' | 'hsl';
+        rowOrder: 'rgb' | 'hsb' | 'hsl';
+    };
+} | {
+    type: 'oil paint';
+    filter: {
+        lightingOn: boolean;
+        stylization: number;
+        cleanliness: number;
+        brushScale: number;
+        microBrush: number;
+        lightDirection: number;
+        specularity: number;
+    };
+} | {
+    type: 'liquify';
+    filter: {
+        liquifyMesh: Uint8Array;
+    };
+};
+export type Filter = FilterVariant & {
+    name: string;
+    opacity: number;
+    blendMode: BlendMode;
+    enabled: boolean;
+    hasOptions: boolean;
+    foregroundColor: Color;
+    backgroundColor: Color;
+};
 export interface PlacedLayerFilter {
     enabled: boolean;
     validAtPosition: boolean;
     maskEnabled: boolean;
     maskLinked: boolean;
     maskExtendWithWhite: boolean;
-    list: {
-        id: number;
-        name: string;
-        opacity: number;
-        blendMode: BlendMode;
-        enabled: boolean;
-        hasOptions: boolean;
-        foregroundColor: Color;
-        backgroundColor: Color;
-        filter: PlacedLayerPuppetFilter | {};
-    }[];
+    list: Filter[];
 }
 export type PlacedLayerType = 'unknown' | 'vector' | 'raster' | 'image stack';
 export interface PlacedLayer {
@@ -973,7 +1331,22 @@ export interface LayerAdditionalInfo {
         unifyLayerVisibility?: boolean;
     };
     timeline?: Timeline;
-    filterEffects?: any;
+    filterEffectsMasks?: {
+        id: string;
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+        depth: number;
+        channels: ({
+            compressionMode: number;
+            data: Uint8Array;
+        } | undefined)[];
+        extra?: {
+            compressionMode: number;
+            data: Uint8Array;
+        };
+    }[];
     engineData?: string;
 }
 export interface ImageResources {
@@ -1205,6 +1578,7 @@ export interface Layer extends LayerAdditionalInfo {
     blendMode?: BlendMode;
     opacity?: number;
     transparencyProtected?: boolean;
+    effectsOpen?: boolean;
     hidden?: boolean;
     clipping?: boolean;
     canvas?: HTMLCanvasElement;
@@ -1286,3 +1660,4 @@ export interface WriteOptions {
      *  with some software. It may also be significantly slower. */
     compress?: boolean;
 }
+export {};

package/dist-es/psdReader.d.ts

@@ -13,6 +13,7 @@ export declare function readUint8(reader: PsdReader): number;
 export declare function peekUint8(reader: PsdReader): number;
 export declare function readInt16(reader: PsdReader): number;
 export declare function readUint16(reader: PsdReader): number;
+export declare function readUint16LE(reader: PsdReader): number;
 export declare function readInt32(reader: PsdReader): number;
 export declare function readInt32LE(reader: PsdReader): number;
 export declare function readUint32(reader: PsdReader): number;
@@ -25,6 +26,7 @@ export declare function readSignature(reader: PsdReader): string;
 export declare function readPascalString(reader: PsdReader, padTo: number): string;
 export declare function readUnicodeString(reader: PsdReader): string;
 export declare function readUnicodeStringWithLength(reader: PsdReader, length: number): string;
+export declare function readUnicodeStringWithLengthLE(reader: PsdReader, length: number): string;
 export declare function readAsciiString(reader: PsdReader, length: number): string;
 export declare function skipBytes(reader: PsdReader, count: number): void;
 export declare function checkSignature(reader: PsdReader, a: string, b?: string): void;

package/dist-es/psdReader.js

@@ -47,6 +47,10 @@ export function readUint16(reader) {
     reader.offset += 2;
     return reader.view.getUint16(reader.offset - 2, false);
 }
+export function readUint16LE(reader) {
+    reader.offset += 2;
+    return reader.view.getUint16(reader.offset - 2, true);
+}
 export function readInt32(reader) {
     reader.offset += 4;
     return reader.view.getInt32(reader.offset - 4, false);
@@ -118,6 +122,16 @@ export function readUnicodeStringWithLength(reader, length) {
     }
     return text;
 }
+export function readUnicodeStringWithLengthLE(reader, length) {
+    var text = '';
+    while (length--) {
+        var value = readUint16LE(reader);
+        if (value || length > 0) { // remove trailing \0
+            text += String.fromCharCode(value);
+        }
+    }
+    return text;
+}
 export function readAsciiString(reader, length) {
     var text = '';
     while (length--) {
@@ -321,14 +335,14 @@ function readLayerRecord(reader, psd, options) {
     var channelCount = readUint16(reader);
     var channels = [];
     for (var i = 0; i < channelCount; i++) {
-        var channelID = readInt16(reader);
-        var channelLength = readUint32(reader);
+        var id = readInt16(reader);
+        var length_1 = readUint32(reader);
         if (options.large) {
-            if (channelLength !== 0)
+            if (length_1 !== 0)
                 throw new Error('Sizes larger than 4GB are not supported');
-            channelLength = readUint32(reader);
+            length_1 = readUint32(reader);
         }
-        channels.push({ id: channelID, length: channelLength });
+        channels.push({ id: id, length: length_1 });
     }
     checkSignature(reader, '8BIM');
     var blendMode = readSignature(reader);
@@ -340,11 +354,12 @@ function readLayerRecord(reader, psd, options) {
     var flags = readUint8(reader);
     layer.transparencyProtected = (flags & 0x01) !== 0;
     layer.hidden = (flags & 0x02) !== 0;
+    if (flags & 0x20)
+        layer.effectsOpen = true;
     // 0x04 - obsolete
     // 0x08 - 1 for Photoshop 5.0 and later, tells if bit 4 has useful information
     // 0x10 - pixel data irrelevant to appearance of document
-    // 0x20 - ???
-    // if (flags & 0x20) (layer as any)._2 = true; // TEMP !!!!
+    // 0x20 - effects/filters panel is expanded
     skipBytes(reader, 1);
     readSection(reader, 1, function (left) {
         var mask = readLayerMaskData(reader, options);
@@ -747,9 +762,9 @@ export function readDataRLE(reader, pixelData, _width, height, step, offsets, la
         }
         else {
             for (var y = 0, p = offset | 0; y < height; y++, li++) {
-                var length_1 = lengths[li];
-                var buffer = readBytes(reader, length_1);
-                for (var i = 0; i < length_1; i++) {
+                var length_2 = lengths[li];
+                var buffer = readBytes(reader, length_2);
+                for (var i = 0; i < length_2; i++) {
                     var header = buffer[i];
                     if (header > 128) {
                         var value = buffer[++i];
@@ -890,7 +905,7 @@ export function readPattern(reader) {
         var has = readUint32(reader);
         if (!has)
             continue;
-        var length_2 = readUint32(reader);
+        var length_3 = readUint32(reader);
         var pixelDepth = readUint32(reader);
         var ctop = readUint32(reader);
         var cleft = readUint32(reader);
@@ -898,7 +913,7 @@ export function readPattern(reader) {
         var cright = readUint32(reader);
         var pixelDepth2 = readUint16(reader);
         var compressionMode = readUint8(reader); // 0 - raw, 1 - zip
-        var dataLength = length_2 - (4 + 16 + 2 + 1);
+        var dataLength = length_3 - (4 + 16 + 2 + 1);
         var cdata = readBytes(reader, dataLength);
         if (pixelDepth !== 8 || pixelDepth2 !== 8) {
             throw new Error('16bit pixel depth not supported for patterns');