ag-psd 31.0.3 → 33.0.0

package/dist-es/psdWriter.js

@@ -23,6 +23,8 @@ exports.writeUnicodeStringWithoutLength = writeUnicodeStringWithoutLength;
 exports.writeUnicodeStringWithoutLengthLE = writeUnicodeStringWithoutLengthLE;
 exports.writeUnicodeString = writeUnicodeString;
 exports.writeUnicodeStringWithPadding = writeUnicodeStringWithPadding;
+exports.getRLEChannelBound = getRLEChannelBound;
+exports.writeUint64 = writeUint64;
 exports.writeSection = writeSection;
 exports.writePsd = writePsd;
 exports.writeColor = writeColor;
@@ -30,11 +32,12 @@ exports.writePattern = writePattern;
 const helpers_1 = require("./helpers");
 const additionalInfo_1 = require("./additionalInfo");
 const imageResources_1 = require("./imageResources");
+const psdReader_1 = require("./psdReader");
 function createWriter(size = 4096) {
     const buffer = new ArrayBuffer(size);
     const view = new DataView(buffer);
     const offset = 0;
-    return { buffer, view, offset, tempBuffer: undefined };
+    return { buffer, view, offset, tempBuffer: undefined, log: console.log };
 }
 function getWriterBuffer(writer) {
     return writer.buffer.slice(0, writer.offset);
@@ -146,59 +149,71 @@ function writeUnicodeStringWithPadding(writer, text) {
     }
     writeUint16(writer, 0);
 }
-function getLargestLayerSize(layers = []) {
+// Worst-case size of writeDataRLE output for a single channel: per row the byte count (2 bytes, 4 for PSB)
+// plus PackBits data, which in the worst case is all literal runs of up to 128 bytes, each with 1 header byte.
+function getRLEChannelBound(width, height, large) {
+    return height * ((large ? 4 : 2) + width + Math.ceil(width / 128));
+}
+function getLargestLayerSize(layers = [], large) {
     let max = 0;
     for (const layer of layers) {
-        const { width, height } = getLayerDimentions(layer);
-        max = Math.max(max, 2 * height + 2 * width * height);
-        if (layer.mask) {
-            const { width, height } = getLayerDimentions(layer.mask);
-            max = Math.max(max, 2 * height + 2 * width * height);
-        }
-        if (layer.realMask) {
-            const { width, height } = getLayerDimentions(layer.realMask);
-            max = Math.max(max, 2 * height + 2 * width * height);
+        for (const target of [layer, layer.mask, layer.realMask]) {
+            if (target) {
+                const { width, height } = getLayerDimentions(target);
+                max = Math.max(max, getRLEChannelBound(width, height, large));
+            }
         }
         if (layer.children) {
-            max = Math.max(max, getLargestLayerSize(layer.children));
+            max = Math.max(max, getLargestLayerSize(layer.children, large));
         }
     }
     return max;
 }
+function writeUint64(writer, value) {
+    writeUint32(writer, Math.floor(value / 0x100000000));
+    writeUint32(writer, value >>> 0);
+}
 function writeSection(writer, round, func, writeTotalLength = false, large = false) {
+    const offset = writer.offset;
     if (large)
         writeUint32(writer, 0);
-    const offset = writer.offset;
     writeUint32(writer, 0);
+    const start = writer.offset;
     func();
-    let length = writer.offset - offset - 4;
+    let length = writer.offset - start;
     let len = length;
     while (len % round) {
         writeUint8(writer, 0);
         len++;
     }
-    // while (writer.offset % round) {
-    // 	writeUint8(writer, 0);
-    // 	len++;
-    // }
     if (writeTotalLength) {
         length = len;
     }
-    writer.view.setUint32(offset, length, false);
+    if (large) {
+        writer.view.setUint32(offset, Math.floor(length / 0x100000000), false);
+        writer.view.setUint32(offset + 4, length >>> 0, false);
+    }
+    else {
+        if (length > 0xffffffff)
+            throw new Error('Section too large, use PSB format instead');
+        writer.view.setUint32(offset, length, false);
+    }
+}
+function verifyPixelData(data, name) {
+    // check element size instead of instanceof, so arrays from other realms (iframes, workers, vm) are accepted
+    const bytesPerElement = data && data.data.BYTES_PER_ELEMENT;
+    if (bytesPerElement !== undefined && bytesPerElement !== 1) {
+        throw new Error(`${name} has incorrect bitDepth (only 8-bit Uint8Array or Uint8ClampedArray data is supported for writing)`);
+    }
 }
 function verifyBitCount(target) {
-    var _a;
+    var _a, _b, _c;
     (_a = target.children) === null || _a === void 0 ? void 0 : _a.forEach(verifyBitCount);
-    const data = target.imageData;
-    if (data && (data.data instanceof Uint32Array || data.data instanceof Uint16Array)) {
-        throw new Error('imageData has incorrect bitDepth');
-    }
-    if ('mask' in target && target.mask) {
-        const data = target.mask.imageData;
-        if (data && (data.data instanceof Uint32Array || data.data instanceof Uint16Array)) {
-            throw new Error('mask imageData has incorrect bitDepth');
-        }
-    }
+    verifyPixelData(target.imageData, 'imageData');
+    if ('mask' in target)
+        verifyPixelData((_b = target.mask) === null || _b === void 0 ? void 0 : _b.imageData, 'mask imageData');
+    if ('realMask' in target)
+        verifyPixelData((_c = target.realMask) === null || _c === void 0 ? void 0 : _c.imageData, 'realMask imageData');
 }
 function writePsd(writer, psd, options = {}) {
     var _a;
@@ -209,9 +224,26 @@ function writePsd(writer, psd, options = {}) {
     const bitsPerChannel = (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
     if (bitsPerChannel !== 8)
         throw new Error('bitsPerChannel other than 8 are not supported for writing');
+    if (options.log)
+        writer.log = options.log;
+    const layers = [];
+    addChildren(layers, psd.children);
+    if (!layers.length)
+        layers.push({});
     verifyBitCount(psd);
     const imageResources = Object.assign({}, psd.imageResources);
     const opt = Object.assign(Object.assign({}, options), { layerIds: new Set(), layerToId: new Map() });
+    // document is always written in RGB color mode, skip resources specific to original color mode
+    if (psd.colorMode !== undefined && psd.colorMode !== 3 /* ColorMode.RGB */) {
+        delete imageResources.iccProfile;
+        delete imageResources.indexedColorCount;
+        delete imageResources.transparencyIndex;
+        delete imageResources.alphaChannelDisplayInfo;
+        delete imageResources.colorHalftoneScreens;
+        delete imageResources.grayscaleHalftoneScreens;
+        delete imageResources.colorTransferFunctions;
+        delete imageResources.grayscaleTransferFunctions;
+    }
     if (opt.generateThumbnail) {
         imageResources.thumbnail = createThumbnail(psd);
     }
@@ -219,11 +251,14 @@ function writePsd(writer, psd, options = {}) {
     if (!imageData && psd.canvas) {
         imageData = psd.canvas.getContext('2d').getImageData(0, 0, psd.canvas.width, psd.canvas.height);
     }
+    if (!imageData && psd.rawCompositeData) { // read with `useRawData` option
+        imageData = (0, psdReader_1.getCompositeImageData)(psd);
+    }
     if (imageData && (psd.width !== imageData.width || psd.height !== imageData.height))
         throw new Error('Document canvas must have the same size as document');
     const globalAlpha = !!imageData && (0, helpers_1.hasAlpha)(imageData);
-    const maxBufferSize = Math.max(getLargestLayerSize(psd.children), 4 * 2 * psd.width * psd.height + 2 * psd.height);
-    writer.tempBuffer = new Uint8Array(maxBufferSize);
+    // only used for encoding a single layer channel at a time, composite image is encoded directly into the writer buffer
+    writer.tempBuffer = new Uint8Array(getLargestLayerSize(psd.children, !!options.psb));
     // header
     writeSignature(writer, '8BPS');
     writeUint16(writer, options.psb ? 2 : 1); // version
@@ -233,23 +268,8 @@ function writePsd(writer, psd, options = {}) {
     writeUint32(writer, psd.width);
     writeUint16(writer, bitsPerChannel); // bits per channel
     writeUint16(writer, 3 /* ColorMode.RGB */); // we only support saving RGB right now
-    // color mode data
-    writeSection(writer, 1, () => {
-        var _a, _b, _c;
-        if (psd.palette) {
-            for (let i = 0; i < 256; i++)
-                writeUint8(writer, ((_a = psd.palette[i]) === null || _a === void 0 ? void 0 : _a.r) || 0);
-            for (let i = 0; i < 256; i++)
-                writeUint8(writer, ((_b = psd.palette[i]) === null || _b === void 0 ? void 0 : _b.g) || 0);
-            for (let i = 0; i < 256; i++)
-                writeUint8(writer, ((_c = psd.palette[i]) === null || _c === void 0 ? void 0 : _c.b) || 0);
-        }
-        // TODO: other data?
-    });
-    const layers = [];
-    addChildren(layers, psd.children);
-    if (!layers.length)
-        layers.push({});
+    // color mode data (empty for RGB color mode)
+    writeUint32(writer, 0);
     // image resources
     imageResources.layersGroup = layers.map(l => l.linkGroup || 0);
     imageResources.layerGroupsEnabledId = layers.map(l => l.linkGroupEnabled == false ? 0 : 1);
@@ -258,10 +278,12 @@ function writePsd(writer, psd, options = {}) {
             const has = handler.has(imageResources);
             const count = has === false ? 0 : (has === true ? 1 : has);
             for (let i = 0; i < count; i++) {
+                const id = handler.keyCount > 1 ? handler.key + i : handler.key;
+                const name = handler.name ? handler.name(imageResources, i) : '';
                 writeSignature(writer, '8BIM');
-                writeUint16(writer, handler.key);
-                writePascalString(writer, '', 2);
-                writeSection(writer, 2, () => handler.write(writer, imageResources, i));
+                writeUint16(writer, id);
+                writePascalString(writer, name, 2);
+                writeSection(writer, 2, () => handler.write(writer, imageResources, i, psd));
             }
         }
     });
@@ -271,42 +293,45 @@ function writePsd(writer, psd, options = {}) {
         writeGlobalLayerMaskInfo(writer, psd.globalLayerMaskInfo);
         writeAdditionalLayerInfo(writer, psd, psd, opt);
     }, undefined, !!opt.psb);
+    writer.tempBuffer = undefined;
     // image data
-    const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
-    const width = imageData ? imageData.width : psd.width;
-    const height = imageData ? imageData.height : psd.height;
-    const data = { data: new Uint8Array(width * height * 4), width, height };
     writeUint16(writer, 1 /* Compression.RleCompressed */); // Photoshop doesn't support zip compression of composite image data
-    if (helpers_1.RAW_IMAGE_DATA && psd.imageDataRaw) {
-        console.log('writing raw image data');
-        writeBytes(writer, psd.imageDataRaw);
-    }
-    else {
-        if (imageData)
-            data.data.set(new Uint8Array(imageData.data.buffer, imageData.data.byteOffset, imageData.data.byteLength));
-        // add weird white matte
-        if (globalAlpha) {
-            const size = data.width * data.height * 4;
-            const p = data.data;
-            for (let i = 0; i < size; i += 4) {
-                const pa = p[i + 3];
-                if (pa != 0 && pa != 255) {
-                    const a = pa / 255;
-                    const ra = 255 * (1 - a);
-                    p[i + 0] = p[i + 0] * a + ra;
-                    p[i + 1] = p[i + 1] * a + ra;
-                    p[i + 2] = p[i + 2] * a + ra;
-                }
+    const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
+    const data = getCompositeData(imageData, psd.width, psd.height, globalAlpha);
+    // encode directly into the writer buffer
+    const maxSize = channels.length * getRLEChannelBound(data.width, data.height, !!options.psb);
+    ensureSize(writer, writer.offset + maxSize);
+    const buffer = new Uint8Array(writer.buffer, writer.offset, maxSize);
+    writer.offset += (0, helpers_1.writeDataRLE)(buffer, data, channels, !!options.psb).length;
+}
+function getCompositeData(imageData, width, height, globalAlpha) {
+    if (!imageData)
+        return { data: new Uint8Array(width * height * 4), width, height };
+    const size = width * height * 4;
+    const src = imageData.data;
+    let dst = undefined;
+    // add weird white matte (copy the data only if there are semi-transparent pixels)
+    if (globalAlpha) {
+        for (let i = 0; i < size; i += 4) {
+            const pa = src[i + 3];
+            if (pa != 0 && pa != 255) {
+                if (!dst)
+                    dst = new Uint8Array(src.buffer, src.byteOffset, size).slice();
+                const a = pa / 255;
+                const ra = 255 * (1 - a);
+                dst[i + 0] = src[i + 0] * a + ra;
+                dst[i + 1] = src[i + 1] * a + ra;
+                dst[i + 2] = src[i + 2] * a + ra;
             }
         }
-        writeBytes(writer, (0, helpers_1.writeDataRLE)(writer.tempBuffer, data, channels, !!options.psb));
     }
+    return dst ? { data: dst, width, height } : imageData;
 }
 function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
     writeSection(writer, 4, () => {
         var _a;
         writeInt16(writer, globalAlpha ? -layers.length : layers.length);
-        const layersData = layers.map((l, i) => getChannels(writer.tempBuffer, l, i === 0, options));
+        const layersData = layers.map((l, i) => getChannels(writer, l, i === 0, options));
         // layer records
         for (const layerData of layersData) {
             const { layer, top, left, bottom, right, channels } = layerData;
@@ -317,9 +342,12 @@ function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
             writeUint16(writer, channels.length);
             for (const c of channels) {
                 writeInt16(writer, c.id);
-                if (options.psb)
-                    writeUint32(writer, 0);
-                writeUint32(writer, c.length);
+                if (options.psb) {
+                    writeUint64(writer, c.length);
+                }
+                else {
+                    writeUint32(writer, c.length);
+                }
             }
             writeSignature(writer, '8BIM');
             writeSignature(writer, helpers_1.fromBlendMode[layer.blendMode] || 'norm');
@@ -355,8 +383,13 @@ function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
         }
     }, true, options.psb);
 }
-function writeLayerMaskData(writer, { mask, realMask }, layerData) {
-    writeSection(writer, 1, () => {
+// real mask is only stored separately if layer has both vector and pixel masks, otherwise it's stored as the main mask
+function getMasks(layer) {
+    return layer.mask ? { mask: layer.mask, realMask: layer.realMask } : { mask: layer.realMask, realMask: undefined };
+}
+function writeLayerMaskData(writer, layer, layerData) {
+    const { mask, realMask } = getMasks(layer);
+    writeSection(writer, 4, () => {
         if (!mask && !realMask)
             return;
         let params = 0, flags = 0, realFlags = 0;
@@ -411,8 +444,7 @@ function writeLayerMaskData(writer, { mask, realMask }, layerData) {
             if (mask.vectorMaskFeather !== undefined)
                 writeFloat64(writer, mask.vectorMaskFeather);
         }
-        writeZeros(writer, 2);
-    });
+    }, true); // photoshop pads mask data to multiple of 4 bytes and includes padding in the length
 }
 function writerBlendingRange(writer, range) {
     writeUint8(writer, range[0]);
@@ -441,7 +473,7 @@ function writeGlobalLayerMaskInfo(writer, info) {
             writeUint16(writer, info.colorSpace2);
             writeUint16(writer, info.colorSpace3);
             writeUint16(writer, info.colorSpace4);
-            writeUint16(writer, Math.round(info.opacity * 0xff));
+            writeUint16(writer, Math.round((0, helpers_1.clamp)(info.opacity, 0, 1) * 100)); // 0-100
             writeUint8(writer, info.kind);
             writeZeros(writer, 3);
         }
@@ -452,13 +484,13 @@ function writeAdditionalLayerInfo(writer, target, psd, options) {
         let key = handler.key;
         if (key === 'Txt2' && options.invalidateTextLayers)
             continue;
-        if (key === 'vmsk' && options.psb)
-            key = 'vsms';
+        if (key === 'vmsk' && additionalInfo_1.infoHandlersMap['vscg'].has(target))
+            key = 'vsms'; // Photoshop uses 'vsms' for layers with vector stroke
         if (handler.has(target)) {
             const large = options.psb && helpers_1.largeAdditionalInfoKeys.indexOf(key) !== -1;
             const writeTotalLength = key !== 'Txt2' && key !== 'cinf' && key !== 'extn' && key !== 'CAI ' && key !== 'OCIO';
             const fourBytes = key === 'levl' || key === 'Txt2' || key === 'luni' || key === 'vmsk' || key === 'artb' || key === 'artd' ||
-                key === 'vogk' || key === 'SoLd' || key === 'lnk2' || key === 'vscg' || key === 'vsms' || key === 'GdFl' ||
+                key === 'vogk' || key === 'SoLd' || key === 'SoLE' || key === 'lnk2' || key === 'vscg' || key === 'vsms' || key === 'GdFl' ||
                 key === 'lmfx' || key === 'lrFX' || key === 'cinf' || key === 'PlLd' || key === 'Anno' || key === 'CAI ' || key === 'OCIO' || key === 'GenI' || key === 'FEid' || key === 'curv' || key === 'CgEd' || key === 'vibA' || key === 'blwh' || key === 'grdm';
             writeSignature(writer, large ? '8B64' : '8BIM');
             writeSignature(writer, key);
@@ -509,10 +541,8 @@ function addChildren(layers, children) {
     }
 }
 function resizeBuffer(writer, size) {
-    let newLength = writer.buffer.byteLength;
-    do {
-        newLength *= 2;
-    } while (size > newLength);
+    // grow at least 2x to keep small writes fast, but don't overshoot large reservations (like composite image data)
+    const newLength = Math.max(writer.buffer.byteLength * 2, size);
     const newBuffer = new ArrayBuffer(newLength);
     const newBytes = new Uint8Array(newBuffer);
     const oldBytes = new Uint8Array(writer.buffer);
@@ -535,12 +565,12 @@ function createThumbnail(psd) {
     let scale = 1;
     if (psd.width > psd.height) {
         canvas.width = 160;
-        canvas.height = Math.floor(psd.height * (canvas.width / psd.width));
+        canvas.height = Math.max(1, Math.floor(psd.height * (canvas.width / psd.width)));
         scale = canvas.width / psd.width;
     }
     else {
         canvas.height = 160;
-        canvas.width = Math.floor(psd.width * (canvas.height / psd.height));
+        canvas.width = Math.max(1, Math.floor(psd.width * (canvas.height / psd.height)));
         scale = canvas.height / psd.height;
     }
     const context = canvas.getContext('2d');
@@ -553,7 +583,7 @@ function createThumbnail(psd) {
     }
     return canvas;
 }
-function getMaskChannels(tempBuffer, layerData, layer, mask, options, realMask) {
+function getMaskChannels(tempBuffer, layerData, mask, options, realMask) {
     let top = mask.top | 0;
     let left = mask.left | 0;
     let right = mask.right | 0;
@@ -570,11 +600,7 @@ function getMaskChannels(tempBuffer, layerData, layer, mask, options, realMask)
     bottom = top + height;
     let buffer;
     let compression;
-    if (helpers_1.RAW_IMAGE_DATA && layer[realMask ? 'realMaskDataRaw' : 'maskDataRaw']) {
-        buffer = layer[realMask ? 'realMaskDataRaw' : 'maskDataRaw'];
-        compression = layer[realMask ? 'realMaskDataRawCompression' : 'maskDataRawCompression'];
-    }
-    else if (!imageData) {
+    if (!imageData) {
         buffer = new Uint8Array(0);
         compression = 1 /* Compression.RleCompressed */;
     }
@@ -583,7 +609,7 @@ function getMaskChannels(tempBuffer, layerData, layer, mask, options, realMask)
         compression = 2 /* Compression.ZipWithoutPrediction */;
     }
     else {
-        buffer = (0, helpers_1.writeDataRLE)(tempBuffer, imageData, [0], !!options.psb);
+        buffer = (0, helpers_1.writeDataRLE)(tempBuffer, imageData, [0], !!options.psb).slice(); // copy, temp buffer is reused
         compression = 1 /* Compression.RleCompressed */;
     }
     layerData.channels.push({ id: realMask ? -3 /* ChannelID.RealUserMask */ : -2 /* ChannelID.UserMask */, compression, data: buffer, length: 2 + buffer.length });
@@ -597,15 +623,32 @@ function bounds(obj) {
         bottom: obj.bottom || 0,
     } : undefined;
 }
-function getChannels(tempBuffer, layer, background, options) {
+function getChannels(writer, layer, background, options) {
+    let source = layer;
     if (layer.rawData) {
-        return Object.assign(Object.assign({ layer, channels: layer.rawData.channels.map(c => { var _a, _b; return (Object.assign(Object.assign({}, c), { length: 2 + ((_b = (_a = c.data) === null || _a === void 0 ? void 0 : _a.byteLength) !== null && _b !== void 0 ? _b : 0) })); }) }, bounds(layer)), { mask: bounds(layer.mask), realMask: bounds(layer.realMask) });
-    }
-    const layerData = getLayerChannels(tempBuffer, layer, background, options);
-    if (layer.mask)
-        getMaskChannels(tempBuffer, layerData, layer, layer.mask, options, false);
-    if (layer.realMask)
-        getMaskChannels(tempBuffer, layerData, layer, layer.realMask, options, true);
+        const { colorMode, bitsPerChannel, large } = layer.rawData;
+        if (large === !!options.psb && colorMode === 3 /* ColorMode.RGB */ && bitsPerChannel === 8) {
+            // same mask mapping as in writeLayerMaskData
+            const { mask, realMask } = getMasks(layer);
+            return Object.assign(Object.assign({ layer, channels: layer.rawData.channels.map(c => { var _a, _b; return (Object.assign(Object.assign({}, c), { length: 2 + ((_b = (_a = c.data) === null || _a === void 0 ? void 0 : _a.byteLength) !== null && _b !== void 0 ? _b : 0) })); }) }, bounds(layer)), { mask: bounds(mask), realMask: bounds(realMask) });
+        }
+        if (bitsPerChannel !== 8)
+            throw new Error('Layer raw data with bitsPerChannel other than 8 is not supported for writing');
+        // raw data is in different format than the one we're writing, decode it so it can be re-encoded
+        source = Object.assign(Object.assign({}, layer), { rawData: undefined, canvas: undefined, imageData: (0, psdReader_1.getLayerImageData)(layer), mask: layer.mask && Object.assign(Object.assign({}, layer.mask), { canvas: undefined, imageData: (0, psdReader_1.getLayerMaskImageData)(layer) }), realMask: layer.realMask && Object.assign(Object.assign({}, layer.realMask), { canvas: undefined, imageData: (0, psdReader_1.getLayerRealMaskImageData)(layer) }) });
+        // temp buffer is sized only for layers with image data, grow it and keep it for following layers
+        const size = getLargestLayerSize([Object.assign(Object.assign({}, source), { children: undefined })], !!options.psb);
+        if (writer.tempBuffer.byteLength < size)
+            writer.tempBuffer = new Uint8Array(size);
+    }
+    const tempBuffer = writer.tempBuffer;
+    const { mask, realMask } = getMasks(source);
+    const layerData = getLayerChannels(tempBuffer, source, background, options);
+    if (mask)
+        getMaskChannels(tempBuffer, layerData, mask, options, false);
+    if (realMask)
+        getMaskChannels(tempBuffer, layerData, realMask, options, true);
+    layerData.layer = layer;
     return layerData;
 }
 function getLayerDimentions({ canvas, imageData }) {
@@ -635,7 +678,6 @@ function cropImageData(data, left, top, width, height) {
     return croppedData;
 }
 function getLayerChannels(tempBuffer, layer, background, options) {
-    var _a;
     let top = layer.top | 0;
     let left = layer.left | 0;
     let right = layer.right | 0;
@@ -674,24 +716,19 @@ function getLayerChannels(tempBuffer, layer, background, options) {
         1 /* ChannelID.Color1 */,
         2 /* ChannelID.Color2 */,
     ];
-    if (!background || options.noBackground || layer.mask || (0, helpers_1.hasAlpha)(imageData) || (helpers_1.RAW_IMAGE_DATA && ((_a = layer.imageDataRaw) === null || _a === void 0 ? void 0 : _a['-1']))) {
+    if (!background || options.noBackground || layer.mask || (0, helpers_1.hasAlpha)(imageData)) {
         channelIds.unshift(-1 /* ChannelID.Transparency */);
     }
     channels = channelIds.map(id => {
-        const offset = (0, helpers_1.offsetForChannel)(id, false); // TODO: psd.colorMode === ColorMode.CMYK);
+        const offset = (0, helpers_1.offsetForChannel)(id, false); // image data is always RGBA
         let data;
         let compression;
-        if (helpers_1.RAW_IMAGE_DATA && layer.imageDataRaw) {
-            // console.log('written raw layer image data');
-            data = layer.imageDataRaw[id];
-            compression = layer.imageDataRawCompression[id];
-        }
-        else if (options.compress) {
+        if (options.compress) {
             data = (0, helpers_1.writeDataZipWithoutPrediction)(imageData, [offset]);
             compression = 2 /* Compression.ZipWithoutPrediction */;
         }
         else {
-            data = (0, helpers_1.writeDataRLE)(tempBuffer, imageData, [offset], !!options.psb);
+            data = (0, helpers_1.writeDataRLE)(tempBuffer, imageData, [offset], !!options.psb).slice(); // copy, temp buffer is reused
             compression = 1 /* Compression.RleCompressed */;
         }
         return { id, compression, data, length: 2 + data.length };
@@ -755,8 +792,8 @@ function writeColor(writer, color) {
     else if ('l' in color) {
         writeUint16(writer, 7 /* ColorSpace.Lab */);
         writeInt16(writer, Math.round(color.l * 10000));
-        writeInt16(writer, Math.round(color.a < 0 ? (color.a * 12800) : (color.a * 12700)));
-        writeInt16(writer, Math.round(color.b < 0 ? (color.b * 12800) : (color.b * 12700)));
+        writeInt16(writer, Math.round((0, helpers_1.denormalizeLabAB)(color.a, 100)));
+        writeInt16(writer, Math.round((0, helpers_1.denormalizeLabAB)(color.b, 100)));
         writeUint16(writer, 0);
     }
     else if ('h' in color) {
@@ -767,11 +804,12 @@ function writeColor(writer, color) {
         writeUint16(writer, 0);
     }
     else if ('c' in color) {
+        // 0 = 100% ink
         writeUint16(writer, 2 /* ColorSpace.CMYK */);
-        writeUint16(writer, Math.round(color.c * 257));
-        writeUint16(writer, Math.round(color.m * 257));
-        writeUint16(writer, Math.round(color.y * 257));
-        writeUint16(writer, Math.round(color.k * 257));
+        writeUint16(writer, 0xffff - Math.round((0, helpers_1.clamp)(color.c, 0, 255) * 257));
+        writeUint16(writer, 0xffff - Math.round((0, helpers_1.clamp)(color.m, 0, 255) * 257));
+        writeUint16(writer, 0xffff - Math.round((0, helpers_1.clamp)(color.y, 0, 255) * 257));
+        writeUint16(writer, 0xffff - Math.round((0, helpers_1.clamp)(color.k, 0, 255) * 257));
     }
     else {
         writeUint16(writer, 8 /* ColorSpace.Grayscale */);
@@ -806,6 +844,9 @@ function writePattern(writer, pattern) {
     writeUint32(writer, bottom);
     writeUint32(writer, right);
     writeUint32(writer, 24); // channels count
+    // ponytail: pattern channels always use small (2-byte) RLE scanline headers, matching
+    // readPattern which reads them as non-large
+    const buffer = new Uint8Array(getRLEChannelBound(width, height, false));
     // channels: RGB at indices 0,1,2 and alpha at index 25
     for (let i = 0; i < 24 + 2; i++) {
         const offset = i < 3 ? i : (i === 25 ? 3 : -1);
@@ -813,10 +854,6 @@ function writePattern(writer, pattern) {
             writeUint32(writer, 0); // has
             continue;
         }
-        // worst-case RLE size for a single channel: width + 1 per scanline, plus scanline length headers
-        const buffer = new Uint8Array(width * height + 2 * height + 2 * width + 16);
-        // ponytail: pattern channels always use small (2-byte) RLE scanline headers, matching
-        // readPattern which reads them as non-large; `large` here only affects the header width.
         const data = (0, helpers_1.writeDataRLE)(buffer, pixelData, [offset], false);
         writeUint32(writer, 1); // has
         writeUint32(writer, data.length + 4 + 16 + 2 + 1); // length