@yft-design/psd-lib 1.0.1 → 1.1.0

package/dist/abr.d.ts

@@ -20,17 +20,68 @@ export interface BrushDynamics {
     jitter: number;
     minimum: number;
 }
-export interface BrushShape {
-    name?: string;
+type DynamicBrushShapeShape = 'round point' | 'round blunt' | 'round curve' | 'round angle' | 'round fan' | 'flat point' | 'flat blunt' | 'flat curve' | 'flat angle' | 'flat fan';
+type TipsBrushShapeShape = 'erodible point' | 'erodible flat' | 'erodible round' | 'erodible square' | 'erodible triangle' | 'custom';
+export type BrushShape = ComputedBrushShape | SampledBrushShape | TipsBrushShape | DynamicBrushShape;
+interface ComputedBrushShape {
+    type: 'computed';
     size: number;
     angle: number;
     roundness: number;
-    hardness?: number;
+    hardness: number;
     spacingOn: boolean;
     spacing: number;
     flipX: boolean;
     flipY: boolean;
-    sampledData?: string;
+}
+interface SampledBrushShape {
+    type: 'sampled';
+    name: string;
+    size: number;
+    angle: number;
+    roundness: number;
+    spacingOn: boolean;
+    spacing: number;
+    flipX: boolean;
+    flipY: boolean;
+    sampledData: string;
+}
+interface TipsBrushShape {
+    type: 'tips';
+    angle: number;
+    size: number;
+    shape: DynamicBrushShapeShape;
+    physics: boolean;
+    spacing: number;
+    spacingOn: boolean;
+    flipX: boolean;
+    flipY: boolean;
+    tipsType: TipsBrushShapeShape;
+    tipsLengthRatio: number;
+    tipsHardness: number;
+    tipsGridSize?: number;
+    tipsErodibleTipHeightMap?: number[];
+    tipsAirbrushCutoffAngle: number;
+    tipsAirbrushGranularity: number;
+    tipsAirbrushStreakiness: number;
+    tipsAirbrushSplatSize: number;
+    tipsAirbrushSplatCount: number;
+}
+interface DynamicBrushShape {
+    type: 'dynamic';
+    size: number;
+    angle: number;
+    shape: DynamicBrushShapeShape;
+    density: number;
+    length: number;
+    clumping: number;
+    thickness: number;
+    stiffness: number;
+    physics: boolean;
+    spacing: number;
+    spacingOn: boolean;
+    flipX: boolean;
+    flipY: boolean;
 }
 export interface Brush {
     name: string;
@@ -63,6 +114,7 @@ export interface Brush {
         depth: number;
         depthMinimum: number;
         depthDynamics: BrushDynamics;
+        textureEachTip: boolean;
     };
     dualBrush?: {
         flip: boolean;
@@ -141,3 +193,4 @@ export interface Brush {
 export declare function readAbr(buffer: ArrayBufferView, options?: {
     logMissingFeatures?: boolean;
 }): Abr;
+export {};

package/dist/abr.js

@@ -1,6 +1,8 @@
 import { BlnM, parseAngle, parsePercent, parseUnitsToNumber, readVersionAndDescriptor } from './descriptor';
 import { checkSignature, createReader, readBytes, readDataRLE, readInt16, readInt32, readPascalString, readPattern, readSignature, readUint16, readUint32, readUint8, skipBytes } from './psdReader';
 const dynamicsControl = ['off', 'fade', 'pen pressure', 'pen tilt', 'stylus wheel', 'initial direction', 'direction', 'initial rotation', 'rotation'];
+const dynamicBrushShapeShapes = ['round point', 'round blunt', 'round curve', 'round angle', 'round fan', 'flat point', 'flat blunt', 'flat curve', 'flat angle', 'flat fan'];
+const tipsBrushShapeShapes = ['erodible point', 'erodible flat', 'erodible round', 'erodible square', 'erodible triangle', 'custom'];
 const toBrushType = {
     _: 'brush',
     MixB: 'mixer brush',
@@ -17,22 +19,95 @@ function parseDynamics(desc) {
     };
 }
 function parseBrushShape(desc) {
-    const shape = {
-        size: parseUnitsToNumber(desc.Dmtr, 'Pixels'),
-        angle: parseAngle(desc.Angl),
-        roundness: parsePercent(desc.Rndn),
-        spacingOn: desc.Intr,
-        spacing: parsePercent(desc.Spcn),
-        flipX: desc.flipX,
-        flipY: desc.flipY,
-    };
-    if (desc['Nm  '])
-        shape.name = desc['Nm  '];
-    if (desc.Hrdn)
-        shape.hardness = parsePercent(desc.Hrdn);
-    if (desc.sampledData)
-        shape.sampledData = desc.sampledData;
-    return shape;
+    switch (desc._classID) {
+        case 'computedBrush': {
+            return {
+                type: 'computed',
+                size: parseUnitsToNumber(desc.Dmtr, 'Pixels'),
+                angle: parseAngle(desc.Angl),
+                roundness: parsePercent(desc.Rndn),
+                spacingOn: desc.Intr,
+                spacing: parsePercent(desc.Spcn),
+                flipX: desc.flipX,
+                flipY: desc.flipY,
+                hardness: parsePercent(desc.Hrdn),
+            };
+        }
+        case 'sampledBrush': {
+            return {
+                type: 'sampled',
+                size: parseUnitsToNumber(desc.Dmtr, 'Pixels'),
+                angle: parseAngle(desc.Angl),
+                roundness: parsePercent(desc.Rndn),
+                spacingOn: desc.Intr,
+                spacing: parsePercent(desc.Spcn),
+                flipX: desc.flipX,
+                flipY: desc.flipY,
+                name: desc['Nm  '],
+                sampledData: desc.sampledData,
+            };
+        }
+        case 'dBrush':
+            return {
+                type: 'dynamic',
+                shape: dynamicBrushShapeShapes[desc['Shp ']],
+                angle: parseAngle(desc.Angl),
+                size: parseUnitsToNumber(desc.Dmtr, 'Pixels'),
+                density: parsePercent(desc.Dnst),
+                length: parsePercent(desc.Lngt),
+                clumping: parsePercent(desc.clumping),
+                thickness: parsePercent(desc.thickness),
+                stiffness: parsePercent(desc.stiffness),
+                physics: desc.physics,
+                spacing: parsePercent(desc.Spcn),
+                spacingOn: desc.Intr,
+                flipX: desc.flipX,
+                flipY: desc.flipY,
+            };
+        case 'dTips': {
+            return {
+                type: 'tips',
+                angle: parseAngle(desc.Angl),
+                size: parseUnitsToNumber(desc.Dmtr, 'Pixels'),
+                shape: dynamicBrushShapeShapes[desc['Shp ']],
+                physics: desc.physics,
+                spacing: parsePercent(desc.Spcn),
+                spacingOn: desc.Intr,
+                flipX: desc.flipX,
+                flipY: desc.flipY,
+                // tips:
+                tipsType: tipsBrushShapeShapes[desc.dtipsType],
+                tipsLengthRatio: parsePercent(desc.dtipsLengthRatio),
+                tipsHardness: parsePercent(desc.dtipsHardness),
+                ...(desc.dtipsGridSize && desc.dtipsErodibleTipHeightMap ? {
+                    tipsGridSize: desc.dtipsGridSize,
+                    tipsErodibleTipHeightMap: parseHeightmap(desc.dtipsErodibleTipHeightMap),
+                } : {}),
+                // airbrush
+                tipsAirbrushCutoffAngle: desc.dtipsAirbrushCutoffAngle,
+                tipsAirbrushGranularity: parsePercent(desc.dtipsAirbrushGranularity),
+                tipsAirbrushStreakiness: parsePercent(desc.dtipsAirbrushStreakiness),
+                tipsAirbrushSplatSize: parsePercent(desc.dtipsAirbrushSplatSize),
+                tipsAirbrushSplatCount: desc.dtipsAirbrushSplatCount,
+            };
+        }
+        default:
+            console.log(require('util').inspect(desc, false, 99, true));
+            throw new Error(`Unknown brush classId: ${desc._classID}`);
+    }
+}
+function parseHeightmap(array) {
+    const result = [];
+    for (let i = 0; i < array.byteLength; i++) {
+        result.push(array[i]);
+    }
+    return result;
+    // const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    // const result: number[] = [];
+    // for (let i = 0, len = (array.byteLength / 4) | 0; i < len; i++) {
+    // 	result.push(view.getInt32(i * 4)); ????
+    // }
+    // return result;
 }
 export function readAbr(buffer, options = {}) {
     const reader = createReader(buffer.buffer, buffer.byteOffset, buffer.byteLength);
@@ -107,6 +182,7 @@ export function readAbr(buffer, options = {}) {
                 case 'desc': {
                     const desc = readVersionAndDescriptor(reader, true);
                     // console.log(require('util').inspect(desc, false, 99, true));
+                    // require('fs').writeFileSync('test.log', require('util').inspect(desc, false, 99, false), 'utf8');
                     for (const brush of desc.Brsh) {
                         const b = {
                             name: brush['Nm  '],
@@ -156,6 +232,7 @@ export function readAbr(buffer, options = {}) {
                                 invert: brush.InvT,
                                 brightness: brush.textureBrightness,
                                 contrast: brush.textureContrast,
+                                textureEachTip: !!brush.TxtC,
                             };
                         }
                         const db = brush.dualBrush;
@@ -258,10 +335,10 @@ export function readAbr(buffer, options = {}) {
                     break;
                 }
                 case 'patt': {
-                    if (reader.offset < end) { // TODO: check multiple patterns
+                    while (reader.offset < end) {
                         patterns.push(readPattern(reader));
-                        reader.offset = end;
                     }
+                    reader.offset = end;
                     break;
                 }
                 case 'phry': {

package/dist/additionalInfo.js

@@ -315,7 +315,7 @@ addHandler('vogk', hasKey('vectorOrigination'), (reader, target, left) => {
         }
         const trnf = i.Trnf;
         if (trnf) {
-            item.transform = [trnf.xx, trnf.xy, trnf.xy, trnf.yy, trnf.tx, trnf.ty];
+            item.transform = [trnf.xx, trnf.xy, trnf.yx, trnf.yy, trnf.tx, trnf.ty];
         }
         target.vectorOrigination.keyDescriptorList.push(item);
     }
@@ -733,6 +733,70 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
         }, 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 = {
+            type: 'vdPS',
+            origin: { x: desc.origin.Hrzn, y: desc.origin.Vrtc },
+            interpretation: {
+                interpretAlpha: desc.interpretation.interpretAlpha.split('.')[1],
+                profile: desc.interpretation.profile,
+            },
+            frameReader: {
+                type: 'QTFR',
+                link: {
+                    name: desc.frameReader['Lnk ']['Nm  '],
+                    fullPath: desc.frameReader['Lnk '].fullPath,
+                    originalPath: desc.frameReader['Lnk '].originalPath,
+                    relativePath: desc.frameReader['Lnk '].relPath,
+                    alias: desc.frameReader['Lnk '].alis,
+                },
+                mediaDescriptor: desc.frameReader.mediaDescriptor,
+            },
+            showAlteredVideo: desc.showAlteredVideo,
+        };
+    }
+    else {
+        reader.log(`Unknown pixelSourceType`);
+    }
+}, (writer, target) => {
+    const source = target.pixelSource;
+    const desc = {
+        _name: '',
+        _classID: 'PixelSource',
+        pixelSourceType: 1986285651, // vdP
+        descVersion: 1,
+        origin: { Hrzn: source.origin.x, Vrtc: source.origin.y },
+        interpretation: {
+            _name: '',
+            _classID: 'footageInterpretation',
+            Vrsn: 1,
+            interpretAlpha: `alphaInterpretation.${source.interpretation.interpretAlpha}`,
+            profile: source.interpretation.profile,
+        },
+        frameReader: {
+            _name: '',
+            _classID: 'FrameReader',
+            frameReaderType: 1364477522, // QTF
+            descVersion: 1,
+            'Lnk ': {
+                _name: '',
+                _classID: 'ExternalFileLink',
+                descVersion: 2,
+                'Nm  ': source.frameReader.link.name,
+                fullPath: source.frameReader.link.fullPath,
+                originalPath: source.frameReader.link.originalPath,
+                alis: source.frameReader.link.alias,
+                relPath: source.frameReader.link.relativePath,
+            },
+            mediaDescriptor: source.frameReader.mediaDescriptor,
+        },
+        showAlteredVideo: source.showAlteredVideo,
+    };
+    writeVersionAndDescriptor(writer, '', 'PixelSource', desc);
+});
 addHandler('vstk', hasKey('vectorStroke'), (reader, target, left) => {
     const desc = readVersionAndDescriptor(reader);
     // console.log(require('util').inspect(desc, false, 99, true));
@@ -2527,6 +2591,8 @@ else {
 }
 /*
 interface CAIDesc {
+    _name: '';
+    _classID: 'null';
     enab: boolean;
     generationalGuid: string;
 }
@@ -2536,15 +2602,15 @@ addHandler(
     () => false,
     (reader, _target, left) => {
         const version = readUint32(reader); // 3
-        const desc = readVersionAndDescriptor(reader) as CAIDesc;
+        const desc = readVersionAndDescriptor(reader, true) as CAIDesc;
+        console.log('CAI version', version);
         console.log('CAI', require('util').inspect(desc, false, 99, true));
-        console.log('CAI', { version });
         console.log('CAI left', readBytes(reader, left())); // 8 bytes left, all zeroes
     },
     (_writer, _target) => {
     },
 );
-*/
+// */
 if (MOCK_HANDLERS) {
     addHandler('CAI ', target => target._CAI_ !== undefined, (reader, target, left) => {
         target._CAI_ = readBytes(reader, left());
@@ -2552,25 +2618,41 @@ if (MOCK_HANDLERS) {
         writeBytes(writer, target._CAI_);
     });
 }
+// interface OCIODescriptor {
+// 	_name: '';
+// 	_classID: 'documentColorManagementInfo';
+// 	'Knd ': 'icc';
+// 	ocio_display_view: {
+// 		_name: '';
+// 		_classID: 'viewColorManagementInfo';
+// 		display: string;
+// 		view: string;
+// 	};
+// }
 if (MOCK_HANDLERS) {
-    addHandler('OCIO', // generative tech?
-    // generative tech?
+    addHandler('OCIO', // document color management info
+    // 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());
     }, (writer, target) => {
         writeBytes(writer, target._OCIO);
     });
 }
-// interface GenIDesc {
+// interface GenIDescriptor {
+//  _name: '';
+//  _classID: 'genTechInfo';
 // 	isUsingGenTech: number;
+//  externalModelList?: [];
 // }
 if (MOCK_HANDLERS) {
     addHandler('GenI', // generative tech
     // 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());
-        // const desc = readVersionAndDescriptor(reader) as GenIDesc;
-        // console.log('GenI', require('util').inspect(desc, false, 99, true));
     }, (writer, target) => {
         writeBytes(writer, target._GenI);
     });
@@ -2768,7 +2850,7 @@ function createLnkHandler(tag) {
                 version = 6;
             else if (file.childDocumentID != null)
                 version = 5;
-            else if (tag == 'lnkE')
+            else if (tag === 'lnkE')
                 version = 3;
             writeLength64(writer, 0);
             const sizeOffset = writer.offset;

package/dist/ase.d.ts

@@ -0,0 +1,32 @@
+export type AseColorType = 'global' | 'spot' | 'normal';
+export interface AseColor {
+    name: string;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+        type: AseColorType;
+    } | {
+        c: number;
+        m: number;
+        y: number;
+        k: number;
+        type: AseColorType;
+    } | {
+        k: number;
+        type: AseColorType;
+    } | {
+        l: number;
+        a: number;
+        b: number;
+        type: AseColorType;
+    };
+}
+export interface AseGroup {
+    name: string;
+    colors: AseColor[];
+}
+export interface Ase {
+    colors: (AseGroup | AseColor)[];
+}
+export declare function readAse(buffer: ArrayBufferView): Ase;

package/dist/ase.js

@@ -0,0 +1,78 @@
+import { createReader, readFloat32, readSignature, readUint16, readUint32, readUnicodeStringWithLength } from './psdReader';
+export function readAse(buffer) {
+    const reader = createReader(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const signature = readSignature(reader); // ASEF
+    if (signature !== 'ASEF')
+        throw new Error('Invalid signature');
+    const versionMajor = readUint16(reader); // 1
+    const versionMinor = readUint16(reader); // 0
+    if (versionMajor !== 1 || versionMinor !== 0)
+        throw new Error('Invalid version');
+    const blocksCount = readUint32(reader);
+    const colorTypes = ['global', 'spot', 'normal'];
+    const ase = { colors: [] };
+    let group = ase;
+    for (let i = 0; i < blocksCount; i++) {
+        const type = readUint16(reader);
+        const length = readUint32(reader);
+        const end = reader.offset + length;
+        switch (type) {
+            case 0x0001: { // color
+                const nameLength = readUint16(reader);
+                const name = readUnicodeStringWithLength(reader, nameLength);
+                const colorMode = readSignature(reader);
+                let color;
+                switch (colorMode) {
+                    case 'RGB ':
+                        color = {
+                            r: readFloat32(reader),
+                            g: readFloat32(reader),
+                            b: readFloat32(reader),
+                            type: colorTypes[readUint16(reader)],
+                        };
+                        break;
+                    case 'CMYK':
+                        color = {
+                            c: readFloat32(reader),
+                            m: readFloat32(reader),
+                            y: readFloat32(reader),
+                            k: readFloat32(reader),
+                            type: colorTypes[readUint16(reader)],
+                        };
+                        break;
+                    case 'Gray':
+                        color = {
+                            k: readFloat32(reader),
+                            type: colorTypes[readUint16(reader)],
+                        };
+                        break;
+                    case 'LAB ':
+                        color = {
+                            l: readFloat32(reader),
+                            a: readFloat32(reader),
+                            b: readFloat32(reader),
+                            type: colorTypes[readUint16(reader)],
+                        };
+                        break;
+                    default:
+                        throw new Error('Invalid color mode');
+                }
+                group.colors.push({ name, color });
+                break;
+            }
+            case 0xC001: { // group start
+                const nameLength = readUint16(reader);
+                const name = readUnicodeStringWithLength(reader, nameLength);
+                ase.colors.push(group = { name, colors: [] });
+                break;
+            }
+            case 0xC002: // group end
+                group = ase;
+                break;
+            default:
+                throw new Error('Invalid block type');
+        }
+        reader.offset = end;
+    }
+    return ase;
+}

package/dist/descriptor.d.ts

@@ -216,6 +216,41 @@ export interface FrameListDescriptor {
     LaID: number;
     LaSt: FrameDescriptor[];
 }
+export interface PxScDescriptor {
+    _name: '';
+    _classID: 'PixelSource';
+    pixelSourceType: 1986285651;
+    descVersion: 1;
+    origin: {
+        Hrzn: number;
+        Vrtc: number;
+    };
+    interpretation: {
+        _name: '';
+        _classID: 'footageInterpretation';
+        Vrsn: 1;
+        interpretAlpha: 'alphaInterpretation.straight';
+        profile: Uint8Array;
+    };
+    frameReader: {
+        _name: '';
+        _classID: 'FrameReader';
+        frameReaderType: 1364477522;
+        descVersion: 1;
+        'Lnk ': {
+            _name: '';
+            _classID: 'ExternalFileLink';
+            descVersion: 2;
+            'Nm  ': string;
+            fullPath: string;
+            originalPath: string;
+            alis: string;
+            relPath: string;
+        };
+        mediaDescriptor: string;
+    };
+    showAlteredVideo: boolean;
+}
 export declare function horzVrtcToXY(hv: HrznVrtcDescriptor): {
     x: number;
     y: number;

package/dist/helpers.d.ts

@@ -1,4 +1,4 @@
-import { Layer, BlendMode, LayerColor, PixelData, PixelArray } from './psd';
+import { Layer, BlendMode, LayerColor, PixelData, PixelArray, ChannelID, Compression } from './psd';
 export declare const MOCK_HANDLERS = false;
 export declare const RAW_IMAGE_DATA = false;
 export declare const fromBlendMode: {
@@ -37,21 +37,6 @@ export declare const enum MaskParams {
     VectorMaskDensity = 4,
     VectorMaskFeather = 8
 }
-export declare const enum ChannelID {
-    Color0 = 0,// red (rgb) / cyan (cmyk)
-    Color1 = 1,// green (rgb) / magenta (cmyk)
-    Color2 = 2,// blue (rgb) / yellow (cmyk)
-    Color3 = 3,// - (rgb) / black (cmyk)
-    Transparency = -1,
-    UserMask = -2,
-    RealUserMask = -3
-}
-export declare const enum Compression {
-    RawData = 0,
-    RleCompressed = 1,
-    ZipWithoutPrediction = 2,
-    ZipWithPrediction = 3
-}
 export interface ChannelData {
     channelId: ChannelID;
     compression: Compression;
@@ -83,7 +68,7 @@ export declare function decodeBitmap(input: PixelArray, output: PixelArray, widt
 export declare function writeDataRaw(data: PixelData, offset: number, width: number, height: number): Uint8Array<ArrayBuffer> | undefined;
 export declare function writeDataRLE(buffer: Uint8Array, { data, width, height }: PixelData, offsets: number[], large: boolean): Uint8Array<ArrayBuffer> | undefined;
 export declare function writeDataZipWithoutPrediction({ data, width, height }: PixelData, offsets: number[]): Uint8Array<ArrayBufferLike>;
+export declare function createCanvasFromData(data: Uint8Array): HTMLCanvasElement;
 export declare let createCanvas: (width: number, height: number) => HTMLCanvasElement;
-export declare let createCanvasFromData: (data: Uint8Array) => HTMLCanvasElement;
 export declare let createImageData: (width: number, height: number) => ImageData;
-export declare function initializeCanvas(createCanvasMethod: (width: number, height: number) => HTMLCanvasElement, createCanvasFromDataMethod?: (data: Uint8Array) => HTMLCanvasElement, createImageDataMethod?: (width: number, height: number) => ImageData): void;
+export declare function initializeCanvas(createCanvasMethod: (width: number, height: number) => HTMLCanvasElement, createImageDataMethod?: (width: number, height: number) => ImageData): void;

package/dist/helpers.js

@@ -1,5 +1,5 @@
-import { fromByteArray } from 'base64-js';
 import { deflate as deflateSync } from 'pako';
+import { decodeJpeg } from './jpeg';
 export const MOCK_HANDLERS = false;
 export const RAW_IMAGE_DATA = false;
 export const fromBlendMode = {};
@@ -264,12 +264,23 @@ export function writeDataZipWithoutPrediction({ data, width, height }, offsets)
         return buffers[0];
     }
 }
+export function createCanvasFromData(data) {
+    const canvas = createCanvas(100, 100);
+    try {
+        const context = canvas.getContext('2d');
+        const imageData = decodeJpeg(data, (w, h) => context.createImageData(w, h));
+        canvas.width = imageData.width;
+        canvas.height = imageData.height;
+        context.putImageData(imageData, 0, 0);
+    }
+    catch (e) {
+        console.error('JPEG decompression error', e.message);
+    }
+    return canvas;
+}
 export let createCanvas = () => {
     throw new Error('Canvas not initialized, use initializeCanvas method to set up createCanvas method');
 };
-export let createCanvasFromData = () => {
-    throw new Error('Canvas not initialized, use initializeCanvas method to set up createCanvasFromData method');
-};
 let tempCanvas = undefined;
 export let createImageData = (width, height) => {
     if (!tempCanvas)
@@ -283,18 +294,8 @@ if (typeof document !== 'undefined') {
         canvas.height = height;
         return canvas;
     };
-    createCanvasFromData = (data) => {
-        const image = new Image();
-        image.src = 'data:image/jpeg;base64,' + fromByteArray(data);
-        const canvas = document.createElement('canvas');
-        canvas.width = image.width;
-        canvas.height = image.height;
-        canvas.getContext('2d').drawImage(image, 0, 0);
-        return canvas;
-    };
 }
-export function initializeCanvas(createCanvasMethod, createCanvasFromDataMethod, createImageDataMethod) {
+export function initializeCanvas(createCanvasMethod, createImageDataMethod) {
     createCanvas = createCanvasMethod;
-    createCanvasFromData = createCanvasFromDataMethod || createCanvasFromData;
     createImageData = createImageDataMethod || createImageData;
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Psd, ReadOptions, WriteOptions } from './psd';
+import { Layer, Psd, ReadOptions, WriteOptions } from './psd';
 import { PsdWriter } from './psdWriter';
 import { PsdReader } from './psdReader';
 import { fromByteArray } from 'base64-js';
@@ -17,3 +17,4 @@ export declare function readPsd(buffer: ArrayBuffer | BufferLike, options?: Read
 export declare function writePsd(psd: Psd, options?: WriteOptions): ArrayBuffer;
 export declare function writePsdUint8Array(psd: Psd, options?: WriteOptions): Uint8Array;
 export declare function writePsdBuffer(psd: Psd, options?: WriteOptions): Buffer;
+export declare function decodeLayerPixels(layer: Layer, useImageData?: boolean): void;

package/dist/index.js

@@ -1,5 +1,5 @@
 import { writePsd as writePsdInternal, getWriterBuffer, createWriter, getWriterBufferNoCopy } from './psdWriter';
-import { readPsd as readPsdInternal, createReader } from './psdReader';
+import { readPsd as readPsdInternal, createReader, decodeLayerImageData } from './psdReader';
 import { fromByteArray } from 'base64-js';
 export * from './abr';
 export * from './csh';
@@ -28,3 +28,6 @@ export function writePsdBuffer(psd, options) {
     }
     return Buffer.from(writePsdUint8Array(psd, options));
 }
+export function decodeLayerPixels(layer, useImageData) {
+    decodeLayerImageData(layer, useImageData);
+}