ag-psd 30.1.0 → 30.2.0

package/dist-es/psdWriter.js

@@ -1,23 +1,11 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import { hasAlpha, createCanvas, writeDataRLE, offsetForChannel, createImageData, fromBlendMode, clamp, largeAdditionalInfoKeys, RAW_IMAGE_DATA, writeDataZipWithoutPrediction, imageDataToCanvas } from './helpers';
 import { infoHandlers } from './additionalInfo';
 import { resourceHandlers } from './imageResources';
-export function createWriter(size) {
-    if (size === void 0) { size = 4096; }
-    var buffer = new ArrayBuffer(size);
-    var view = new DataView(buffer);
-    var offset = 0;
-    return { buffer: buffer, view: view, offset: offset, tempBuffer: undefined };
+export function createWriter(size = 4096) {
+    const buffer = new ArrayBuffer(size);
+    const view = new DataView(buffer);
+    const offset = 0;
+    return { buffer, view, offset, tempBuffer: undefined };
 }
 export function getWriterBuffer(writer) {
     return writer.buffer.slice(0, writer.offset);
@@ -26,39 +14,39 @@ export function getWriterBufferNoCopy(writer) {
     return new Uint8Array(writer.buffer, 0, writer.offset);
 }
 export function writeUint8(writer, value) {
-    var offset = addSize(writer, 1);
+    const offset = addSize(writer, 1);
     writer.view.setUint8(offset, value);
 }
 export function writeInt16(writer, value) {
-    var offset = addSize(writer, 2);
+    const offset = addSize(writer, 2);
     writer.view.setInt16(offset, value, false);
 }
 export function writeUint16(writer, value) {
-    var offset = addSize(writer, 2);
+    const offset = addSize(writer, 2);
     writer.view.setUint16(offset, value, false);
 }
 export function writeUint16LE(writer, value) {
-    var offset = addSize(writer, 2);
+    const offset = addSize(writer, 2);
     writer.view.setUint16(offset, value, true);
 }
 export function writeInt32(writer, value) {
-    var offset = addSize(writer, 4);
+    const offset = addSize(writer, 4);
     writer.view.setInt32(offset, value, false);
 }
 export function writeInt32LE(writer, value) {
-    var offset = addSize(writer, 4);
+    const offset = addSize(writer, 4);
     writer.view.setInt32(offset, value, true);
 }
 export function writeUint32(writer, value) {
-    var offset = addSize(writer, 4);
+    const offset = addSize(writer, 4);
     writer.view.setUint32(offset, value, false);
 }
 export function writeFloat32(writer, value) {
-    var offset = addSize(writer, 4);
+    const offset = addSize(writer, 4);
     writer.view.setFloat32(offset, value, false);
 }
 export function writeFloat64(writer, value) {
-    var offset = addSize(writer, 8);
+    const offset = addSize(writer, 8);
     writer.view.setFloat64(offset, value, false);
 }
 // 32-bit fixed-point number 16.16
@@ -72,35 +60,35 @@ export function writeFixedPointPath32(writer, value) {
 export function writeBytes(writer, buffer) {
     if (buffer) {
         ensureSize(writer, writer.offset + buffer.length);
-        var bytes = new Uint8Array(writer.buffer);
+        const bytes = new Uint8Array(writer.buffer);
         bytes.set(buffer, writer.offset);
         writer.offset += buffer.length;
     }
 }
 export function writeZeros(writer, count) {
-    for (var i = 0; i < count; i++) {
+    for (let i = 0; i < count; i++) {
         writeUint8(writer, 0);
     }
 }
 export function writeSignature(writer, signature) {
     if (signature.length !== 4)
-        throw new Error("Invalid signature: '".concat(signature, "'"));
-    for (var i = 0; i < 4; i++) {
+        throw new Error(`Invalid signature: '${signature}'`);
+    for (let i = 0; i < 4; i++) {
         writeUint8(writer, signature.charCodeAt(i));
     }
 }
 export function writeAsciiString(writer, text) {
-    for (var i = 0; i < text.length; i++) {
+    for (let i = 0; i < text.length; i++) {
         writeUint8(writer, text.charCodeAt(i));
     }
 }
 export function writePascalString(writer, text, padTo) {
-    var length = text.length;
+    let length = text.length;
     if (length > 255)
-        throw new Error("String too long");
+        throw new Error(`String too long`);
     writeUint8(writer, length);
-    for (var i = 0; i < length; i++) {
-        var code = text.charCodeAt(i);
+    for (let i = 0; i < length; i++) {
+        const code = text.charCodeAt(i);
         // writeUint8(writer, code); // for testing
         writeUint8(writer, code < 128 ? code : '?'.charCodeAt(0));
     }
@@ -109,12 +97,12 @@ export function writePascalString(writer, text, padTo) {
     }
 }
 export function writeUnicodeStringWithoutLength(writer, text) {
-    for (var i = 0; i < text.length; i++) {
+    for (let i = 0; i < text.length; i++) {
         writeUint16(writer, text.charCodeAt(i));
     }
 }
 export function writeUnicodeStringWithoutLengthLE(writer, text) {
-    for (var i = 0; i < text.length; i++) {
+    for (let i = 0; i < text.length; i++) {
         writeUint16LE(writer, text.charCodeAt(i));
     }
 }
@@ -124,18 +112,16 @@ export function writeUnicodeString(writer, text) {
 }
 export function writeUnicodeStringWithPadding(writer, text) {
     writeUint32(writer, text.length + 1);
-    for (var i = 0; i < text.length; i++) {
+    for (let i = 0; i < text.length; i++) {
         writeUint16(writer, text.charCodeAt(i));
     }
     writeUint16(writer, 0);
 }
-function getLargestLayerSize(layers) {
-    if (layers === void 0) { layers = []; }
-    var max = 0;
-    for (var _i = 0, layers_1 = layers; _i < layers_1.length; _i++) {
-        var layer = layers_1[_i];
+function getLargestLayerSize(layers = []) {
+    let max = 0;
+    for (const layer of layers) {
         if (layer.canvas || layer.imageData) {
-            var _a = getLayerDimentions(layer), width = _a.width, height = _a.height;
+            const { width, height } = getLayerDimentions(layer);
             max = Math.max(max, 2 * height + 2 * width * height);
         }
         if (layer.children) {
@@ -144,16 +130,14 @@ function getLargestLayerSize(layers) {
     }
     return max;
 }
-export function writeSection(writer, round, func, writeTotalLength, large) {
-    if (writeTotalLength === void 0) { writeTotalLength = false; }
-    if (large === void 0) { large = false; }
+export function writeSection(writer, round, func, writeTotalLength = false, large = false) {
     if (large)
         writeUint32(writer, 0);
-    var offset = writer.offset;
+    const offset = writer.offset;
     writeUint32(writer, 0);
     func();
-    var length = writer.offset - offset - 4;
-    var len = length;
+    let length = writer.offset - offset - 4;
+    let len = length;
     while (len % round) {
         writeUint8(writer, 0);
         len++;
@@ -170,41 +154,40 @@ export function writeSection(writer, round, func, writeTotalLength, large) {
 function verifyBitCount(target) {
     var _a;
     (_a = target.children) === null || _a === void 0 ? void 0 : _a.forEach(verifyBitCount);
-    var data = target.imageData;
+    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) {
-        var data_1 = target.mask.imageData;
-        if (data_1 && (data_1.data instanceof Uint32Array || data_1.data instanceof Uint16Array)) {
+        const data = target.mask.imageData;
+        if (data && (data.data instanceof Uint32Array || data.data instanceof Uint16Array)) {
             throw new Error('mask imageData has incorrect bitDepth');
         }
     }
 }
-export function writePsd(writer, psd, options) {
+export function writePsd(writer, psd, options = {}) {
     var _a;
-    if (options === void 0) { options = {}; }
     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)');
-    var bitsPerChannel = (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
+    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');
     verifyBitCount(psd);
-    var imageResources = __assign({}, psd.imageResources);
-    var opt = __assign(__assign({}, options), { layerIds: new Set(), layerToId: new Map() });
+    const imageResources = Object.assign({}, psd.imageResources);
+    const opt = Object.assign(Object.assign({}, options), { layerIds: new Set(), layerToId: new Map() });
     if (opt.generateThumbnail) {
         imageResources.thumbnail = createThumbnail(psd);
     }
-    var imageData = psd.imageData;
+    let imageData = psd.imageData;
     if (!imageData && psd.canvas) {
         imageData = psd.canvas.getContext('2d').getImageData(0, 0, psd.canvas.width, psd.canvas.height);
     }
     if (imageData && (psd.width !== imageData.width || psd.height !== imageData.height))
         throw new Error('Document canvas must have the same size as document');
-    var globalAlpha = !!imageData && hasAlpha(imageData);
-    var maxBufferSize = Math.max(getLargestLayerSize(psd.children), 4 * 2 * psd.width * psd.height + 2 * psd.height);
+    const globalAlpha = !!imageData && hasAlpha(imageData);
+    const maxBufferSize = Math.max(getLargestLayerSize(psd.children), 4 * 2 * psd.width * psd.height + 2 * psd.height);
     writer.tempBuffer = new Uint8Array(maxBufferSize);
     // header
     writeSignature(writer, '8BPS');
@@ -216,55 +199,48 @@ export function writePsd(writer, psd, options) {
     writeUint16(writer, bitsPerChannel); // bits per channel
     writeUint16(writer, 3 /* ColorMode.RGB */); // we only support saving RGB right now
     // color mode data
-    writeSection(writer, 1, function () {
+    writeSection(writer, 1, () => {
         var _a, _b, _c;
         if (psd.palette) {
-            for (var i = 0; i < 256; i++)
+            for (let i = 0; i < 256; i++)
                 writeUint8(writer, ((_a = psd.palette[i]) === null || _a === void 0 ? void 0 : _a.r) || 0);
-            for (var i = 0; i < 256; i++)
+            for (let i = 0; i < 256; i++)
                 writeUint8(writer, ((_b = psd.palette[i]) === null || _b === void 0 ? void 0 : _b.g) || 0);
-            for (var i = 0; i < 256; i++)
+            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?
     });
-    var layers = [];
+    const layers = [];
     addChildren(layers, psd.children);
     if (!layers.length)
         layers.push({});
     // image resources
-    imageResources.layersGroup = layers.map(function (l) { return l.linkGroup || 0; });
-    imageResources.layerGroupsEnabledId = layers.map(function (l) { return l.linkGroupEnabled == false ? 0 : 1; });
-    writeSection(writer, 1, function () {
-        var _loop_1 = function (handler) {
-            var has = handler.has(imageResources);
-            var count = has === false ? 0 : (has === true ? 1 : has);
-            var _loop_2 = function (i) {
+    imageResources.layersGroup = layers.map(l => l.linkGroup || 0);
+    imageResources.layerGroupsEnabledId = layers.map(l => l.linkGroupEnabled == false ? 0 : 1);
+    writeSection(writer, 1, () => {
+        for (const handler of resourceHandlers) {
+            const has = handler.has(imageResources);
+            const count = has === false ? 0 : (has === true ? 1 : has);
+            for (let i = 0; i < count; i++) {
                 writeSignature(writer, '8BIM');
                 writeUint16(writer, handler.key);
                 writePascalString(writer, '', 2);
-                writeSection(writer, 2, function () { return handler.write(writer, imageResources, i); });
-            };
-            for (var i = 0; i < count; i++) {
-                _loop_2(i);
+                writeSection(writer, 2, () => handler.write(writer, imageResources, i));
             }
-        };
-        for (var _i = 0, resourceHandlers_1 = resourceHandlers; _i < resourceHandlers_1.length; _i++) {
-            var handler = resourceHandlers_1[_i];
-            _loop_1(handler);
         }
     });
     // layer and mask info
-    writeSection(writer, 2, function () {
+    writeSection(writer, 2, () => {
         writeLayerInfo(writer, layers, psd, globalAlpha, opt);
         writeGlobalLayerMaskInfo(writer, psd.globalLayerMaskInfo);
         writeAdditionalLayerInfo(writer, psd, psd, opt);
     }, undefined, !!opt.psb);
     // image data
-    var channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
-    var width = imageData ? imageData.width : psd.width;
-    var height = imageData ? imageData.height : psd.height;
-    var data = { data: new Uint8Array(width * height * 4), width: width, height: height };
+    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 (RAW_IMAGE_DATA && psd.imageDataRaw) {
         console.log('writing raw image data');
@@ -275,13 +251,13 @@ export function writePsd(writer, psd, options) {
             data.data.set(new Uint8Array(imageData.data.buffer, imageData.data.byteOffset, imageData.data.byteLength));
         // add weird white matte
         if (globalAlpha) {
-            var size = data.width * data.height * 4;
-            var p = data.data;
-            for (var i = 0; i < size; i += 4) {
-                var pa = p[i + 3];
+            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) {
-                    var a = pa / 255;
-                    var ra = 255 * (1 - a);
+                    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;
@@ -292,19 +268,19 @@ export function writePsd(writer, psd, options) {
     }
 }
 function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
-    writeSection(writer, 4, function () {
+    writeSection(writer, 4, () => {
         var _a;
         writeInt16(writer, globalAlpha ? -layers.length : layers.length);
-        var layersData = layers.map(function (l, i) { return getChannels(writer.tempBuffer, l, i === 0, options); });
-        var _loop_3 = function (layerData) {
-            var layer = layerData.layer, top_1 = layerData.top, left = layerData.left, bottom = layerData.bottom, right = layerData.right, channels = layerData.channels;
-            writeInt32(writer, top_1);
+        const layersData = layers.map((l, i) => getChannels(writer.tempBuffer, 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 (var _e = 0, channels_1 = channels; _e < channels_1.length; _e++) {
-                var c = channels_1[_e];
+            for (const c of channels) {
                 writeInt16(writer, c.channelId);
                 if (options.psb)
                     writeUint32(writer, 0);
@@ -314,7 +290,7 @@ function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
             writeSignature(writer, fromBlendMode[layer.blendMode] || 'norm');
             writeUint8(writer, Math.round(clamp((_a = layer.opacity) !== null && _a !== void 0 ? _a : 1, 0, 1) * 255));
             writeUint8(writer, layer.clipping ? 1 : 0);
-            var flags = 0x08; // 1 for Photoshop 5.0 and later, tells if bit 4 has useful information
+            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)
@@ -326,23 +302,16 @@ function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
                 flags |= 0x20;
             writeUint8(writer, flags);
             writeUint8(writer, 0); // filler
-            writeSection(writer, 1, function () {
+            writeSection(writer, 1, () => {
                 writeLayerMaskData(writer, layer, layerData);
                 writeLayerBlendingRanges(writer, layer);
                 writePascalString(writer, (layer.name || '').substring(0, 255), 4);
                 writeAdditionalLayerInfo(writer, layer, psd, options);
             });
-        };
-        // layer records
-        for (var _i = 0, layersData_1 = layersData; _i < layersData_1.length; _i++) {
-            var layerData = layersData_1[_i];
-            _loop_3(layerData);
         }
         // layer channel image data
-        for (var _b = 0, layersData_2 = layersData; _b < layersData_2.length; _b++) {
-            var layerData = layersData_2[_b];
-            for (var _c = 0, _d = layerData.channels; _c < _d.length; _c++) {
-                var channel = _d[_c];
+        for (const layerData of layersData) {
+            for (const channel of layerData.channels) {
                 writeUint16(writer, channel.compression);
                 if (channel.buffer) {
                     writeBytes(writer, channel.buffer);
@@ -351,12 +320,11 @@ function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
         }
     }, true, options.psb);
 }
-function writeLayerMaskData(writer, _a, layerData) {
-    var mask = _a.mask, realMask = _a.realMask;
-    writeSection(writer, 1, function () {
+function writeLayerMaskData(writer, { mask, realMask }, layerData) {
+    writeSection(writer, 1, () => {
         if (!mask && !realMask)
             return;
-        var params = 0, flags = 0, realFlags = 0;
+        let params = 0, flags = 0, realFlags = 0;
         if (mask) {
             if (mask.userMaskDensity !== undefined)
                 params |= 1 /* MaskParams.UserMaskDensity */;
@@ -375,7 +343,7 @@ function writeLayerMaskData(writer, _a, layerData) {
             if (params)
                 flags |= 16 /* LayerMaskFlags.MaskHasParametersAppliedToIt */;
         }
-        var m = layerData.mask || {};
+        const m = layerData.mask || {};
         writeInt32(writer, m.top || 0);
         writeInt32(writer, m.left || 0);
         writeInt32(writer, m.bottom || 0);
@@ -389,7 +357,7 @@ function writeLayerMaskData(writer, _a, layerData) {
                 realFlags |= 1 /* LayerMaskFlags.PositionRelativeToLayer */;
             if (realMask.fromVectorData)
                 realFlags |= 8 /* LayerMaskFlags.LayerMaskFromRenderingOtherData */;
-            var r = layerData.realMask || {};
+            const r = layerData.realMask || {};
             writeUint8(writer, realFlags);
             writeUint8(writer, realMask.defaultColor || 0);
             writeInt32(writer, r.top || 0);
@@ -418,13 +386,12 @@ function writerBlendingRange(writer, range) {
     writeUint8(writer, range[3]);
 }
 function writeLayerBlendingRanges(writer, layer) {
-    writeSection(writer, 1, function () {
-        var ranges = layer.blendingRanges;
+    writeSection(writer, 1, () => {
+        const ranges = layer.blendingRanges;
         if (ranges) {
             writerBlendingRange(writer, ranges.compositeGrayBlendSource);
             writerBlendingRange(writer, ranges.compositeGraphBlendDestinationRange);
-            for (var _i = 0, _a = ranges.ranges; _i < _a.length; _i++) {
-                var r = _a[_i];
+            for (const r of ranges.ranges) {
                 writerBlendingRange(writer, r.sourceRange);
                 writerBlendingRange(writer, r.destRange);
             }
@@ -432,7 +399,7 @@ function writeLayerBlendingRanges(writer, layer) {
     });
 }
 function writeGlobalLayerMaskInfo(writer, info) {
-    writeSection(writer, 1, function () {
+    writeSection(writer, 1, () => {
         if (info) {
             writeUint16(writer, info.overlayColorSpace);
             writeUint16(writer, info.colorSpace1);
@@ -446,28 +413,24 @@ function writeGlobalLayerMaskInfo(writer, info) {
     });
 }
 function writeAdditionalLayerInfo(writer, target, psd, options) {
-    var _loop_4 = function (handler) {
-        var key = handler.key;
+    for (const handler of infoHandlers) {
+        let key = handler.key;
         if (key === 'Txt2' && options.invalidateTextLayers)
-            return "continue";
+            continue;
         if (key === 'vmsk' && options.psb)
             key = 'vsms';
         if (handler.has(target)) {
-            var large = options.psb && largeAdditionalInfoKeys.indexOf(key) !== -1;
-            var writeTotalLength = key !== 'Txt2' && key !== 'cinf' && key !== 'extn' && key !== 'CAI ' && key !== 'OCIO';
-            var fourBytes = key === 'Txt2' || key === 'luni' || key === 'vmsk' || key === 'artb' || key === 'artd' ||
+            const large = options.psb && largeAdditionalInfoKeys.indexOf(key) !== -1;
+            const writeTotalLength = key !== 'Txt2' && key !== 'cinf' && key !== 'extn' && key !== 'CAI ' && key !== 'OCIO';
+            const fourBytes = key === 'Txt2' || key === 'luni' || key === 'vmsk' || key === 'artb' || key === 'artd' ||
                 key === 'vogk' || key === 'SoLd' || 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);
-            writeSection(writer, fourBytes ? 4 : 2, function () {
+            writeSection(writer, fourBytes ? 4 : 2, () => {
                 handler.write(writer, target, psd, options);
             }, writeTotalLength, large);
         }
-    };
-    for (var _i = 0, infoHandlers_1 = infoHandlers; _i < infoHandlers_1.length; _i++) {
-        var handler = infoHandlers_1[_i];
-        _loop_4(handler);
     }
 }
 function addChildren(layers, children) {
@@ -475,12 +438,11 @@ function addChildren(layers, children) {
         return;
     // const layerIds: number[] = [2];
     // const timestamps: number[] = [1740120767.0230637];
-    for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
-        var c = children_1[_i];
+    for (const c of children) {
         if (c.children && c.canvas)
-            throw new Error("Invalid layer, cannot have both 'canvas' and 'children' properties");
+            throw new Error(`Invalid layer, cannot have both 'canvas' and 'children' properties`);
         if (c.children && c.imageData)
-            throw new Error("Invalid layer, cannot have both 'imageData' and 'children' properties");
+            throw new Error(`Invalid layer, cannot have both 'imageData' and 'children' properties`);
         if (c.children) {
             layers.push({
                 name: '</Layer group>',
@@ -500,25 +462,25 @@ function addChildren(layers, children) {
                 // referencePoint: { x: 0, y: 0 },
             });
             addChildren(layers, c.children);
-            layers.push(__assign(__assign({}, c), { blendMode: c.blendMode === 'pass through' ? 'normal' : c.blendMode, sectionDivider: {
+            layers.push(Object.assign(Object.assign({}, c), { blendMode: c.blendMode === 'pass through' ? 'normal' : c.blendMode, sectionDivider: {
                     type: c.opened === false ? 2 /* SectionDividerType.ClosedFolder */ : 1 /* SectionDividerType.OpenFolder */,
                     key: fromBlendMode[c.blendMode] || 'pass',
                     subType: 0,
                 } }));
         }
         else {
-            layers.push(__assign({}, c));
+            layers.push(Object.assign({}, c));
         }
     }
 }
 function resizeBuffer(writer, size) {
-    var newLength = writer.buffer.byteLength;
+    let newLength = writer.buffer.byteLength;
     do {
         newLength *= 2;
     } while (size > newLength);
-    var newBuffer = new ArrayBuffer(newLength);
-    var newBytes = new Uint8Array(newBuffer);
-    var oldBytes = new Uint8Array(writer.buffer);
+    const newBuffer = new ArrayBuffer(newLength);
+    const newBytes = new Uint8Array(newBuffer);
+    const oldBytes = new Uint8Array(writer.buffer);
     newBytes.set(oldBytes);
     writer.buffer = newBuffer;
     writer.view = new DataView(writer.buffer);
@@ -529,13 +491,13 @@ function ensureSize(writer, size) {
     }
 }
 function addSize(writer, size) {
-    var offset = writer.offset;
+    const offset = writer.offset;
     ensureSize(writer, writer.offset += size);
     return offset;
 }
 function createThumbnail(psd) {
-    var canvas = createCanvas(10, 10);
-    var scale = 1;
+    const canvas = createCanvas(10, 10);
+    let scale = 1;
     if (psd.width > psd.height) {
         canvas.width = 160;
         canvas.height = Math.floor(psd.height * (canvas.width / psd.width));
@@ -546,7 +508,7 @@ function createThumbnail(psd) {
         canvas.width = Math.floor(psd.width * (canvas.height / psd.height));
         scale = canvas.height / psd.height;
     }
-    var context = canvas.getContext('2d');
+    const context = canvas.getContext('2d');
     context.scale(scale, scale);
     if (psd.imageData) {
         context.drawImage(imageDataToCanvas(psd.imageData), 0, 0);
@@ -557,12 +519,12 @@ function createThumbnail(psd) {
     return canvas;
 }
 function getMaskChannels(tempBuffer, layerData, layer, mask, options, realMask) {
-    var top = mask.top | 0;
-    var left = mask.left | 0;
-    var right = mask.right | 0;
-    var bottom = mask.bottom | 0;
-    var _a = getLayerDimentions(mask), width = _a.width, height = _a.height;
-    var imageData = mask.imageData;
+    let top = mask.top | 0;
+    let left = mask.left | 0;
+    let right = mask.right | 0;
+    let bottom = mask.bottom | 0;
+    let { width, height } = getLayerDimentions(mask);
+    let imageData = mask.imageData;
     if (!imageData && mask.canvas && width && height) {
         imageData = mask.canvas.getContext('2d').getImageData(0, 0, width, height);
     }
@@ -571,8 +533,8 @@ function getMaskChannels(tempBuffer, layerData, layer, mask, options, realMask)
     }
     right = left + width;
     bottom = top + height;
-    var buffer;
-    var compression;
+    let buffer;
+    let compression;
     if (RAW_IMAGE_DATA && layer[realMask ? 'realMaskDataRaw' : 'maskDataRaw']) {
         buffer = layer[realMask ? 'realMaskDataRaw' : 'maskDataRaw'];
         compression = layer[realMask ? 'realMaskDataRawCompression' : 'maskDataRawCompression'];
@@ -589,36 +551,35 @@ function getMaskChannels(tempBuffer, layerData, layer, mask, options, realMask)
         buffer = writeDataRLE(tempBuffer, imageData, [0], !!options.psb);
         compression = 1 /* Compression.RleCompressed */;
     }
-    layerData.channels.push({ channelId: realMask ? -3 /* ChannelID.RealUserMask */ : -2 /* ChannelID.UserMask */, compression: compression, buffer: buffer, length: 2 + buffer.length });
-    layerData[realMask ? 'realMask' : 'mask'] = { top: top, left: left, right: right, bottom: bottom };
+    layerData.channels.push({ channelId: realMask ? -3 /* ChannelID.RealUserMask */ : -2 /* ChannelID.UserMask */, compression, buffer, length: 2 + buffer.length });
+    layerData[realMask ? 'realMask' : 'mask'] = { top, left, right, bottom };
 }
 function getChannels(tempBuffer, layer, background, options) {
-    var layerData = getLayerChannels(tempBuffer, layer, background, options);
+    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);
     return layerData;
 }
-function getLayerDimentions(_a) {
-    var _b, _c, _d, _e;
-    var canvas = _a.canvas, imageData = _a.imageData;
+function getLayerDimentions({ canvas, imageData }) {
+    var _a, _b, _c, _d;
     // this way in case canvas/imageData are incorrect objects without width/height properties
-    var width = (_c = (_b = imageData === null || imageData === void 0 ? void 0 : imageData.width) !== null && _b !== void 0 ? _b : canvas === null || canvas === void 0 ? void 0 : canvas.width) !== null && _c !== void 0 ? _c : 0;
-    var height = (_e = (_d = imageData === null || imageData === void 0 ? void 0 : imageData.height) !== null && _d !== void 0 ? _d : canvas === null || canvas === void 0 ? void 0 : canvas.height) !== null && _e !== void 0 ? _e : 0;
-    return { width: width, height: height };
+    const width = (_b = (_a = imageData === null || imageData === void 0 ? void 0 : imageData.width) !== null && _a !== void 0 ? _a : canvas === null || canvas === void 0 ? void 0 : canvas.width) !== null && _b !== void 0 ? _b : 0;
+    const height = (_d = (_c = imageData === null || imageData === void 0 ? void 0 : imageData.height) !== null && _c !== void 0 ? _c : canvas === null || canvas === void 0 ? void 0 : canvas.height) !== null && _d !== void 0 ? _d : 0;
+    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');
     }
-    var croppedData = createImageData(width, height);
-    var srcData = data.data;
-    var dstData = croppedData.data;
-    for (var y = 0; y < height; y++) {
-        for (var x = 0; x < width; x++) {
-            var src = ((x + left) + (y + top) * data.width) * 4;
-            var dst = (x + y * width) * 4;
+    const croppedData = createImageData(width, height);
+    const srcData = data.data;
+    const dstData = croppedData.data;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let src = ((x + left) + (y + top) * data.width) * 4;
+            let dst = (x + y * width) * 4;
             dstData[dst] = srcData[src];
             dstData[dst + 1] = srcData[src + 1];
             dstData[dst + 2] = srcData[src + 2];
@@ -629,27 +590,27 @@ function cropImageData(data, left, top, width, height) {
 }
 function getLayerChannels(tempBuffer, layer, background, options) {
     var _a;
-    var top = layer.top | 0;
-    var left = layer.left | 0;
-    var right = layer.right | 0;
-    var bottom = layer.bottom | 0;
-    var channels = [
+    let top = layer.top | 0;
+    let left = layer.left | 0;
+    let right = layer.right | 0;
+    let bottom = layer.bottom | 0;
+    let channels = [
         { channelId: -1 /* ChannelID.Transparency */, compression: 0 /* Compression.RawData */, buffer: undefined, length: 2 },
         { channelId: 0 /* ChannelID.Color0 */, compression: 0 /* Compression.RawData */, buffer: undefined, length: 2 },
         { channelId: 1 /* ChannelID.Color1 */, compression: 0 /* Compression.RawData */, buffer: undefined, length: 2 },
         { channelId: 2 /* ChannelID.Color2 */, compression: 0 /* Compression.RawData */, buffer: undefined, length: 2 },
     ];
-    var _b = getLayerDimentions(layer), width = _b.width, height = _b.height;
+    let { width, height } = getLayerDimentions(layer);
     if (!(layer.canvas || layer.imageData) || !width || !height) {
         right = left;
         bottom = top;
-        return { layer: layer, top: top, left: left, right: right, bottom: bottom, channels: channels };
+        return { layer, top, left, right, bottom, channels };
     }
     right = left + width;
     bottom = top + height;
-    var data = layer.imageData || layer.canvas.getContext('2d').getImageData(0, 0, width, height);
+    let data = layer.imageData || layer.canvas.getContext('2d').getImageData(0, 0, width, height);
     if (options.trimImageData) {
-        var trimmed = trimData(data);
+        const trimmed = trimData(data);
         if (trimmed.left !== 0 || trimmed.top !== 0 || trimmed.right !== data.width || trimmed.bottom !== data.height) {
             left += trimmed.left;
             top += trimmed.top;
@@ -658,11 +619,11 @@ function getLayerChannels(tempBuffer, layer, background, options) {
             width = right - left;
             height = bottom - top;
             if (!width || !height)
-                return { layer: layer, top: top, left: left, right: right, bottom: bottom, channels: channels };
+                return { layer, top, left, right, bottom, channels };
             data = cropImageData(data, trimmed.left, trimmed.top, width, height);
         }
     }
-    var channelIds = [
+    const channelIds = [
         0 /* ChannelID.Color0 */,
         1 /* ChannelID.Color1 */,
         2 /* ChannelID.Color2 */,
@@ -670,10 +631,10 @@ function getLayerChannels(tempBuffer, layer, background, options) {
     if (!background || options.noBackground || layer.mask || hasAlpha(data) || (RAW_IMAGE_DATA && ((_a = layer.imageDataRaw) === null || _a === void 0 ? void 0 : _a['-1']))) {
         channelIds.unshift(-1 /* ChannelID.Transparency */);
     }
-    channels = channelIds.map(function (channelId) {
-        var offset = offsetForChannel(channelId, false); // TODO: psd.colorMode === ColorMode.CMYK);
-        var buffer;
-        var compression;
+    channels = channelIds.map(channelId => {
+        const offset = offsetForChannel(channelId, false); // TODO: psd.colorMode === ColorMode.CMYK);
+        let buffer;
+        let compression;
         if (RAW_IMAGE_DATA && layer.imageDataRaw) {
             // console.log('written raw layer image data');
             buffer = layer.imageDataRaw[channelId];
@@ -687,26 +648,24 @@ function getLayerChannels(tempBuffer, layer, background, options) {
             buffer = writeDataRLE(tempBuffer, data, [offset], !!options.psb);
             compression = 1 /* Compression.RleCompressed */;
         }
-        return { channelId: channelId, compression: compression, buffer: buffer, length: 2 + buffer.length };
+        return { channelId, compression, buffer, length: 2 + buffer.length };
     });
-    return { layer: layer, top: top, left: left, right: right, bottom: bottom, channels: channels };
+    return { layer, top, left, right, bottom, channels };
 }
-function isRowEmpty(_a, y, left, right) {
-    var data = _a.data, width = _a.width;
-    var start = ((y * width + left) * 4 + 3) | 0;
-    var end = (start + (right - left) * 4) | 0;
-    for (var i = start; i < end; i = (i + 4) | 0) {
+function isRowEmpty({ data, width }, y, left, right) {
+    const start = ((y * width + left) * 4 + 3) | 0;
+    const end = (start + (right - left) * 4) | 0;
+    for (let i = start; i < end; i = (i + 4) | 0) {
         if (data[i] !== 0) {
             return false;
         }
     }
     return true;
 }
-function isColEmpty(_a, x, top, bottom) {
-    var data = _a.data, width = _a.width;
-    var stride = (width * 4) | 0;
-    var start = (top * stride + x * 4 + 3) | 0;
-    for (var y = top, i = start; y < bottom; y++, i = (i + stride) | 0) {
+function isColEmpty({ data, width }, x, top, bottom) {
+    const stride = (width * 4) | 0;
+    const start = (top * stride + x * 4 + 3) | 0;
+    for (let y = top, i = start; y < bottom; y++, i = (i + stride) | 0) {
         if (data[i] !== 0) {
             return false;
         }
@@ -714,10 +673,10 @@ function isColEmpty(_a, x, top, bottom) {
     return true;
 }
 function trimData(data) {
-    var top = 0;
-    var left = 0;
-    var right = data.width;
-    var bottom = data.height;
+    let top = 0;
+    let left = 0;
+    let right = data.width;
+    let bottom = data.height;
     while (top < bottom && isRowEmpty(data, top, left, right))
         top++;
     while (bottom > top && isRowEmpty(data, bottom - 1, left, right))
@@ -726,7 +685,7 @@ function trimData(data) {
         left++;
     while (right > left && isColEmpty(data, right - 1, top, bottom))
         right--;
-    return { top: top, left: left, right: right, bottom: bottom };
+    return { top, left, right, bottom };
 }
 export function writeColor(writer, color) {
     if (!color) {
@@ -774,4 +733,63 @@ export function writeColor(writer, color) {
         writeZeros(writer, 6);
     }
 }
+// ponytail: only round-trips RGB 8-bit patterns; source colorMode (16-bit/Indexed) is not preserved,
+// since readPattern already converted everything to RGBA. Upgrade if pattern colorMode must survive write.
+export function writePattern(writer, pattern) {
+    const width = pattern.bounds.w;
+    const height = pattern.bounds.h;
+    const pixelData = { width, height, data: pattern.data };
+    writeUint32(writer, 0); // length, fixed up below
+    const pattsOffset = writer.offset;
+    writeUint32(writer, 1); // version
+    writeUint32(writer, 3 /* ColorMode.RGB */); // color mode - rgb only
+    writeInt16(writer, pattern.x);
+    writeInt16(writer, pattern.y);
+    writeUnicodeString(writer, pattern.name + '\0'); // name
+    writePascalString(writer, pattern.id, 1); // id
+    // virtual memory array list
+    writeUint32(writer, 3); // version
+    writeUint32(writer, 0); // length, fixed up below
+    const vlOffset = writer.offset;
+    const top = pattern.bounds.y;
+    const left = pattern.bounds.x;
+    const bottom = top + height;
+    const right = left + width;
+    writeUint32(writer, top);
+    writeUint32(writer, left);
+    writeUint32(writer, bottom);
+    writeUint32(writer, right);
+    writeUint32(writer, 24); // channels count
+    // 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);
+        if (offset < 0) {
+            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 = writeDataRLE(buffer, pixelData, [offset], false);
+        writeUint32(writer, 1); // has
+        writeUint32(writer, data.length + 4 + 16 + 2 + 1); // length
+        writeUint32(writer, 8); // pixelDepth
+        writeUint32(writer, top);
+        writeUint32(writer, left);
+        writeUint32(writer, bottom);
+        writeUint32(writer, right);
+        writeUint16(writer, 8); // pixelDepth2
+        writeUint8(writer, 1); // compressionMode - rle
+        writeBytes(writer, data);
+    }
+    const vlLength = writer.offset - vlOffset;
+    let pattsLength = writer.offset - pattsOffset;
+    while (pattsLength % 4) {
+        writeZeros(writer, 1);
+        pattsLength++;
+    }
+    writer.view.setUint32(vlOffset - 4, vlLength, false);
+    writer.view.setUint32(pattsOffset - 4, pattsLength, false);
+}
 //# sourceMappingURL=psdWriter.js.map