ag-psd 33.0.0 → 34.0.0

package/dist-es/psdWriter.js

@@ -30,6 +30,7 @@ exports.writePsd = writePsd;
 exports.writeColor = writeColor;
 exports.writePattern = writePattern;
 const helpers_1 = require("./helpers");
+const pako_1 = require("pako");
 const additionalInfo_1 = require("./additionalInfo");
 const imageResources_1 = require("./imageResources");
 const psdReader_1 = require("./psdReader");
@@ -202,10 +203,33 @@ function writeSection(writer, round, func, writeTotalLength = false, large = fal
 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)`);
+    if (bytesPerElement !== undefined && bytesPerElement !== 1 && bytesPerElement !== 2 && !(data.data instanceof Float32Array)) {
+        throw new Error(`${name} has incorrect bitDepth (only Uint8Array, Uint8ClampedArray, Uint16Array and Float32Array data is supported for writing)`);
     }
 }
+// supported bit depths for each color mode
+const writeBitDepths = {
+    [0 /* ColorMode.Bitmap */]: [1],
+    [1 /* ColorMode.Grayscale */]: [8, 16, 32],
+    [2 /* ColorMode.Indexed */]: [8],
+    [3 /* ColorMode.RGB */]: [8, 16, 32],
+    [4 /* ColorMode.CMYK */]: [8, 16],
+};
+const colorModeNames = {
+    [0 /* ColorMode.Bitmap */]: 'Bitmap', [1 /* ColorMode.Grayscale */]: 'Grayscale', [2 /* ColorMode.Indexed */]: 'Indexed', [3 /* ColorMode.RGB */]: 'RGB',
+    [4 /* ColorMode.CMYK */]: 'CMYK', [7 /* ColorMode.Multichannel */]: 'Multichannel', [8 /* ColorMode.Duotone */]: 'Duotone', [9 /* ColorMode.Lab */]: 'Lab',
+};
+function colorChannelsCount(colorMode) {
+    return colorMode === 3 /* ColorMode.RGB */ ? 3 : (colorMode === 4 /* ColorMode.CMYK */ ? 4 : 1);
+}
+// HDR toning settings that Photoshop stores in color mode data of 32bit documents (default values of new document),
+// Photoshop refuses to open 32bit documents without them
+const hdrToningData = [
+    104, 100, 114, 116, 0, 0, 0, 3, 62, 107, 133, 31, 0, 0, 0, 2, 0, 0, 0, 7, 0, 76, 0, 105, 0, 110, 0, 101, 0, 97, 0, 114, 0, 0,
+    0, 2, 0, 2, 0, 0, 0, 0, 0, 255, 0, 255, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 65, 128, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 63, 128, 0, 0,
+    104, 100, 114, 97, 0, 0, 0, 6, 0, 0, 0, 0, 65, 160, 0, 0, 65, 240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63, 128, 0, 0, 0, 0, 0, 0,
+    0, 0,
+];
 function verifyBitCount(target) {
     var _a, _b, _c;
     (_a = target.children) === null || _a === void 0 ? void 0 : _a.forEach(verifyBitCount);
@@ -216,34 +240,37 @@ function verifyBitCount(target) {
         verifyPixelData((_c = target.realMask) === null || _c === void 0 ? void 0 : _c.imageData, 'realMask imageData');
 }
 function writePsd(writer, psd, options = {}) {
-    var _a;
+    var _a, _b, _c, _d;
     if (!(+psd.width > 0 && +psd.height > 0))
         throw new Error('Invalid document size');
     if ((psd.width > 30000 || psd.height > 30000) && !options.psb)
         throw new Error('Document size is too large (max is 30000x30000, use PSB format instead)');
-    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');
+    const colorMode = (_a = psd.colorMode) !== null && _a !== void 0 ? _a : 3 /* ColorMode.RGB */;
+    const bitsPerChannel = (_b = psd.bitsPerChannel) !== null && _b !== void 0 ? _b : (colorMode === 0 /* ColorMode.Bitmap */ ? 1 : 8);
+    const bitDepths = writeBitDepths[colorMode];
+    if (!bitDepths)
+        throw new Error(`${(_c = colorModeNames[colorMode]) !== null && _c !== void 0 ? _c : colorMode} color mode is not supported for writing`);
+    if (bitDepths.indexOf(bitsPerChannel) === -1)
+        throw new Error(`bitsPerChannel ${bitsPerChannel} is not supported for writing in ${colorModeNames[colorMode]} color mode`);
+    // Photoshop doesn't support layers in bitmap and indexed color modes
+    const layersAllowed = colorMode !== 0 /* ColorMode.Bitmap */ && colorMode !== 2 /* ColorMode.Indexed */;
+    if (!layersAllowed && ((_d = psd.children) === null || _d === void 0 ? void 0 : _d.length))
+        throw new Error(`Layers are not supported in ${colorModeNames[colorMode]} color mode`);
+    if (colorMode === 2 /* ColorMode.Indexed */ && !psd.palette)
+        throw new Error('Missing color palette for Indexed color mode');
     if (options.log)
         writer.log = options.log;
+    if (options.logMissingFeatures)
+        writer.logMissingFeatures = true;
     const layers = [];
     addChildren(layers, psd.children);
-    if (!layers.length)
+    if (!layers.length && layersAllowed)
         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;
-    }
+    const opt = Object.assign(Object.assign({}, options), { layerIds: new Set(), layerToId: new Map(), colorMode, bitsPerChannel });
+    // 16 and 32 bit documents store layers in Lr16 / Lr32 section of global additional info
+    const layersInGlobalInfo = bitsPerChannel === 16 || bitsPerChannel === 32;
     if (opt.generateThumbnail) {
         imageResources.thumbnail = createThumbnail(psd);
     }
@@ -256,20 +283,34 @@ function writePsd(writer, psd, options = {}) {
     }
     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 globalAlpha = !!imageData && layersAllowed && (0, helpers_1.hasAlpha)(imageData);
     // 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
     writeZeros(writer, 6);
-    writeUint16(writer, globalAlpha ? 4 : 3); // channels
+    writeUint16(writer, colorChannelsCount(colorMode) + (globalAlpha ? 1 : 0)); // channels
     writeUint32(writer, psd.height);
     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 (empty for RGB color mode)
-    writeUint32(writer, 0);
+    writeUint16(writer, colorMode);
+    // color mode data
+    writeSection(writer, 1, () => {
+        var _a, _b, _c, _d, _e, _f;
+        if (colorMode === 2 /* ColorMode.Indexed */) {
+            const palette = psd.palette;
+            for (let i = 0; i < 256; i++)
+                writeUint8(writer, (_b = (_a = palette[i]) === null || _a === void 0 ? void 0 : _a.r) !== null && _b !== void 0 ? _b : 0);
+            for (let i = 0; i < 256; i++)
+                writeUint8(writer, (_d = (_c = palette[i]) === null || _c === void 0 ? void 0 : _c.g) !== null && _d !== void 0 ? _d : 0);
+            for (let i = 0; i < 256; i++)
+                writeUint8(writer, (_f = (_e = palette[i]) === null || _e === void 0 ? void 0 : _e.b) !== null && _f !== void 0 ? _f : 0);
+        }
+        else if (bitsPerChannel === 32) {
+            writeBytes(writer, new Uint8Array(hdrToningData));
+        }
+    });
     // image resources
     imageResources.layersGroup = layers.map(l => l.linkGroup || 0);
     imageResources.layerGroupsEnabledId = layers.map(l => l.linkGroupEnabled == false ? 0 : 1);
@@ -289,20 +330,202 @@ function writePsd(writer, psd, options = {}) {
     });
     // layer and mask info
     writeSection(writer, 2, () => {
-        writeLayerInfo(writer, layers, psd, globalAlpha, opt);
+        if (layersInGlobalInfo || !layersAllowed) {
+            writeSection(writer, 4, () => { }, true, opt.psb); // empty layer info
+        }
+        else {
+            writeLayerInfo(writer, layers, psd, globalAlpha, opt);
+        }
         writeGlobalLayerMaskInfo(writer, psd.globalLayerMaskInfo);
+        if (layersInGlobalInfo) {
+            if (globalAlpha)
+                writeGlobalInfoSection(writer, bitsPerChannel === 16 ? 'Mt16' : 'Mt32', !!opt.psb, () => { });
+            writeGlobalInfoSection(writer, bitsPerChannel === 16 ? 'Lr16' : 'Lr32', !!opt.psb, () => {
+                writeLayerInfoData(writer, layers, psd, globalAlpha, opt);
+            });
+        }
         writeAdditionalLayerInfo(writer, psd, psd, opt);
     }, undefined, !!opt.psb);
     writer.tempBuffer = undefined;
     // image data
-    writeUint16(writer, 1 /* Compression.RleCompressed */); // Photoshop doesn't support zip compression of composite image data
-    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;
+    if (colorMode === 3 /* ColorMode.RGB */ && bitsPerChannel === 8 && (!imageData || is8bit(imageData))) {
+        writeUint16(writer, 1 /* Compression.RleCompressed */); // Photoshop doesn't support zip compression of composite image data
+        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;
+    }
+    else {
+        writeCompositeImageData(writer, psd, imageData, colorMode, bitsPerChannel, globalAlpha, !!options.psb);
+    }
+}
+function writeGlobalInfoSection(writer, key, psb, func) {
+    writeSignature(writer, psb ? '8B64' : '8BIM');
+    writeSignature(writer, key);
+    writeSection(writer, 4, func, false, psb);
+}
+function is8bit(data) {
+    return data.data.BYTES_PER_ELEMENT === 1;
+}
+// converts image data (8, 16 or 32 bit RGBA data) to channels of the document color mode and bit depth
+function getPlanarChannels(imageData, colorMode, bitsPerChannel, matte) {
+    const { data, width, height } = imageData;
+    const size = width * height;
+    const srcFloat = data instanceof Float32Array;
+    const srcMax = srcFloat ? 1 : (data instanceof Uint16Array ? 0xffff : 0xff);
+    const dstFloat = bitsPerChannel === 32;
+    const dstMax = dstFloat ? 1 : (bitsPerChannel === 16 ? 0xffff : 0xff);
+    const colorCount = colorChannelsCount(colorMode);
+    const create = () => dstFloat ? new Float32Array(size) : (bitsPerChannel === 16 ? new Uint16Array(size) : new Uint8Array(size));
+    const colors = [];
+    for (let i = 0; i < colorCount; i++)
+        colors.push(create());
+    const alpha = create();
+    // color values are gamma corrected when converting between float (linear) and integer values (same as imageDataToCanvas)
+    const toNormalized = (v) => srcFloat ? Math.pow((0, helpers_1.clamp)(v, 0, 1), 1 / 2.2) : v / srcMax;
+    const fromNormalized = (v) => dstFloat ? Math.pow(v, 2.2) : Math.round((0, helpers_1.clamp)(v, 0, 1) * dstMax);
+    const sameType = srcFloat === dstFloat && srcMax === dstMax;
+    const convertColor = (v) => sameType ? (dstFloat ? v : Math.round(v)) : fromNormalized(toNormalized(v));
+    const convertAlpha = (v) => sameType ? v : (dstFloat ? v / srcMax : Math.round((0, helpers_1.clamp)(v / srcMax, 0, 1) * dstMax));
+    const cmyk = [0, 0, 0, 0];
+    for (let i = 0, p = 0; i < size; i++, p += 4) {
+        const a = data[p + 3];
+        const alphaValue = convertAlpha(a);
+        alpha[i] = alphaValue;
+        // composite image colors are blended with white (or no ink) for documents with transparency
+        const blend = matte && a !== srcMax && a > 0 ? (0, helpers_1.clamp)(a / srcMax, 0, 1) : 1;
+        if (colorMode === 4 /* ColorMode.CMYK */) {
+            (0, helpers_1.rgbToCmykValues)(toNormalized(data[p]), toNormalized(data[p + 1]), toNormalized(data[p + 2]), cmyk);
+            for (let j = 0; j < 4; j++) {
+                colors[j][i] = Math.round((1 - (0, helpers_1.clamp)(cmyk[j] * blend, 0, 1)) * dstMax); // stored inverted (0 = 100% ink)
+            }
+        }
+        else {
+            for (let j = 0; j < colorCount; j++) {
+                let value;
+                if (colorMode === 3 /* ColorMode.RGB */) {
+                    value = convertColor(data[p + j]);
+                }
+                else {
+                    const r = data[p], g = data[p + 1], b = data[p + 2];
+                    value = convertColor((r === g && g === b) ? r : (0.299 * r + 0.587 * g + 0.114 * b));
+                }
+                if (blend !== 1)
+                    value = dstFloat ? value * blend + 1 - blend : Math.round(value * blend + dstMax * (1 - blend));
+                colors[j][i] = value;
+            }
+        }
+    }
+    return { colors, alpha };
+}
+function encodeChannel(values, width, height, options) {
+    if (!(values instanceof Uint8Array)) {
+        return { data: (0, helpers_1.writeDataZipWithPrediction)(values, width, height), compression: 3 /* Compression.ZipWithPrediction */ };
+    }
+    else if (options.compress) {
+        return { data: (0, pako_1.deflate)(values), compression: 2 /* Compression.ZipWithoutPrediction */ };
+    }
+    else {
+        return { data: (0, helpers_1.writeDataRLEBytes)(values, width, height, !!options.psb), compression: 1 /* Compression.RleCompressed */ };
+    }
+}
+function writeCompositeImageData(writer, psd, imageData, colorMode, bitsPerChannel, globalAlpha, psb) {
+    var _a;
+    const { width, height } = psd;
+    const data = imageData !== null && imageData !== void 0 ? imageData : { data: new Uint8Array(width * height * 4), width, height };
+    const parts = [];
+    if (colorMode === 0 /* ColorMode.Bitmap */ || colorMode === 2 /* ColorMode.Indexed */) {
+        const values = colorMode === 0 /* ColorMode.Bitmap */ ?
+            getBitmapData(data) :
+            getIndexedData(data, psd.palette, (_a = psd.imageResources) === null || _a === void 0 ? void 0 : _a.transparencyIndex);
+        const rowBytes = colorMode === 0 /* ColorMode.Bitmap */ ? Math.ceil(width / 8) : width;
+        if (colorMode === 0 /* ColorMode.Bitmap */) {
+            writeUint16(writer, 0 /* Compression.RawData */);
+            parts.push(values);
+        }
+        else {
+            writeUint16(writer, 1 /* Compression.RleCompressed */);
+            parts.push((0, helpers_1.writeDataRLEBytes)(values, rowBytes, height, psb));
+        }
+    }
+    else {
+        const { colors, alpha } = getPlanarChannels(data, colorMode, bitsPerChannel, globalAlpha);
+        const channels = globalAlpha ? [...colors, alpha] : colors;
+        if (bitsPerChannel === 8) {
+            // row byte counts for all channels are stored before data of all channels
+            const encoded = channels.map(c => (0, helpers_1.writeDataRLEBytes)(c, width, height, psb));
+            const countsSize = height * (psb ? 4 : 2);
+            writeUint16(writer, 1 /* Compression.RleCompressed */);
+            for (const e of encoded)
+                parts.push(e.subarray(0, countsSize));
+            for (const e of encoded)
+                parts.push(e.subarray(countsSize));
+        }
+        else {
+            writeUint16(writer, 0 /* Compression.RawData */); // Photoshop writes 16 and 32 bit composite image without compression
+            for (const c of channels)
+                parts.push((0, helpers_1.planarToBytes)(c));
+        }
+    }
+    for (const part of parts)
+        writeBytes(writer, part);
+}
+function getBitmapData({ data, width, height }) {
+    const rowBytes = Math.ceil(width / 8);
+    const result = new Uint8Array(rowBytes * height);
+    const max = data instanceof Float32Array ? 1 : (data instanceof Uint16Array ? 0xffff : 0xff);
+    for (let y = 0, p = 0; y < height; y++) {
+        for (let x = 0; x < width; x++, p += 4) {
+            const a = data[p + 3] / max;
+            const value = ((0.299 * data[p] + 0.587 * data[p + 1] + 0.114 * data[p + 2]) / max) * a + (1 - a); // blend with white
+            if (value < 0.5)
+                result[y * rowBytes + (x >> 3)] |= 0x80 >> (x & 7); // 1 = black
+        }
+    }
+    return result;
+}
+function getIndexedData({ data, width, height }, palette, transparencyIndex) {
+    const size = width * height;
+    const result = new Uint8Array(size);
+    const shift = data instanceof Uint16Array ? 8 : 0;
+    const cache = new Map();
+    for (let i = 0; i < palette.length && i < 256; i++) {
+        const key = (palette[i].r << 16) | (palette[i].g << 8) | palette[i].b;
+        if (i !== transparencyIndex && !cache.has(key))
+            cache.set(key, i);
+    }
+    for (let i = 0, p = 0; i < size; i++, p += 4) {
+        const read = (v) => data instanceof Float32Array ? Math.round(Math.pow((0, helpers_1.clamp)(v, 0, 1), 1 / 2.2) * 255) : (v >>> shift);
+        const a = data instanceof Float32Array ? data[p + 3] * 255 : (data[p + 3] >>> shift);
+        if (transparencyIndex !== undefined && transparencyIndex >= 0 && a < 128) {
+            result[i] = transparencyIndex;
+            continue;
+        }
+        const r = read(data[p]), g = read(data[p + 1]), b = read(data[p + 2]);
+        const key = (r << 16) | (g << 8) | b;
+        let index = cache.get(key);
+        if (index === undefined) {
+            // use closest color from the palette
+            let best = Infinity;
+            index = 0;
+            for (let j = 0; j < palette.length && j < 256; j++) {
+                if (j === transparencyIndex)
+                    continue;
+                const dr = palette[j].r - r, dg = palette[j].g - g, db = palette[j].b - b;
+                const distance = dr * dr + dg * dg + db * db;
+                if (distance < best) {
+                    best = distance;
+                    index = j;
+                }
+            }
+            cache.set(key, index);
+        }
+        result[i] = index;
+    }
+    return result;
 }
 function getCompositeData(imageData, width, height, globalAlpha) {
     if (!imageData)
@@ -328,60 +551,61 @@ function getCompositeData(imageData, width, height, globalAlpha) {
     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, l, i === 0, options));
-        // layer records
-        for (const layerData of layersData) {
-            const { layer, top, left, bottom, right, channels } = layerData;
-            writeInt32(writer, top);
-            writeInt32(writer, left);
-            writeInt32(writer, bottom);
-            writeInt32(writer, right);
-            writeUint16(writer, channels.length);
-            for (const c of channels) {
-                writeInt16(writer, c.id);
-                if (options.psb) {
-                    writeUint64(writer, c.length);
-                }
-                else {
-                    writeUint32(writer, c.length);
-                }
+    writeSection(writer, 4, () => writeLayerInfoData(writer, layers, psd, globalAlpha, options), true, options.psb);
+}
+function writeLayerInfoData(writer, layers, psd, globalAlpha, options) {
+    var _a;
+    writeInt16(writer, globalAlpha ? -layers.length : layers.length);
+    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;
+        writeInt32(writer, top);
+        writeInt32(writer, left);
+        writeInt32(writer, bottom);
+        writeInt32(writer, right);
+        writeUint16(writer, channels.length);
+        for (const c of channels) {
+            writeInt16(writer, c.id);
+            if (options.psb) {
+                writeUint64(writer, c.length);
             }
-            writeSignature(writer, '8BIM');
-            writeSignature(writer, helpers_1.fromBlendMode[layer.blendMode] || 'norm');
-            writeUint8(writer, Math.round((0, helpers_1.clamp)((_a = layer.opacity) !== null && _a !== void 0 ? _a : 1, 0, 1) * 255));
-            writeUint8(writer, layer.clipping ? 1 : 0);
-            let flags = 0x08; // 1 for Photoshop 5.0 and later, tells if bit 4 has useful information
-            if (layer.transparencyProtected)
-                flags |= 0x01;
-            if (layer.hidden)
-                flags |= 0x02;
-            if (layer.vectorMask || (layer.sectionDivider && layer.sectionDivider.type !== 0 /* SectionDividerType.Other */) || layer.adjustment) {
-                flags |= 0x10; // pixel data irrelevant to appearance of document
+            else {
+                writeUint32(writer, c.length);
             }
-            if (layer.effectsOpen)
-                flags |= 0x20;
-            writeUint8(writer, flags);
-            writeUint8(writer, 0); // filler
-            writeSection(writer, 1, () => {
-                writeLayerMaskData(writer, layer, layerData);
-                writeLayerBlendingRanges(writer, layer);
-                writePascalString(writer, (layer.name || '').substring(0, 255), 4);
-                writeAdditionalLayerInfo(writer, layer, psd, options);
-            });
         }
-        // layer channel image data
-        for (const layerData of layersData) {
-            for (const channel of layerData.channels) {
-                writeUint16(writer, channel.compression);
-                if (channel.data) {
-                    writeBytes(writer, channel.data);
-                }
+        writeSignature(writer, '8BIM');
+        writeSignature(writer, helpers_1.fromBlendMode[layer.blendMode] || 'norm');
+        writeUint8(writer, Math.round((0, helpers_1.clamp)((_a = layer.opacity) !== null && _a !== void 0 ? _a : 1, 0, 1) * 255));
+        writeUint8(writer, layer.clipping ? 1 : 0);
+        let flags = 0x08; // 1 for Photoshop 5.0 and later, tells if bit 4 has useful information
+        if (layer.transparencyProtected)
+            flags |= 0x01;
+        if (layer.hidden)
+            flags |= 0x02;
+        if (layer.vectorMask || (layer.sectionDivider && layer.sectionDivider.type !== 0 /* SectionDividerType.Other */) || layer.adjustment) {
+            flags |= 0x10; // pixel data irrelevant to appearance of document
+        }
+        if (layer.effectsOpen)
+            flags |= 0x20;
+        writeUint8(writer, flags);
+        writeUint8(writer, 0); // filler
+        writeSection(writer, 1, () => {
+            writeLayerMaskData(writer, layer, layerData);
+            writeLayerBlendingRanges(writer, layer);
+            writePascalString(writer, (layer.name || '').substring(0, 255), 4);
+            writeAdditionalLayerInfo(writer, layer, psd, options);
+        });
+    }
+    // layer channel image data
+    for (const layerData of layersData) {
+        for (const channel of layerData.channels) {
+            writeUint16(writer, channel.compression);
+            if (channel.data) {
+                writeBytes(writer, channel.data);
             }
         }
-    }, true, options.psb);
+    }
 }
 // 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) {
@@ -584,6 +808,7 @@ function createThumbnail(psd) {
     return canvas;
 }
 function getMaskChannels(tempBuffer, layerData, mask, options, realMask) {
+    var _a;
     let top = mask.top | 0;
     let left = mask.left | 0;
     let right = mask.right | 0;
@@ -600,10 +825,15 @@ function getMaskChannels(tempBuffer, layerData, mask, options, realMask) {
     bottom = top + height;
     let buffer;
     let compression;
+    const bitsPerChannel = (_a = options.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
     if (!imageData) {
         buffer = new Uint8Array(0);
         compression = 1 /* Compression.RleCompressed */;
     }
+    else if (bitsPerChannel !== 8 || !is8bit(imageData)) {
+        const { colors } = getPlanarChannels(imageData, 3 /* ColorMode.RGB */, bitsPerChannel, false);
+        ({ data: buffer, compression } = encodeChannel(colors[0], width, height, options));
+    }
     else if (options.compress) {
         buffer = (0, helpers_1.writeDataZipWithoutPrediction)(imageData, [0]);
         compression = 2 /* Compression.ZipWithoutPrediction */;
@@ -624,16 +854,16 @@ function bounds(obj) {
     } : undefined;
 }
 function getChannels(writer, layer, background, options) {
+    var _a, _b;
     let source = layer;
     if (layer.rawData) {
         const { colorMode, bitsPerChannel, large } = layer.rawData;
-        if (large === !!options.psb && colorMode === 3 /* ColorMode.RGB */ && bitsPerChannel === 8) {
+        const opt = options;
+        if (large === !!options.psb && colorMode === ((_a = opt.colorMode) !== null && _a !== void 0 ? _a : 3 /* ColorMode.RGB */) && bitsPerChannel === ((_b = opt.bitsPerChannel) !== null && _b !== void 0 ? _b : 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
@@ -659,10 +889,8 @@ function getLayerDimentions({ canvas, imageData }) {
     return { width, height };
 }
 function cropImageData(data, left, top, width, height) {
-    if (data.data instanceof Uint32Array || data.data instanceof Uint16Array) {
-        throw new Error('imageData has incorrect bit depth');
-    }
-    const croppedData = (0, helpers_1.createImageData)(width, height);
+    const croppedData = is8bit(data) ? (0, helpers_1.createImageData)(width, height) :
+        { width, height, data: new data.data.constructor(width * height * 4) };
     const srcData = data.data;
     const dstData = croppedData.data;
     for (let y = 0; y < height; y++) {
@@ -678,6 +906,7 @@ function cropImageData(data, left, top, width, height) {
     return croppedData;
 }
 function getLayerChannels(tempBuffer, layer, background, options) {
+    var _a, _b;
     let top = layer.top | 0;
     let left = layer.left | 0;
     let right = layer.right | 0;
@@ -690,8 +919,11 @@ function getLayerChannels(tempBuffer, layer, background, options) {
     ];
     let { width, height } = getLayerDimentions(layer);
     if (!(layer.canvas || layer.imageData) || !width || !height) {
-        right = left;
-        bottom = top;
+        // layer without image data is empty, keep inverted (negative size) bounds from some files as they are
+        if (layer.right === undefined || right > left)
+            right = left;
+        if (layer.bottom === undefined || bottom > top)
+            bottom = top;
         return { layer, top, left, right, bottom, channels };
     }
     right = left + width;
@@ -719,6 +951,19 @@ function getLayerChannels(tempBuffer, layer, background, options) {
     if (!background || options.noBackground || layer.mask || (0, helpers_1.hasAlpha)(imageData)) {
         channelIds.unshift(-1 /* ChannelID.Transparency */);
     }
+    const colorMode = (_a = options.colorMode) !== null && _a !== void 0 ? _a : 3 /* ColorMode.RGB */;
+    const bitsPerChannel = (_b = options.bitsPerChannel) !== null && _b !== void 0 ? _b : 8;
+    if (colorMode !== 3 /* ColorMode.RGB */ || bitsPerChannel !== 8 || !is8bit(imageData)) {
+        const { colors, alpha } = getPlanarChannels(imageData, colorMode, bitsPerChannel, false);
+        const ids = channelIds[0] === -1 /* ChannelID.Transparency */ ? [-1 /* ChannelID.Transparency */] : [];
+        for (let i = 0; i < colors.length; i++)
+            ids.push(i);
+        channels = ids.map(id => {
+            const { data, compression } = encodeChannel(id === -1 /* ChannelID.Transparency */ ? alpha : colors[id], width, height, options);
+            return { id, compression, data, length: 2 + data.length };
+        });
+        return { layer, top, left, right, bottom, channels };
+    }
     channels = channelIds.map(id => {
         const offset = (0, helpers_1.offsetForChannel)(id, false); // image data is always RGBA
         let data;