@yft-design/psd-lib 1.0.1 → 1.1.0

package/dist/psd.d.ts

@@ -1482,6 +1482,29 @@ export interface LayerAdditionalInfo {
         }[];
     };
     vowv?: number;
+    pixelSource?: {
+        type: 'vdPS';
+        origin: {
+            x: number;
+            y: number;
+        };
+        interpretation: {
+            interpretAlpha: string;
+            profile: Uint8Array;
+        };
+        frameReader: {
+            type: 'QTFR';
+            link: {
+                name: string;
+                fullPath: string;
+                originalPath: string;
+                relativePath: string;
+                alias: string;
+            };
+            mediaDescriptor: string;
+        };
+        showAlteredVideo: boolean;
+    };
     engineData?: string;
 }
 export declare enum LayerCompCapturedInfo {
@@ -1720,6 +1743,32 @@ export interface Annotation {
     date: string;
     data: string | Uint8Array;
 }
+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 LayerRawDataChannel {
+    id: ChannelID;
+    compression: Compression;
+    data: Uint8Array | undefined;
+}
+export interface LayerRawData {
+    colorMode: ColorMode;
+    bitsPerChannel: number;
+    channels: LayerRawDataChannel[];
+    large: boolean;
+}
 export interface Layer extends LayerAdditionalInfo {
     top?: number;
     left?: number;
@@ -1733,6 +1782,7 @@ export interface Layer extends LayerAdditionalInfo {
     clipping?: boolean;
     canvas?: HTMLCanvasElement;
     imageData?: PixelData;
+    rawData?: LayerRawData;
     children?: Layer[];
     /** Applies only for layer groups. */
     opened?: boolean;
@@ -1788,6 +1838,7 @@ export interface ReadOptions {
      * (image data will appear in `imageData` fields instead of `canvas` fields)
      * This avoids issues with canvas premultiplied alpha corrupting image data. */
     useImageData?: boolean;
+    useRawData?: boolean;
     /** Loads thumbnail raw data instead of decoding it's content into canvas.
      * `thumnailRaw` field is used instead. */
     useRawThumbnail?: boolean;

package/dist/psdReader.d.ts

@@ -1,6 +1,5 @@
-import { Compression } from './helpers';
+import { Psd, Layer, ColorMode, LayerAdditionalInfo, ReadOptions, Color, PatternInfo, GlobalLayerMaskInfo, PixelData } from './psd';
 import { InternalImageResources } from './imageResources';
-import { Color, ColorMode, GlobalLayerMaskInfo, LayerAdditionalInfo, PatternInfo, PixelData, Psd, ReadOptions } from './psd';
 export declare const supportedColorModes: ColorMode[];
 export interface PsdReader extends ReadOptions {
     offset: number;
@@ -35,12 +34,12 @@ export declare function skipBytes(reader: PsdReader, count: number): void;
 export declare function checkSignature(reader: PsdReader, a: string, b?: string): void;
 export declare function readPsd(reader: PsdReader, readOptions?: ReadOptions): Psd;
 export declare function readLayerInfo(reader: PsdReader, psd: Psd, imageResources: InternalImageResources): void;
-export declare function readData(reader: PsdReader, length: number, data: PixelData | undefined, compression: Compression, width: number, height: number, bitDepth: number, offset: number, large: boolean, step: number): void;
+export declare function decodeLayerImageData(layer: Layer, useImageData?: boolean, throwForMissingFeatures?: boolean): void;
 export declare function readGlobalLayerMaskInfo(reader: PsdReader): GlobalLayerMaskInfo | undefined;
 export declare function readAdditionalLayerInfo(reader: PsdReader, target: LayerAdditionalInfo, psd: Psd, imageResources: InternalImageResources): void;
 export declare function createImageDataBitDepth(width: number, height: number, bitDepth: number, channels?: number): PixelData;
-export declare function readDataZip(reader: PsdReader, length: number, pixelData: PixelData | undefined, width: number, height: number, bitDepth: number, step: number, offset: number, prediction: boolean): void;
-export declare function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined, width: number, height: number, bitDepth: number, step: number, offsets: number[], large: boolean): void;
+export declare function readDataZip(compressed: Uint8Array, pixelData: PixelData | undefined, width: number, height: number, bitDepth: number, step: number, offset: number, prediction: boolean): void;
+export declare function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined, width: number, height: number, _bitDepth: number, step: number, offsets: number[], large: boolean): void;
 export declare function readSection<T>(reader: PsdReader, round: number, func: (left: () => number) => T, skipEmpty?: boolean, eightBytes?: boolean): T | undefined;
 export declare function readColor(reader: PsdReader): Color;
 export declare function readPattern(reader: PsdReader): PatternInfo;

package/dist/psdReader.js

@@ -1,6 +1,6 @@
 import { inflate as inflateSync } from 'pako';
+import { resetImageData, offsetForChannel, decodeBitmap, createImageData, toBlendMode, RAW_IMAGE_DATA, largeAdditionalInfoKeys, imageDataToCanvas } from './helpers';
 import { infoHandlersMap } from './additionalInfo';
-import { RAW_IMAGE_DATA, createImageData, decodeBitmap, imageDataToCanvas, largeAdditionalInfoKeys, offsetForChannel, resetImageData, toBlendMode } from './helpers';
 import { resourceHandlersMap } from './imageResources';
 export const supportedColorModes = [0 /* ColorMode.Bitmap */, 1 /* ColorMode.Grayscale */, 3 /* ColorMode.RGB */, 2 /* ColorMode.Indexed */, 4 /* ColorMode.CMYK */];
 const colorModes = ['bitmap', 'grayscale', 'indexed', 'RGB', 'CMYK', 'multichannel', 'duotone', 'lab'];
@@ -72,10 +72,10 @@ export function readFixedPointPath32(reader) {
 export function readBytes(reader, length) {
     const start = reader.view.byteOffset + reader.offset;
     reader.offset += length;
-    if (start + length > reader.view.buffer.byteLength) {
+    if ((start + length) > reader.view.buffer.byteLength) {
         // fix for broken PSD files that are missing part of file at the end
         warnOrThrow(reader, 'Reading bytes exceeding buffer length');
-        if (length > 100 * 1024 * 1024)
+        if (length > (100 * 1024 * 1024))
             throw new Error('Reading past end of file'); // limit to 100MB
         const result = new Uint8Array(length);
         const len = Math.min(length, reader.view.byteLength - start);
@@ -91,17 +91,16 @@ export function readSignature(reader) {
     return readShortString(reader, 4);
 }
 export function validSignatureAt(reader, offset) {
-    const sig = String.fromCharCode(reader.view.getUint8(offset)) +
-        String.fromCharCode(reader.view.getUint8(offset + 1)) +
-        String.fromCharCode(reader.view.getUint8(offset + 2)) +
-        String.fromCharCode(reader.view.getUint8(offset + 3));
+    const sig = String.fromCharCode(reader.view.getUint8(offset))
+        + String.fromCharCode(reader.view.getUint8(offset + 1))
+        + String.fromCharCode(reader.view.getUint8(offset + 2))
+        + String.fromCharCode(reader.view.getUint8(offset + 3));
     return sig == '8BIM' || sig == '8B64';
 }
 export function readPascalString(reader, padTo) {
     let length = readUint8(reader);
     const text = length ? readShortString(reader, length) : '';
-    while (++length % padTo) {
-        // starts with length + 1 so we count the size byte too
+    while (++length % padTo) { // starts with length + 1 so we count the size byte too
         reader.offset++;
     }
     return text;
@@ -114,8 +113,7 @@ export function readUnicodeStringWithLength(reader, length) {
     let text = '';
     while (length--) {
         const value = readUint16(reader);
-        if (value || length > 0) {
-            // remove trailing \0
+        if (value || length > 0) { // remove trailing \0
             text += String.fromCharCode(value);
         }
     }
@@ -125,8 +123,7 @@ export function readUnicodeStringWithLengthLE(reader, length) {
     let text = '';
     while (length--) {
         const value = readUint16LE(reader);
-        if (value || length > 0) {
-            // remove trailing \0
+        if (value || length > 0) { // remove trailing \0
             text += String.fromCharCode(value);
         }
     }
@@ -186,7 +183,7 @@ export function readPsd(reader, readOptions = {}) {
     reader.large = version === 2;
     reader.globalAlpha = false;
     // color mode data
-    readSection(reader, 1, (left) => {
+    readSection(reader, 1, left => {
         if (!left())
             return;
         if (colorMode === 2 /* ColorMode.Indexed */) {
@@ -209,12 +206,12 @@ export function readPsd(reader, readOptions = {}) {
     });
     // image resources
     const imageResources = {};
-    readSection(reader, 1, (left) => {
+    readSection(reader, 1, left => {
         while (left() > 0) {
             realignWithSignature(reader, isValidSignature);
             const id = readUint16(reader);
             readPascalString(reader, 2); // name
-            readSection(reader, 2, (left) => {
+            readSection(reader, 2, left => {
                 const handler = resourceHandlersMap[id];
                 const skip = id === 1036 && !!reader.skipThumbnail;
                 if (handler && !skip) {
@@ -239,8 +236,8 @@ export function readPsd(reader, readOptions = {}) {
         psd.imageResources = rest;
     }
     // layer and mask info
-    readSection(reader, 1, (left) => {
-        readSection(reader, 2, (left) => {
+    readSection(reader, 1, left => {
+        readSection(reader, 2, left => {
             readLayerInfo(reader, psd, imageResources);
             skipBytes(reader, left());
         }, undefined, reader.large);
@@ -298,10 +295,8 @@ export function readLayerInfo(reader, psd, imageResources) {
         layers.push(layer);
         layerChannels.push(channels);
     }
-    if (!reader.skipLayerImageData) {
-        for (let i = 0; i < layerCount; i++) {
-            readLayerChannelImageData(reader, psd, layers[i], layerChannels[i]);
-        }
+    for (let i = 0; i < layerCount; i++) {
+        readLayerChannelImageData(reader, psd, layers[i], layerChannels[i]);
     }
     if (!psd.children)
         psd.children = [];
@@ -365,7 +360,7 @@ function readLayerRecord(reader, psd, imageResources) {
     // 0x10 - pixel data irrelevant to appearance of document
     // 0x20 - effects/filters panel is expanded
     skipBytes(reader, 1);
-    readSection(reader, 1, (left) => {
+    readSection(reader, 1, left => {
         readLayerMaskData(reader, layer);
         const blendingRanges = readLayerBlendingRanges(reader);
         if (blendingRanges)
@@ -381,7 +376,7 @@ function readLayerRecord(reader, psd, imageResources) {
     return { layer, channels };
 }
 function readLayerMaskData(reader, layer) {
-    return readSection(reader, 1, (left) => {
+    return readSection(reader, 1, left => {
         if (!left())
             return undefined;
         const mask = {};
@@ -426,7 +421,7 @@ function readBlendingRange(reader) {
     return [readUint8(reader), readUint8(reader), readUint8(reader), readUint8(reader)];
 }
 function readLayerBlendingRanges(reader) {
-    return readSection(reader, 1, (left) => {
+    return readSection(reader, 1, left => {
         const compositeGrayBlendSource = readBlendingRange(reader);
         const compositeGraphBlendDestinationRange = readBlendingRange(reader);
         const ranges = [];
@@ -439,74 +434,101 @@ function readLayerBlendingRanges(reader) {
     });
 }
 function readLayerChannelImageData(reader, psd, layer, channels) {
+    if (reader.skipLayerImageData)
+        return;
+    const { colorMode = 3 /* ColorMode.RGB */, bitsPerChannel = 8 } = psd;
+    layer.rawData = { colorMode, bitsPerChannel, channels: [], large: reader.large };
+    for (const channel of channels) {
+        const start = reader.offset;
+        let compression = 0 /* Compression.RawData */;
+        let data = undefined;
+        if (channel.length === 1)
+            throw new Error('Invalid channel length');
+        if (channel.length) {
+            compression = readUint16(reader);
+            // try to fix broken files where there's 1 byte shift of channel
+            if (compression > 3) {
+                reader.offset -= 1;
+                compression = readUint16(reader);
+            }
+            // try to fix broken files where there's 1 byte shift of channel
+            if (compression > 3) {
+                reader.offset -= 3;
+                compression = readUint16(reader);
+            }
+            if (compression > 3)
+                throw new Error(`Invalid compression: ${compression}`);
+            if (channel.length > 2) {
+                data = readBytes(reader, channel.length - 2);
+            }
+        }
+        reader.offset = start + channel.length;
+        layer.rawData.channels.push({ id: channel.id, compression, data });
+    }
+    if (!reader.useRawData) {
+        decodeLayerImageData(layer, !!reader.useImageData, !!reader.throwForMissingFeatures);
+    }
+}
+function resetAlpha({ data }, cmyk) {
+    const alpha = (data instanceof Float32Array) ? 1.0 : ((data instanceof Uint16Array) ? 0xffff : 0xff);
+    const offset = (cmyk ? 4 : 3) | 0;
+    const length = data.length | 0;
+    const step = (cmyk ? 5 : 4) | 0;
+    for (let p = offset; p < length; p = (p + step) | 0) {
+        data[p] = alpha;
+    }
+}
+export function decodeLayerImageData(layer, useImageData, throwForMissingFeatures) {
+    if (!layer.rawData)
+        return;
+    const { colorMode, bitsPerChannel, channels, large } = layer.rawData;
     const layerWidth = (layer.right || 0) - (layer.left || 0);
     const layerHeight = (layer.bottom || 0) - (layer.top || 0);
-    const cmyk = psd.colorMode === 4 /* ColorMode.CMYK */;
+    const cmyk = colorMode === 4 /* ColorMode.CMYK */;
     let imageData;
+    let initializedAlpha = false;
     if (layerWidth && layerHeight) {
         if (cmyk) {
-            if (psd.bitsPerChannel !== 8)
+            if (bitsPerChannel !== 8)
                 throw new Error('bitsPerChannel Not supproted');
             imageData = { width: layerWidth, height: layerHeight, data: new Uint8ClampedArray(layerWidth * layerHeight * 5) };
-            for (let p = 4; p < imageData.data.byteLength; p += 5)
-                imageData.data[p] = 255;
         }
         else {
-            imageData = createImageDataBitDepth(layerWidth, layerHeight, psd.bitsPerChannel ?? 8);
-            resetImageData(imageData);
+            imageData = createImageDataBitDepth(layerWidth, layerHeight, bitsPerChannel);
         }
     }
-    if (RAW_IMAGE_DATA) {
-        ;
+    if (RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
         layer.imageDataRaw = [];
         layer.imageDataRawCompression = [];
     }
-    for (const channel of channels) {
-        if (channel.length === 0)
+    for (const { id, compression, data } of channels) {
+        if (!data)
             continue;
-        if (channel.length < 2)
-            throw new Error('Invalid channel length');
-        const start = reader.offset;
-        let compression = readUint16(reader);
-        // try to fix broken files where there's 1 byte shift of channel
-        if (compression > 3) {
-            reader.offset -= 1;
-            compression = readUint16(reader);
-        }
-        // try to fix broken files where there's 1 byte shift of channel
-        if (compression > 3) {
-            reader.offset -= 3;
-            compression = readUint16(reader);
-        }
-        if (compression > 3)
-            throw new Error(`Invalid compression: ${compression}`);
-        if (channel.id === -2 /* ChannelID.UserMask */ || channel.id === -3 /* ChannelID.RealUserMask */) {
-            const mask = channel.id === -2 /* ChannelID.UserMask */ ? layer.mask : layer.realMask;
+        const dataReader = createReader(data.buffer, data.byteOffset, data.byteLength);
+        if (id === -2 /* ChannelID.UserMask */ || id === -3 /* ChannelID.RealUserMask */) {
+            const mask = id === -2 /* ChannelID.UserMask */ ? layer.mask : layer.realMask;
             if (!mask)
-                throw new Error(`Missing layer ${channel.id === -2 /* ChannelID.UserMask */ ? 'mask' : 'real mask'} data`);
+                throw new Error(`Missing layer ${id === -2 /* ChannelID.UserMask */ ? 'mask' : 'real mask'} data`);
             const maskWidth = (mask.right || 0) - (mask.left || 0);
             const maskHeight = (mask.bottom || 0) - (mask.top || 0);
             if (maskWidth < 0 || maskHeight < 0 || maskWidth > 30000 || maskHeight > 30000)
                 throw new Error('Invalid mask size');
             if (maskWidth && maskHeight) {
-                const maskData = createImageDataBitDepth(maskWidth, maskHeight, psd.bitsPerChannel ?? 8);
-                resetImageData(maskData);
-                const start = reader.offset;
-                readData(reader, channel.length, maskData, compression, maskWidth, maskHeight, psd.bitsPerChannel ?? 8, 0, reader.large, 4);
-                if (RAW_IMAGE_DATA) {
-                    if (channel.id === -2 /* ChannelID.UserMask */) {
-                        ;
+                const maskData = createImageDataBitDepth(maskWidth, maskHeight, bitsPerChannel);
+                readData(dataReader, data.byteLength, maskData, compression, maskWidth, maskHeight, bitsPerChannel, 0, large, 4);
+                if (RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
+                    if (id === -2 /* ChannelID.UserMask */) {
                         layer.maskDataRawCompression = compression;
-                        layer.maskDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
+                        layer.maskDataRaw = data;
                     }
                     else {
-                        ;
                         layer.realMaskDataRawCompression = compression;
-                        layer.realMaskDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
+                        layer.realMaskDataRaw = data;
                     }
                 }
                 setupGrayscale(maskData);
-                if (reader.useImageData) {
+                resetAlpha(maskData, false);
+                if (useImageData) {
                     mask.imageData = maskData;
                 }
                 else {
@@ -515,59 +537,72 @@ function readLayerChannelImageData(reader, psd, layer, channels) {
             }
         }
         else {
-            const offset = offsetForChannel(channel.id, cmyk);
+            const offset = offsetForChannel(id, cmyk);
             let targetData = imageData;
             if (offset < 0) {
                 targetData = undefined;
-                if (reader.throwForMissingFeatures) {
-                    throw new Error(`Channel not supported: ${channel.id}`);
+                if (throwForMissingFeatures) {
+                    throw new Error(`Channel not supported: ${id}`);
                 }
             }
-            readData(reader, channel.length, targetData, compression, layerWidth, layerHeight, psd.bitsPerChannel ?? 8, offset, reader.large, cmyk ? 5 : 4);
-            if (RAW_IMAGE_DATA) {
-                ;
-                layer.imageDataRawCompression[channel.id] = compression;
-                layer.imageDataRaw[channel.id] = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start + 2, channel.length - 2);
+            readData(dataReader, data.byteLength, targetData, compression, layerWidth, layerHeight, bitsPerChannel, offset, large, cmyk ? 5 : 4);
+            if (RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
+                layer.imageDataRawCompression[id] = compression;
+                layer.imageDataRaw[id] = data;
             }
-            reader.offset = start + channel.length;
-            if (targetData && psd.colorMode === 1 /* ColorMode.Grayscale */) {
+            if (targetData && colorMode === 1 /* ColorMode.Grayscale */) {
                 setupGrayscale(targetData);
             }
         }
+        if (id === -1 /* ChannelID.Transparency */) {
+            initializedAlpha = true;
+        }
     }
     if (imageData) {
+        if (!initializedAlpha)
+            resetAlpha(imageData, cmyk);
         if (cmyk) {
             const cmykData = imageData;
             imageData = createImageData(cmykData.width, cmykData.height);
             cmykToRgb(cmykData, imageData, false);
         }
-        if (reader.useImageData) {
+        if (useImageData) {
             layer.imageData = imageData;
         }
         else {
             layer.canvas = imageDataToCanvas(imageData);
         }
     }
+    delete layer.rawData;
 }
-export function readData(reader, length, data, compression, width, height, bitDepth, offset, large, step) {
+function readData(reader, length, pixels, compression, width, height, bitDepth, offset, large, step) {
+    if (!length)
+        return;
     if (compression === 0 /* Compression.RawData */) {
-        readDataRaw(reader, data, width, height, bitDepth, step, offset);
+        if (length !== (width * height * Math.floor(bitDepth / 8))) {
+            reader.log(`Invalid length (${length}, ${width * height * Math.floor(bitDepth / 8)})`);
+        }
+        const data = readBytes(reader, length);
+        readDataRaw(data, pixels, bitDepth, step, offset);
     }
     else if (compression === 1 /* Compression.RleCompressed */) {
-        readDataRLE(reader, data, width, height, bitDepth, step, [offset], large);
+        // const reader = createReader(data.buffer, data.byteOffset, data.byteLength);
+        readDataRLE(reader, pixels, width, height, bitDepth, step, [offset], large);
     }
     else if (compression === 2 /* Compression.ZipWithoutPrediction */) {
-        readDataZip(reader, length, data, width, height, bitDepth, step, offset, false);
+        const data = readBytes(reader, length);
+        readDataZip(data, pixels, width, height, bitDepth, step, offset, false);
     }
     else if (compression === 3 /* Compression.ZipWithPrediction */) {
-        readDataZip(reader, length, data, width, height, bitDepth, step, offset, true);
+        const data = readBytes(reader, length);
+        readDataZip(data, pixels, width, height, bitDepth, step, offset, true);
     }
     else {
         throw new Error(`Invalid Compression type: ${compression}`);
     }
 }
 export function readGlobalLayerMaskInfo(reader) {
-    return readSection(reader, 1, (left) => {
+    return readSection(reader, 1, left => {
         if (!left())
             return undefined;
         const overlayColorSpace = readUint16(reader);
@@ -596,7 +631,7 @@ function realignWithSignature(reader, isValid) {
             break;
     }
     if (!isValid(sig)) {
-        throw new Error(`Invalid signature: '${sig}' at 0x${sigOffset.toString(16)}`);
+        throw new Error(`Invalid signature: '${sig}' at 0x${(sigOffset).toString(16)}`);
     }
     return sig;
 }
@@ -608,7 +643,7 @@ export function readAdditionalLayerInfo(reader, target, psd, imageResources) {
     const key = readSignature(reader);
     // `largeAdditionalInfoKeys` fallback, because some keys don't have 8B64 signature even when they are 64bit
     const u64 = sig === '8B64' || (reader.large && largeAdditionalInfoKeys.indexOf(key) !== -1);
-    readSection(reader, 2, (left) => {
+    readSection(reader, 2, left => {
         const handler = infoHandlersMap[key];
         if (handler) {
             try {
@@ -689,7 +724,8 @@ function readImageData(reader, psd) {
             }
             if (compression === 0 /* Compression.RawData */) {
                 for (let i = 0; i < channels.length; i++) {
-                    readDataRaw(reader, imageData, psd.width, psd.height, bitsPerChannel, 4, channels[i]);
+                    const data = readBytes(reader, psd.width * psd.height * Math.floor(bitsPerChannel / 8));
+                    readDataRaw(data, imageData, bitsPerChannel, 4, channels[i]);
                 }
             }
             else if (compression === 1 /* Compression.RleCompressed */) {
@@ -717,7 +753,7 @@ function readImageData(reader, psd) {
                 const indexedImageData = {
                     width: imageData.width,
                     height: imageData.height,
-                    data: new Uint8Array(imageData.width * imageData.height)
+                    data: new Uint8Array(imageData.width * imageData.height),
                 };
                 readDataRLE(reader, indexedImageData, psd.width, psd.height, bitsPerChannel, 1, [0], reader.large);
                 indexedToRgb(indexedImageData, imageData, psd.palette);
@@ -730,7 +766,7 @@ function readImageData(reader, psd) {
         case 4 /* ColorMode.CMYK */: {
             if (bitsPerChannel !== 8)
                 throw new Error('bitsPerChannel Not supproted');
-            if (psd.channels !== 4 && psd.channels !== 5)
+            if (psd.channels !== 4)
                 throw new Error(`Invalid channel count`);
             const channels = [0, 1, 2, 3];
             if (reader.globalAlpha)
@@ -746,7 +782,7 @@ function readImageData(reader, psd) {
                 const cmykImageData = {
                     width: imageData.width,
                     height: imageData.height,
-                    data: new Uint8Array(imageData.width * imageData.height * 5)
+                    data: new Uint8Array(imageData.width * imageData.height * 5),
                 };
                 const start = reader.offset;
                 readDataRLE(reader, cmykImageData, psd.width, psd.height, bitsPerChannel, 5, channels, reader.large);
@@ -759,8 +795,7 @@ function readImageData(reader, psd) {
             }
             break;
         }
-        default:
-            throw new Error(`Color mode not supported: ${psd.colorMode}`);
+        default: throw new Error(`Color mode not supported: ${psd.colorMode}`);
     }
     // remove weird white matte
     if (reader.globalAlpha) {
@@ -796,9 +831,9 @@ function cmykToRgb(cmyk, rgb, reverseAlpha) {
         const m = srcData[src + 1];
         const y = srcData[src + 2];
         const k = srcData[src + 3];
-        dstData[dst] = (((c * k) | 0) / 255) | 0;
-        dstData[dst + 1] = (((m * k) | 0) / 255) | 0;
-        dstData[dst + 2] = (((y * k) | 0) / 255) | 0;
+        dstData[dst] = ((((c * k) | 0) / 255) | 0);
+        dstData[dst + 1] = ((((m * k) | 0) / 255) | 0);
+        dstData[dst + 2] = ((((y * k) | 0) / 255) | 0);
         dstData[dst + 3] = reverseAlpha ? 255 - srcData[src + 4] : srcData[src + 4];
     }
     // for (let src = 0, dst = 0; dst < size; src += 5, dst += 4) {
@@ -825,7 +860,7 @@ function indexedToRgb(indexed, rgb, palette) {
     }
 }
 function verifyCompatible(a, b) {
-    if (a.byteLength / a.length !== b.byteLength / b.length) {
+    if ((a.byteLength / a.length) !== (b.byteLength / b.length)) {
         throw new Error('Invalid array types');
     }
 }
@@ -834,6 +869,13 @@ function bytesToArray(bytes, bitDepth) {
         return bytes;
     }
     else if (bitDepth === 16) {
+        // PSD files store 16-bit channel data in big-endian byte order.
+        // Swap each pair of bytes so that Uint16Array (native-endian) reads the correct values.
+        for (let i = 0; i < bytes.byteLength; i += 2) {
+            const tmp = bytes[i];
+            bytes[i] = bytes[i + 1];
+            bytes[i + 1] = tmp;
+        }
         if (bytes.byteOffset % 2) {
             const result = new Uint16Array(bytes.byteLength / 2);
             new Uint8Array(result.buffer, result.byteOffset, result.byteLength).set(bytes);
@@ -865,8 +907,7 @@ function copyChannelToPixelData(pixelData, channel, offset, step) {
         data[p] = channel[i];
     }
 }
-function readDataRaw(reader, pixelData, width, height, bitDepth, step, offset) {
-    const buffer = readBytes(reader, width * height * Math.floor(bitDepth / 8));
+function readDataRaw(buffer, pixelData, bitDepth, step, offset) {
     if (bitDepth == 32) {
         for (let i = 0; i < buffer.byteLength; i += 4) {
             const a = buffer[i + 0];
@@ -892,8 +933,7 @@ function decodePredicted(data, width, height, mod) {
         }
     }
 }
-export function readDataZip(reader, length, pixelData, width, height, bitDepth, step, offset, prediction) {
-    const compressed = readBytes(reader, length);
+export function readDataZip(compressed, pixelData, width, height, bitDepth, step, offset, prediction) {
     const decompressed = inflateSync(compressed);
     if (pixelData && offset < step) {
         const array = bytesToArray(decompressed, bitDepth);
@@ -927,7 +967,7 @@ export function readDataZip(reader, length, pixelData, width, height, bitDepth,
         }
     }
 }
-export function readDataRLE(reader, pixelData, width, height, bitDepth, step, offsets, large) {
+export function readDataRLE(reader, pixelData, width, height, _bitDepth, step, offsets, large) {
     const data = pixelData && pixelData.data;
     let lengths;
     if (large) {
@@ -946,8 +986,7 @@ export function readDataRLE(reader, pixelData, width, height, bitDepth, step, of
             }
         }
     }
-    if (bitDepth !== 1 && bitDepth !== 8)
-        throw new Error(`Invalid bit depth (${bitDepth})`);
+    // if (bitDepth !== 1 && bitDepth !== 8) throw new Error(`Invalid bit depth (${bitDepth})`);
     const extraLimit = (step - 1) | 0; // 3 for rgb, 4 for cmyk
     for (let c = 0, li = 0; c < offsets.length; c++) {
         const offset = offsets[c] | 0;
@@ -1044,13 +1083,13 @@ export function readColor(reader) {
             const l = readInt16(reader) / 10000;
             const ta = readInt16(reader);
             const tb = readInt16(reader);
-            const a = ta < 0 ? ta / 12800 : ta / 12700;
-            const b = tb < 0 ? tb / 12800 : tb / 12700;
+            const a = ta < 0 ? (ta / 12800) : (ta / 12700);
+            const b = tb < 0 ? (tb / 12800) : (tb / 12700);
             skipBytes(reader, 2);
             return { l, a, b };
         }
         case 8 /* ColorSpace.Grayscale */: {
-            const k = (readUint16(reader) * 255) / 10000;
+            const k = readUint16(reader) * 255 / 10000;
             skipBytes(reader, 6);
             return { k };
         }
@@ -1059,7 +1098,10 @@ export function readColor(reader) {
     }
 }
 export function readPattern(reader) {
-    readUint32(reader); // length
+    let length = readUint32(reader);
+    while (length % 4)
+        length++;
+    const end = reader.offset + length;
     const version = readUint32(reader);
     if (version !== 1)
         throw new Error(`Invalid pattern version: ${version}`);
@@ -1078,7 +1120,7 @@ export function readPattern(reader) {
             palette.push({
                 r: readUint8(reader),
                 g: readUint8(reader),
-                b: readUint8(reader)
+                b: readUint8(reader),
             });
         }
         skipBytes(reader, 4); // no idea what this is
@@ -1099,7 +1141,7 @@ export function readPattern(reader) {
     for (let i = 3; i < data.byteLength; i += 4) {
         data[i] = 255;
     }
-    for (let i = 0, ch = 0; i < channelsCount + 2; i++) {
+    for (let i = 0, ch = 0; i < (channelsCount + 2); i++) {
         const has = readUint32(reader);
         if (!has)
             continue;
@@ -1170,7 +1212,7 @@ export function readPattern(reader) {
         }
         ch++;
     }
-    // TODO: use canvas instead of data ?
+    reader.offset = end;
     return { id, name, x, y, bounds: { x: left, y: top, w: width, h: height }, data };
 }
 function copyChannelToRGBA(srcData, dstData, ox, oy, offset) {