ag-psd 33.0.0 → 34.0.0

package/dist/psdReader.js

@@ -206,6 +206,8 @@ function readUnicodeString(reader) {
     return readUnicodeStringWithLength(reader, length);
 }
 const STRING_CHUNK_SIZE = 0x2000;
+// shorter strings (most descriptor keys, OSTypes and names) are faster to build with simple loop than String.fromCharCode.apply
+const SHORT_STRING_LENGTH = 64;
 function checkReadBounds(reader, size) {
     if (reader.offset < 0 || (reader.offset + size) > reader.view.byteLength) {
         throw new RangeError('Offset is outside the bounds of the DataView');
@@ -216,9 +218,18 @@ function readUtf16String(reader, length, littleEndian) {
         return '';
     checkReadBounds(reader, length * 2);
     const view = reader.view;
-    const codes = new Uint16Array(Math.min(length, STRING_CHUNK_SIZE));
     let offset = reader.offset;
     let text = '';
+    if (length <= SHORT_STRING_LENGTH) {
+        for (let i = 0; i < length; i++, offset += 2) {
+            text += String.fromCharCode(view.getUint16(offset, littleEndian));
+        }
+        reader.offset = offset;
+        if (text.charCodeAt(text.length - 1) === 0)
+            text = text.substring(0, text.length - 1);
+        return text;
+    }
+    const codes = new Uint16Array(Math.min(length, STRING_CHUNK_SIZE));
     for (let i = 0; i < length; i += STRING_CHUNK_SIZE) {
         const count = Math.min(STRING_CHUNK_SIZE, length - i);
         for (let j = 0; j < count; j++, offset += 2) {
@@ -249,6 +260,15 @@ function readAsciiString(reader, length) {
     if (!(length > 0))
         return '';
     checkReadBounds(reader, length);
+    if (length <= SHORT_STRING_LENGTH) {
+        const view = reader.view;
+        let text = '';
+        for (let i = 0, offset = reader.offset; i < length; i++, offset++) {
+            text += String.fromCharCode(view.getUint8(offset));
+        }
+        reader.offset += length;
+        return text;
+    }
     const text = bytesToString(new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length));
     reader.offset += length;
     return text;
@@ -264,7 +284,14 @@ function checkSignature(reader, a, b) {
     }
 }
 function readShortString(reader, length) {
-    return bytesToString(readBytes(reader, length));
+    const bytes = readBytes(reader, length);
+    if (length > SHORT_STRING_LENGTH)
+        return bytesToString(bytes);
+    let text = '';
+    for (let i = 0; i < bytes.length; i++) {
+        text += String.fromCharCode(bytes[i]);
+    }
+    return text;
 }
 function isValidSignature(sig) {
     return sig === '8BIM' || sig === 'MeSa' || sig === 'AgHg' || sig === 'PHUT' || sig === 'DCSR';
@@ -450,6 +477,9 @@ function readLayerInfo(reader, psd, imageResources) {
         if (type === 1 /* SectionDividerType.OpenFolder */ || type === 2 /* SectionDividerType.ClosedFolder */) {
             l.opened = type === 1 /* SectionDividerType.OpenFolder */;
             l.children = [];
+            // group layers can't have image data, some broken files have it, ignore it like Photoshop does
+            delete l.canvas;
+            delete l.imageData;
             if ((_a = l.sectionDivider) === null || _a === void 0 ? void 0 : _a.key) {
                 l.blendMode = (_b = helpers_1.toBlendMode[l.sectionDivider.key]) !== null && _b !== void 0 ? _b : l.blendMode;
             }
@@ -648,9 +678,8 @@ function readLayerChannelImageData(reader, psd, layer, channels) {
         const start = reader.offset;
         let compression = 0 /* Compression.RawData */;
         let data = undefined;
-        if (channel.length === 1)
-            throw new Error('Invalid channel length');
-        if (channel.length) {
+        // channel length of 1 is invalid (should be 0 or at least 2), skip the byte and treat channel as empty
+        if (channel.length >= 2) {
             compression = readUint16(reader);
             // try to fix broken files where there's 1 byte shift of channel
             if (compression > 3) {
@@ -672,7 +701,16 @@ function readLayerChannelImageData(reader, psd, layer, channels) {
         layer.rawData.channels.push({ id: channel.id, compression, data });
     }
     if (!reader.useRawData) {
-        decodeLayerImageData(layer, reader);
+        try {
+            decodeLayerImageData(layer, reader);
+        }
+        catch (e) {
+            // corrupted image data of one layer shouldn't prevent reading rest of the file
+            if (reader.throwForMissingFeatures || e.message === 'Exceeded memory limit')
+                throw e;
+            reader.logMissingFeatures && reader.log(`Failed to decode layer image data: ${e.message}`);
+            delete layer.rawData;
+        }
     }
 }
 function resetAlpha({ data }, cmyk) {
@@ -876,7 +914,7 @@ function readGlobalLayerMaskInfo(reader) {
         const colorSpace2 = readUint16(reader);
         const colorSpace3 = readUint16(reader);
         const colorSpace4 = readUint16(reader);
-        const opacity = readUint16(reader) / 100; // 0 - 100
+        const opacity = Math.min(readUint16(reader), 100) / 100; // 0 - 100 (some files have values out of range)
         const kind = readUint8(reader);
         skipBytes(reader, left()); // 3 bytes of padding ?
         return { overlayColorSpace, colorSpace1, colorSpace2, colorSpace3, colorSpace4, opacity, kind };
@@ -1126,10 +1164,7 @@ function toRange(value, max) {
     value = Math.round(value * (max / 255));
     return value <= 0 ? 0 : (value >= max ? max : value);
 }
-// Polynomial approximation of U.S. Web Coated (SWOP) v2 CMYK to RGB conversion (default CMYK profile of Photoshop).
-// Coefficients are taken from pdf.js (DeviceCmykCS in src/core/colorspace.js, https://github.com/mozilla/pdf.js),
-// Copyright 2012 Mozilla Foundation, licensed under the Apache License, Version 2.0
-// (http://www.apache.org/licenses/LICENSE-2.0)
+// converts CMYK data to RGB using approximation of U.S. Web Coated (SWOP) v2 profile (see cmykToRgbValues)
 // cmyk - 8 or 16 bit data with 5 channels (cmyka), rgb - 8 or 16 bit data with 4 channels (rgba)
 // removeMatte - colors are blended with white (no ink), used for composite image of documents with global alpha
 function cmykToRgb(cmyk, rgb, removeMatte) {
@@ -1138,6 +1173,7 @@ function cmykToRgb(cmyk, rgb, removeMatte) {
     const dstData = rgb.data;
     const srcMax = srcData instanceof Uint16Array ? 0xffff : 0xff;
     const dstMax = dstData instanceof Uint16Array ? 0xffff : 0xff;
+    const out = [0, 0, 0];
     for (let src = 0, dst = 0; dst < size; src += 5, dst += 4) {
         const a = srcData[src + 4];
         // image data stores inverted values (0 = 100% ink)
@@ -1152,21 +1188,10 @@ function cmykToRgb(cmyk, rgb, removeMatte) {
             y = Math.min(1, y * ra);
             k = Math.min(1, k * ra);
         }
-        dstData[dst] = toRange(255 +
-            c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k - 285.2331026137004) +
-            m * (1.7149763477362134 * m - 5.6096736904047315 * y - 17.873870861415444 * k - 5.497006427196366) +
-            y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) +
-            k * (-21.86122147463605 * k - 189.48180835922747), dstMax);
-        dstData[dst + 1] = toRange(255 +
-            c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k - 79.2970844816548) +
-            m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) +
-            y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) +
-            k * (-20.737325471181034 * k - 187.80453709719578), dstMax);
-        dstData[dst + 2] = toRange(255 +
-            c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k - 14.183576799673286) +
-            m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) +
-            y * (0.03296041114873217 * y + 115.60384449646641 * k - 193.58209356861505) +
-            k * (-22.33816807309886 * k - 180.12613974708367), dstMax);
+        (0, helpers_1.cmykToRgbValues)(c, m, y, k, out);
+        dstData[dst] = toRange(out[0], dstMax);
+        dstData[dst + 1] = toRange(out[1], dstMax);
+        dstData[dst + 2] = toRange(out[2], dstMax);
         dstData[dst + 3] = srcMax === dstMax ? a : Math.round(a * dstMax / srcMax);
     }
 }
@@ -1333,8 +1358,8 @@ function readDataZip(compressed, pixelData, width, height, bitDepth, step, offse
             recoverMemory(reader, expectedSize);
     }
 }
-// decodes single PackBits row, returns number of decoded values
-function decodeRLERow(src, i, end, dst, p, step, count) {
+// decodes single PackBits row into byte buffer, returns number of decoded bytes
+function decodeRLERow(src, i, end, dst, count) {
     let x = 0;
     while (i < end && x < count) {
         const header = src[i++];
@@ -1345,10 +1370,8 @@ function decodeRLERow(src, i, end, dst, p, step, count) {
             let n = 257 - header;
             if (n > count - x)
                 n = count - x;
+            dst.fill(value, x, x + n);
             x += n;
-            for (; n > 0; n--, p += step) {
-                dst[p] = value;
-            }
         }
         else if (header < 128) {
             let n = header + 1;
@@ -1356,9 +1379,8 @@ function decodeRLERow(src, i, end, dst, p, step, count) {
                 n = count - x;
             if (n > end - i)
                 n = end - i;
-            x += n;
-            for (; n > 0; n--, p += step) {
-                dst[p] = src[i++];
+            for (; n > 0; n--) {
+                dst[x++] = src[i++];
             }
         }
         else {
@@ -1367,6 +1389,47 @@ function decodeRLERow(src, i, end, dst, p, step, count) {
     }
     return x;
 }
+// decodes RLE rows of single 8bit channel, writing values to `data` with `step`
+// (kept as single function with the loops, inlining row decoder into readDataRLE makes V8 generate much slower code)
+function decodeRLEChannel8(src, lengths, li, pos, width, height, data, offset, step) {
+    const srcEnd = src.length | 0;
+    for (let y = 0; y < height; y++, li++) {
+        let i = (pos < srcEnd ? pos : srcEnd) | 0;
+        pos += lengths[li];
+        const end = (pos < srcEnd ? pos : srcEnd) | 0;
+        let p = (offset + y * width * step) | 0;
+        let x = 0;
+        while (i < end && x < width) {
+            const header = src[i++] | 0;
+            if (header > 128) {
+                if (i >= end)
+                    break;
+                const value = src[i++] | 0;
+                let n = (257 - header) | 0;
+                if (n > width - x)
+                    n = (width - x) | 0;
+                x = (x + n) | 0;
+                for (const pe = (p + n * step) | 0; p < pe; p = (p + step) | 0) {
+                    data[p] = value;
+                }
+            }
+            else if (header < 128) {
+                let n = (header + 1) | 0;
+                if (n > width - x)
+                    n = (width - x) | 0;
+                if (n > end - i)
+                    n = (end - i) | 0;
+                x = (x + n) | 0;
+                for (const ie = (i + n) | 0; i < ie; i = (i + 1) | 0, p = (p + step) | 0) {
+                    data[p] = src[i];
+                }
+            }
+            else {
+                // ignore 128
+            }
+        }
+    }
+}
 // converts big-endian 16/32-bit values from bytes and writes them to `data` starting at `p` with `step`
 function scatterValues(bytes, count, bpv, data, p, step) {
     if (bpv === 2) {
@@ -1381,8 +1444,8 @@ function scatterValues(bytes, count, bpv, data, p, step) {
         }
     }
 }
-// decodes RLE rows of single channel, each row starts at the beginning of the image row
-function decodeRLEChannel(src, lengths, li, pos, width, height, data, offset, step, bpv, row) {
+// decodes RLE rows of single 16bit or 32bit channel, each row is decoded into `row` buffer and then converted to values
+function decodeRLEChannelWide(src, lengths, li, pos, width, height, data, offset, step, bpv, row) {
     const srcEnd = src.length;
     const rowSize = width * bpv;
     for (let y = 0; y < height; y++, li++) {
@@ -1391,25 +1454,24 @@ function decodeRLEChannel(src, lengths, li, pos, width, height, data, offset, st
         const rowEnd = pos < srcEnd ? pos : srcEnd;
         if (rowStart >= rowEnd)
             continue;
-        if (bpv === 1) {
-            decodeRLERow(src, rowStart, rowEnd, data, offset + y * width * step, step, width);
-        }
-        else {
-            const decoded = decodeRLERow(src, rowStart, rowEnd, row, 0, 1, rowSize);
-            scatterValues(row, Math.floor(decoded / bpv), bpv, data, offset + y * width * step, step);
-        }
+        const decoded = decodeRLERow(src, rowStart, rowEnd, row, rowSize);
+        scatterValues(row, Math.floor(decoded / bpv), bpv, data, offset + y * width * step, step);
     }
 }
 function readDataRLE(reader, pixelData, width, height, bitDepth, step, offsets, large) {
     const data = pixelData && pixelData.data;
     const rows = offsets.length * height;
     const lengthSize = large ? 4 : 2;
-    consumeMemory(reader, rows * lengthSize);
+    const lengthsMemory = rows * lengthSize;
+    const srcEnd = reader.view.byteLength;
+    const bpv = bytesPerValue(bitDepth); // throws before consuming memory
+    let lengths;
+    consumeMemory(reader, lengthsMemory);
     try {
-        if ((reader.offset + rows * lengthSize) > reader.view.byteLength) {
+        if ((reader.offset + lengthsMemory) > srcEnd) {
             throw new Error('RLE row lengths exceed buffer length');
         }
-        const lengths = large ? new Uint32Array(rows) : new Uint16Array(rows);
+        lengths = large ? new Uint32Array(rows) : new Uint16Array(rows);
         let total = 0;
         if (large) {
             for (let i = 0; i < rows; i++)
@@ -1419,32 +1481,37 @@ function readDataRLE(reader, pixelData, width, height, bitDepth, step, offsets,
             for (let i = 0; i < rows; i++)
                 total += (lengths[i] = readUint16(reader));
         }
-        const start = reader.offset;
-        const srcEnd = reader.view.byteLength;
-        if (total > (srcEnd - start)) {
+        if (total > (srcEnd - reader.offset)) {
             // broken or truncated file, decode only data that is available
             warnOrThrow(reader, 'RLE data exceeds buffer length');
         }
-        const bpv = bytesPerValue(bitDepth);
         if (data)
             verifyArrayType(data, bpv);
-        const src = new Uint8Array(reader.view.buffer, reader.view.byteOffset, srcEnd);
-        const row = (data && bpv > 1) ? new Uint8Array(width * bpv) : undefined;
-        let pos = start;
-        for (let c = 0, li = 0; c < offsets.length; c++, li += height) {
-            const offset = offsets[c] | 0;
-            const channelStart = pos;
-            for (let y = 0; y < height; y++)
-                pos += lengths[li + y];
-            if (data && offset >= 0 && offset < step) {
-                decodeRLEChannel(src, lengths, li, channelStart, width, height, data, offset, step, bpv, row);
+    }
+    catch (e) {
+        recoverMemory(reader, lengthsMemory);
+        throw e;
+    }
+    // decoding can't throw, it's kept outside of try block because V8 generates much slower code for loops inlined into try block
+    const src = new Uint8Array(reader.view.buffer, reader.view.byteOffset, srcEnd);
+    const row = (data && bpv > 1) ? new Uint8Array(width * bpv) : undefined;
+    let pos = reader.offset;
+    for (let c = 0, li = 0; c < offsets.length; c++, li += height) {
+        const offset = offsets[c] | 0;
+        const channelStart = pos;
+        for (let y = 0; y < height; y++)
+            pos += lengths[li + y];
+        if (data && offset >= 0 && offset < step) {
+            if (bpv === 1) {
+                decodeRLEChannel8(src, lengths, li, channelStart, width, height, data, offset, step);
+            }
+            else {
+                decodeRLEChannelWide(src, lengths, li, channelStart, width, height, data, offset, step, bpv, row);
             }
         }
-        reader.offset = pos;
-    }
-    finally {
-        recoverMemory(reader, rows * lengthSize);
     }
+    reader.offset = pos;
+    recoverMemory(reader, lengthsMemory);
 }
 function readSection(reader, round, func, skipEmpty = true, eightBytes = false) {
     let length = readUint32(reader);
@@ -1586,19 +1653,13 @@ function readPattern(reader) {
     // channels cover whole pattern, each 2 bytes of RLE data can produce at most 128 bytes
     if (width * height > (Math.min(end, reader.view.byteLength) - reader.offset) * 64)
         throw new Error('Pattern data out of bounds');
-    const size = width * height * 4;
-    consumeMemory(reader, size);
-    const data = new Uint8Array(size);
-    for (let i = 3; i < data.byteLength; i += 4) {
-        data[i] = 255;
-    }
     // first written arrays are color channels, next one is transparency (Photoshop stores it in the last, sheet mask, array)
     const colorChannels = colorMode === 3 /* ColorMode.RGB */ ? 3 : (colorMode === 4 /* ColorMode.CMYK */ ? 4 : 1);
-    // CMYK channels are decoded into separate buffer (5 values per pixel, inverted, 0 = 100% ink) and converted to RGB at the end
-    const cmyk = colorMode === 4 /* ColorMode.CMYK */ ? new Uint8Array(width * height * 5).fill(255) : undefined;
-    if (cmyk)
-        consumeMemory(reader, cmyk.byteLength);
-    const alphaTarget = cmyk ? 4 : 3;
+    const isCmyk = colorMode === 4 /* ColorMode.CMYK */;
+    const alphaTarget = isCmyk ? 4 : 3;
+    const channels = [];
+    let maxDecodeSize = 0;
+    // validate all channels before allocating any image data
     for (let i = 0, ch = 0; i < (channelsCount + 2) && reader.offset + 4 <= end; i++) {
         const has = readUint32(reader);
         if (!has)
@@ -1630,72 +1691,107 @@ function readPattern(reader) {
         const h = cbottom - ctop;
         const rowBytes = w * (depth / 8);
         const channelSize = rowBytes * h;
-        let bytes;
         if (compressionMode === 0) {
             if (cdata.byteLength < channelSize)
                 throw new Error('Pattern channel data out of bounds');
-            bytes = cdata;
         }
         else if (compressionMode === 1) {
             // each 2 bytes of RLE data can produce at most 128 bytes
             if (channelSize > cdata.byteLength * 64)
                 throw new Error('Pattern channel data out of bounds');
-            consumeMemory(reader, channelSize);
-            bytes = new Uint8Array(channelSize);
-            const cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
-            readDataRLE(cdataReader, { data: bytes, width: rowBytes, height: h }, rowBytes, h, 8, 1, [0], false);
+            maxDecodeSize = Math.max(maxDecodeSize, channelSize);
         }
         else {
             throw new Error('Invalid pattern compression mode');
         }
+        channels.push({ target, depth, compressionMode, cdata, ctop, cleft, w, h, rowBytes, channelSize });
+    }
+    // check peak memory up front (image data, CMYK buffer and largest RLE decode buffer),
+    // image data is consumed only after successful decoding so failed patterns don't reduce the limit
+    const size = width * height * 4;
+    const cmykSize = isCmyk ? width * height * 5 : 0;
+    consumeMemory(reader, size + cmykSize + maxDecodeSize);
+    recoverMemory(reader, size + cmykSize + maxDecodeSize);
+    const data = new Uint8Array(size);
+    for (let i = 3; i < data.byteLength; i += 4) {
+        data[i] = 255;
+    }
+    // CMYK channels are decoded into separate buffer (5 values per pixel, inverted, 0 = 100% ink) and converted to RGB at the end
+    const cmyk = isCmyk ? new Uint8Array(cmykSize).fill(255) : undefined;
+    for (const { target, depth, compressionMode, cdata, ctop, cleft, w, h, rowBytes, channelSize } of channels) {
+        let bytes = cdata;
+        if (compressionMode === 1) {
+            bytes = new Uint8Array(channelSize);
+            const cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
+            readDataRLE(cdataReader, { data: bytes, width: rowBytes, height: h }, rowBytes, h, 8, 1, [0], false);
+        }
+        if (depth !== 8)
+            bytes = patternChannelTo8bit(bytes, w * h, depth);
         const ox = cleft - left;
         const oy = ctop - top;
-        for (let y = 0; y < h; y++) {
-            for (let x = 0; x < w; x++) {
-                const src = x + y * w;
-                const dst = (ox + x + (y + oy) * width) * 4;
-                const value = depth === 8 ? bytes[src] : patternValueTo8bit(bytes, src, depth);
-                if (cmyk) {
-                    cmyk[(ox + x + (y + oy) * width) * 5 + target] = value;
-                }
-                else if (target === 3) {
-                    data[dst + 3] = value;
-                }
-                else if (colorMode === 2 /* ColorMode.Indexed */) {
-                    const color = palette[value];
-                    data[dst + 0] = color.r;
-                    data[dst + 1] = color.g;
-                    data[dst + 2] = color.b;
+        if (cmyk) {
+            copyPatternChannel(bytes, cmyk, w, h, (ox + oy * width) * 5 + target, width * 5, 5);
+        }
+        else if (target === 3 || colorMode === 3 /* ColorMode.RGB */) {
+            copyPatternChannel(bytes, data, w, h, (ox + oy * width) * 4 + target, width * 4, 4);
+        }
+        else if (colorMode === 2 /* ColorMode.Indexed */) {
+            const colors = new Uint8Array(256 * 3);
+            for (let i = 0; i < 256; i++) {
+                colors[i * 3 + 0] = palette[i].r;
+                colors[i * 3 + 1] = palette[i].g;
+                colors[i * 3 + 2] = palette[i].b;
+            }
+            for (let y = 0; y < h; y++) {
+                for (let x = 0, src = y * w, dst = (ox + (y + oy) * width) * 4; x < w; x++, src++, dst += 4) {
+                    const index = bytes[src] * 3;
+                    data[dst + 0] = colors[index + 0];
+                    data[dst + 1] = colors[index + 1];
+                    data[dst + 2] = colors[index + 2];
                 }
-                else if (colorMode === 1 /* ColorMode.Grayscale */) {
+            }
+        }
+        else { // grayscale
+            for (let y = 0; y < h; y++) {
+                for (let x = 0, src = y * w, dst = (ox + (y + oy) * width) * 4; x < w; x++, src++, dst += 4) {
+                    const value = bytes[src];
                     data[dst + 0] = value;
                     data[dst + 1] = value;
                     data[dst + 2] = value;
                 }
-                else {
-                    data[dst + target] = value;
-                }
             }
         }
-        if (compressionMode === 1)
-            recoverMemory(reader, channelSize);
     }
     if (cmyk) {
         cmykToRgb({ width, height, data: cmyk }, { width, height, data }, false);
-        recoverMemory(reader, cmyk.byteLength);
     }
+    consumeMemory(reader, size);
     reader.offset = end;
     return { id, name, x, y, bounds: { x: left, y: top, w: width, h: height }, data };
 }
-// converts big-endian 16bit or 32bit (float) value at given index to 8bit value
-function patternValueTo8bit(bytes, index, depth) {
+// converts big-endian 16bit or 32bit (float) values to 8bit values
+function patternChannelTo8bit(bytes, count, depth) {
+    const result = new Uint8Array(count);
     if (depth === 16) {
-        return Math.round(((bytes[index * 2] << 8) | bytes[index * 2 + 1]) / 257);
+        for (let i = 0; i < count; i++) {
+            result[i] = Math.round(((bytes[i * 2] << 8) | bytes[i * 2 + 1]) / 257);
+        }
     }
     else {
-        const view = new DataView(bytes.buffer, bytes.byteOffset + index * 4, 4);
-        const value = view.getFloat32(0, false);
-        return value > 0 ? (value < 1 ? Math.round(value * 255) : 255) : 0;
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        for (let i = 0; i < count; i++) {
+            const value = view.getFloat32(i * 4, false);
+            result[i] = value > 0 ? (value < 1 ? Math.round(value * 255) : 255) : 0;
+        }
+    }
+    return result;
+}
+// copies w x h channel values into interleaved data starting at `offset`
+function copyPatternChannel(bytes, data, w, h, offset, stride, step) {
+    for (let y = 0, src = 0; y < h; y++) {
+        for (let x = 0, dst = offset + y * stride; x < w; x++, src++, dst += step) {
+            data[dst] = bytes[src];
+        }
     }
 }
 function consumeMemory(reader, size) {