@dereekb/firebase-server 13.25.1 → 13.27.0

package/model/index.esm.js

@@ -7,7 +7,8 @@ import { Optional, Inject, Injectable, Module, Global } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { BaseError } from 'make-error';
 import sharp from 'sharp';
-import { PDFName, PDFDocument, PDFRawStream, PDFArray } from '@cantoo/pdf-lib';
+import { inflateSync } from 'node:zlib';
+import { PDFName, PDFDocument, PDFRawStream, PDFArray, PDFNumber, PDFStream, PDFDict, PDFRef } from '@cantoo/pdf-lib';
 import archiver from 'archiver';
 
 function _array_like_to_array$a(arr, len) {
@@ -8243,7 +8244,7 @@ var DEFAULT_COMPRESS_IMAGE_FORMAT = 'jpeg';
  * ```
  */ function compressImageBufferToTargetSize(input, config) {
     return _async_to_generator$6(function() {
-        var _config_maxDimension, _config_initialQuality, _config_minQuality, _config_qualityStep, _config_format, _metadata_width, _metadata_height, targetSizeBytes, maxDimension, initialQuality, minQuality, qualityStep, format, metadata, originalWidth, originalHeight, originalSizeBytes, longestSide, resizeNeeded, scale, workingWidth, workingHeight, bestBuffer, bestSize, bestQuality, bestWidth, bestHeight, hitTarget, qualities, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, quality, encoded, err, result;
+        var _config_maxDimension, _config_initialQuality, _config_minQuality, _config_qualityStep, _config_format, _config_rawPixelInput, _ref, _ref1, _ref2, _ref3, targetSizeBytes, maxDimension, initialQuality, minQuality, qualityStep, format, rawPixelInput, inputMetadata, _tmp, originalWidth, originalHeight, originalSizeBytes, longestSide, resizeNeeded, scale, workingWidth, workingHeight, bestBuffer, bestSize, bestQuality, bestWidth, bestHeight, hitTarget, qualities, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, quality, encoded, err, finalChannels, _ref4, _ref5, _channels, result;
         return _ts_generator$6(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -8253,14 +8254,28 @@ var DEFAULT_COMPRESS_IMAGE_FORMAT = 'jpeg';
                     minQuality = (_config_minQuality = config.minQuality) !== null && _config_minQuality !== void 0 ? _config_minQuality : DEFAULT_COMPRESS_IMAGE_MIN_QUALITY;
                     qualityStep = (_config_qualityStep = config.qualityStep) !== null && _config_qualityStep !== void 0 ? _config_qualityStep : DEFAULT_COMPRESS_IMAGE_QUALITY_STEP;
                     format = (_config_format = config.format) !== null && _config_format !== void 0 ? _config_format : DEFAULT_COMPRESS_IMAGE_FORMAT;
+                    rawPixelInput = (_config_rawPixelInput = config.rawPixelInput) !== null && _config_rawPixelInput !== void 0 ? _config_rawPixelInput : undefined;
+                    if (!(rawPixelInput == null)) return [
+                        3,
+                        2
+                    ];
                     return [
                         4,
                         sharp(input).metadata()
                     ];
                 case 1:
-                    metadata = _state.sent();
-                    originalWidth = (_metadata_width = metadata.width) !== null && _metadata_width !== void 0 ? _metadata_width : 0;
-                    originalHeight = (_metadata_height = metadata.height) !== null && _metadata_height !== void 0 ? _metadata_height : 0;
+                    _tmp = _state.sent();
+                    return [
+                        3,
+                        3
+                    ];
+                case 2:
+                    _tmp = undefined;
+                    _state.label = 3;
+                case 3:
+                    inputMetadata = _tmp;
+                    originalWidth = (_ref = (_ref1 = rawPixelInput === null || rawPixelInput === void 0 ? void 0 : rawPixelInput.width) !== null && _ref1 !== void 0 ? _ref1 : inputMetadata === null || inputMetadata === void 0 ? void 0 : inputMetadata.width) !== null && _ref !== void 0 ? _ref : 0;
+                    originalHeight = (_ref2 = (_ref3 = rawPixelInput === null || rawPixelInput === void 0 ? void 0 : rawPixelInput.height) !== null && _ref3 !== void 0 ? _ref3 : inputMetadata === null || inputMetadata === void 0 ? void 0 : inputMetadata.height) !== null && _ref2 !== void 0 ? _ref2 : 0;
                     originalSizeBytes = input.byteLength;
                     longestSide = Math.max(originalWidth, originalHeight);
                     resizeNeeded = longestSide > maxDimension && longestSide > 0;
@@ -8268,14 +8283,15 @@ var DEFAULT_COMPRESS_IMAGE_FORMAT = 'jpeg';
                     workingWidth = Math.max(1, Math.round(originalWidth * scale));
                     workingHeight = Math.max(1, Math.round(originalHeight * scale));
                     bestBuffer = input;
-                    bestSize = originalSizeBytes;
+                    // raw input must always be re-encoded, so no encoding is compared against the raw byte size
+                    bestSize = rawPixelInput == null ? originalSizeBytes : Number.MAX_SAFE_INTEGER;
                     bestQuality = 100;
                     bestWidth = originalWidth;
                     bestHeight = originalHeight;
-                    hitTarget = bestSize <= targetSizeBytes && !resizeNeeded;
+                    hitTarget = rawPixelInput == null && bestSize <= targetSizeBytes && !resizeNeeded;
                     if (!!hitTarget) return [
                         3,
-                        9
+                        11
                     ];
                     qualities = qualityIterationSteps({
                         format: format,
@@ -8284,20 +8300,20 @@ var DEFAULT_COMPRESS_IMAGE_FORMAT = 'jpeg';
                         qualityStep: qualityStep
                     });
                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                    _state.label = 2;
-                case 2:
+                    _state.label = 4;
+                case 4:
                     _state.trys.push([
-                        2,
-                        7,
-                        8,
-                        9
+                        4,
+                        9,
+                        10,
+                        11
                     ]);
                     _iterator = qualities[Symbol.iterator]();
-                    _state.label = 3;
-                case 3:
+                    _state.label = 5;
+                case 5:
                     if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                         3,
-                        6
+                        8
                     ];
                     quality = _step.value;
                     return [
@@ -8308,10 +8324,11 @@ var DEFAULT_COMPRESS_IMAGE_FORMAT = 'jpeg';
                             quality: quality,
                             resizeNeeded: resizeNeeded,
                             workingWidth: workingWidth,
-                            workingHeight: workingHeight
+                            workingHeight: workingHeight,
+                            rawPixelInput: rawPixelInput
                         })
                     ];
-                case 4:
+                case 6:
                     encoded = _state.sent();
                     if (encoded.byteLength < bestSize) {
                         bestBuffer = encoded;
@@ -8324,30 +8341,30 @@ var DEFAULT_COMPRESS_IMAGE_FORMAT = 'jpeg';
                         hitTarget = true;
                         return [
                             3,
-                            6
+                            8
                         ];
                     }
-                    _state.label = 5;
-                case 5:
+                    _state.label = 7;
+                case 7:
                     _iteratorNormalCompletion = true;
                     return [
                         3,
-                        3
+                        5
                     ];
-                case 6:
+                case 8:
                     return [
                         3,
-                        9
+                        11
                     ];
-                case 7:
+                case 9:
                     err = _state.sent();
                     _didIteratorError = true;
                     _iteratorError = err;
                     return [
                         3,
-                        9
+                        11
                     ];
-                case 8:
+                case 10:
                     try {
                         if (!_iteratorNormalCompletion && _iterator.return != null) {
                             _iterator.return();
@@ -8360,14 +8377,33 @@ var DEFAULT_COMPRESS_IMAGE_FORMAT = 'jpeg';
                     return [
                         7
                     ];
-                case 9:
+                case 11:
+                    if (!(bestBuffer === input)) return [
+                        3,
+                        12
+                    ];
+                    finalChannels = (_ref4 = (_ref5 = rawPixelInput === null || rawPixelInput === void 0 ? void 0 : rawPixelInput.channels) !== null && _ref5 !== void 0 ? _ref5 : inputMetadata === null || inputMetadata === void 0 ? void 0 : inputMetadata.channels) !== null && _ref4 !== void 0 ? _ref4 : 0;
+                    return [
+                        3,
+                        14
+                    ];
+                case 12:
+                    return [
+                        4,
+                        sharp(bestBuffer).metadata()
+                    ];
+                case 13:
+                    finalChannels = (_channels = _state.sent().channels) !== null && _channels !== void 0 ? _channels : 0;
+                    _state.label = 14;
+                case 14:
                     result = {
                         buffer: bestBuffer,
                         originalSizeBytes: originalSizeBytes,
-                        compressedSizeBytes: bestSize,
+                        compressedSizeBytes: bestBuffer.byteLength,
                         finalQuality: bestQuality,
                         finalWidth: bestWidth,
                         finalHeight: bestHeight,
+                        finalChannels: finalChannels,
                         hitTarget: hitTarget
                     };
                     return [
@@ -8393,11 +8429,17 @@ function qualityIterationSteps(input) {
 }
 function encodeImage(input) {
     return _async_to_generator$6(function() {
-        var pipeline, result, _;
+        var _input_rawPixelInput, pipeline, result, _;
         return _ts_generator$6(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    pipeline = sharp(input.input);
+                    pipeline = input.rawPixelInput == null ? sharp(input.input) : sharp(input.input, {
+                        raw: input.rawPixelInput
+                    });
+                    // grayscale raw input stays grayscale — sharp otherwise converts raw pipelines to sRGB on encode
+                    if (((_input_rawPixelInput = input.rawPixelInput) === null || _input_rawPixelInput === void 0 ? void 0 : _input_rawPixelInput.channels) === 1) {
+                        pipeline.toColourspace('b-w');
+                    }
                     if (input.resizeNeeded) {
                         pipeline.resize({
                             width: input.workingWidth,
@@ -8666,10 +8708,15 @@ var DEFAULT_COMPRESS_PDF_IMAGE_SIZE_THRESHOLD_BYTES = 100 * 1024;
 /**
  * Recompresses image XObjects embedded in a PDF to shrink its overall size.
  *
- * Only DCTDecode (JPEG) image streams are touched in this implementation — the
- * dominant case for "phone photo PDFs". Images using other filters (FlateDecode,
- * CCITTFax, JBIG2, JPEG2000), indexed/CMYK color spaces, or that carry a
- * `/SMask` (soft mask) are skipped and counted in `imagesSkipped`.
+ * Two stream kinds are recompressed to JPEG (DCTDecode):
+ * - DCTDecode (JPEG) image streams — the dominant case for "phone photo PDFs".
+ * - FlateDecode raster image streams (zlib-deflated raw pixels, 8 bits per
+ *   component, DeviceRGB/DeviceGray/CalRGB/CalGray/ICCBased color spaces, with
+ *   optional PNG/TIFF predictors) — the dominant case for scanner-produced PDFs.
+ *
+ * Images using other filters (CCITTFax, JBIG2, JPEG2000), indexed/CMYK/other
+ * color spaces, non-8-bit rasters, or that carry a `/SMask` or `/Mask` are
+ * skipped and counted in `imagesSkipped`.
  *
  * Throws on a malformed PDF — callers should catch and fall back to the original
  * bytes.
@@ -8826,7 +8873,7 @@ var DEFAULT_COMPRESS_PDF_IMAGE_SIZE_THRESHOLD_BYTES = 100 * 1024;
 }
 function processPdfStream(input) {
     return _async_to_generator$5(function() {
-        var pdfDoc, ref, obj, counters, imageMaxDimension, imageQuality, imageSizeThresholdBytes, _counters_imageStreamsByFilter_filterKey, filterKey, compressedImage;
+        var pdfDoc, ref, obj, counters, imageMaxDimension, imageQuality, imageSizeThresholdBytes, _counters_imageStreamsByFilter_filterKey, filterKey, streamType, compressedImage, decoded;
         return _ts_generator$5(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -8836,7 +8883,8 @@ function processPdfStream(input) {
                         filterKey = imageStreamFilterKey(obj);
                         counters.imageStreamsByFilter[filterKey] = ((_counters_imageStreamsByFilter_filterKey = counters.imageStreamsByFilter[filterKey]) !== null && _counters_imageStreamsByFilter_filterKey !== void 0 ? _counters_imageStreamsByFilter_filterKey : 0) + 1;
                     }
-                    if (!isCompressibleImageStream(obj)) {
+                    streamType = compressibleImageStreamType(obj);
+                    if (streamType == null) {
                         return [
                             2
                         ];
@@ -8850,10 +8898,14 @@ function processPdfStream(input) {
                 case 1:
                     _state.trys.push([
                         1,
-                        3,
+                        7,
                         ,
-                        4
+                        8
                     ]);
+                    if (!(streamType === 'jpeg')) return [
+                        3,
+                        3
+                    ];
                     return [
                         4,
                         compressImageBufferToTargetSize(Buffer.from(obj.contents), {
@@ -8865,7 +8917,41 @@ function processPdfStream(input) {
                     ];
                 case 2:
                     compressedImage = _state.sent();
-                    if (compressedImage.compressedSizeBytes >= obj.contents.byteLength) {
+                    return [
+                        3,
+                        6
+                    ];
+                case 3:
+                    decoded = decodeFlateRasterImage(pdfDoc, obj);
+                    if (!(decoded == null)) return [
+                        3,
+                        4
+                    ];
+                    counters.imagesSkipped += 1; // unsupported raster layout (color space, bit depth, predictor, or decode array)
+                    return [
+                        3,
+                        6
+                    ];
+                case 4:
+                    return [
+                        4,
+                        compressImageBufferToTargetSize(decoded.data, {
+                            targetSizeBytes: obj.contents.byteLength,
+                            maxDimension: imageMaxDimension,
+                            initialQuality: imageQuality,
+                            format: 'jpeg',
+                            rawPixelInput: {
+                                width: decoded.width,
+                                height: decoded.height,
+                                channels: decoded.channels
+                            }
+                        })
+                    ];
+                case 5:
+                    compressedImage = _state.sent();
+                    _state.label = 6;
+                case 6:
+                    if (compressedImage == null || compressedImage.compressedSizeBytes >= obj.contents.byteLength) {
                         return [
                             2
                         ]; // no gain — leave it alone
@@ -8875,21 +8961,22 @@ function processPdfStream(input) {
                         ref: ref,
                         newImageBytes: compressedImage.buffer,
                         newWidth: compressedImage.finalWidth,
-                        newHeight: compressedImage.finalHeight
+                        newHeight: compressedImage.finalHeight,
+                        colorSpace: compressedImage.finalChannels === 1 ? 'DeviceGray' : 'DeviceRGB'
                     });
                     counters.imagesCompressed += 1;
                     return [
                         3,
-                        4
+                        8
                     ];
-                case 3:
+                case 7:
                     _state.sent();
                     counters.imagesSkipped += 1;
                     return [
                         3,
-                        4
+                        8
                     ];
-                case 4:
+                case 8:
                     return [
                         2
                     ];
@@ -8933,11 +9020,28 @@ var PDF_NAME_SUBTYPE = PDFName.of('Subtype');
 var PDF_NAME_IMAGE = PDFName.of('Image');
 var PDF_NAME_FILTER = PDFName.of('Filter');
 var PDF_NAME_DCTDECODE = PDFName.of('DCTDecode');
+var PDF_NAME_FLATEDECODE = PDFName.of('FlateDecode');
 var PDF_NAME_SMASK = PDFName.of('SMask');
 var PDF_NAME_MASK = PDFName.of('Mask');
-function isCompressibleImageStream(stream) {
+var PDF_NAME_WIDTH = PDFName.of('Width');
+var PDF_NAME_HEIGHT = PDFName.of('Height');
+var PDF_NAME_BITS_PER_COMPONENT = PDFName.of('BitsPerComponent');
+var PDF_NAME_COLOR_SPACE = PDFName.of('ColorSpace');
+var PDF_NAME_DECODE = PDFName.of('Decode');
+var PDF_NAME_IMAGE_MASK = PDFName.of('ImageMask');
+var PDF_NAME_DECODE_PARMS = PDFName.of('DecodeParms');
+var PDF_NAME_PREDICTOR = PDFName.of('Predictor');
+var PDF_NAME_COLORS = PDFName.of('Colors');
+var PDF_NAME_COLUMNS = PDFName.of('Columns');
+var PDF_NAME_DEVICE_RGB = PDFName.of('DeviceRGB');
+var PDF_NAME_DEVICE_GRAY = PDFName.of('DeviceGray');
+var PDF_NAME_CAL_RGB = PDFName.of('CalRGB');
+var PDF_NAME_CAL_GRAY = PDFName.of('CalGray');
+var PDF_NAME_ICC_BASED = PDFName.of('ICCBased');
+var PDF_NAME_N = PDFName.of('N');
+function compressibleImageStreamType(stream) {
     var dict = stream.dict;
-    var result = false;
+    var result;
     // Must be Type /XObject (when present) and Subtype /Image
     var type = dict.get(PDF_NAME_TYPE);
     var typeOk = type === undefined || pdfNameEquals(type, PDF_NAME_XOBJECT);
@@ -8947,13 +9051,15 @@ function isCompressibleImageStream(stream) {
         // Skip images with masks; replacing them risks breaking the mask alignment.
         var hasMask = dict.get(PDF_NAME_SMASK) !== undefined || dict.get(PDF_NAME_MASK) !== undefined;
         if (subtypeOk && !hasMask) {
-            // Only DCTDecode (JPEG) streams in v1.
             var filter = dict.get(PDF_NAME_FILTER);
-            if (filter !== undefined) {
-                if (_instanceof$1(filter, PDFArray)) {
-                    result = filter.size() === 1 && pdfNameEquals(filter.get(0), PDF_NAME_DCTDECODE);
-                } else {
-                    result = pdfNameEquals(filter, PDF_NAME_DCTDECODE);
+            if (_instanceof$1(filter, PDFArray) && filter.size() === 1) {
+                filter = filter.get(0);
+            }
+            if (_instanceof$1(filter, PDFName)) {
+                if (pdfNameEquals(filter, PDF_NAME_DCTDECODE)) {
+                    result = 'jpeg';
+                } else if (pdfNameEquals(filter, PDF_NAME_FLATEDECODE)) {
+                    result = 'flateRaster';
                 }
             }
         }
@@ -8963,15 +9069,217 @@ function isCompressibleImageStream(stream) {
 function pdfNameEquals(candidate, name) {
     return _instanceof$1(candidate, PDFName) && candidate.asString() === name.asString();
 }
+function lookupPdfObject(pdfDoc, value) {
+    return _instanceof$1(value, PDFRef) ? pdfDoc.context.lookup(value) : value;
+}
+function dictNumber(dict, name) {
+    var value = dict.get(name);
+    return _instanceof$1(value, PDFNumber) ? value.asNumber() : undefined;
+}
+function resolveImageColorSpaceChannels(pdfDoc, colorSpaceValue) {
+    var colorSpace = lookupPdfObject(pdfDoc, colorSpaceValue);
+    var result;
+    if (_instanceof$1(colorSpace, PDFName)) {
+        if (pdfNameEquals(colorSpace, PDF_NAME_DEVICE_RGB) || pdfNameEquals(colorSpace, PDF_NAME_CAL_RGB)) {
+            result = 3;
+        } else if (pdfNameEquals(colorSpace, PDF_NAME_DEVICE_GRAY) || pdfNameEquals(colorSpace, PDF_NAME_CAL_GRAY)) {
+            result = 1;
+        }
+    } else if (_instanceof$1(colorSpace, PDFArray) && colorSpace.size() > 0) {
+        var family = colorSpace.get(0);
+        if (pdfNameEquals(family, PDF_NAME_ICC_BASED) && colorSpace.size() > 1) {
+            var iccStream = lookupPdfObject(pdfDoc, colorSpace.get(1));
+            if (_instanceof$1(iccStream, PDFStream)) {
+                var componentCount = dictNumber(iccStream.dict, PDF_NAME_N);
+                if (componentCount === 3) {
+                    result = 3;
+                } else if (componentCount === 1) {
+                    result = 1;
+                }
+            }
+        } else if (pdfNameEquals(family, PDF_NAME_CAL_RGB)) {
+            result = 3;
+        } else if (pdfNameEquals(family, PDF_NAME_CAL_GRAY)) {
+            result = 1;
+        }
+    }
+    return result;
+}
+function readFlatePredictorParams(pdfDoc, dict) {
+    var _ref, _ref1, _ref2, _ref3;
+    var parmsValue = lookupPdfObject(pdfDoc, dict.get(PDF_NAME_DECODE_PARMS));
+    // A filter array pairs with a DecodeParms array; a single flate filter uses the first entry.
+    if (_instanceof$1(parmsValue, PDFArray)) {
+        parmsValue = lookupPdfObject(pdfDoc, parmsValue.size() > 0 ? parmsValue.get(0) : undefined);
+    }
+    var parms = _instanceof$1(parmsValue, PDFDict) ? parmsValue : undefined;
+    var result = {
+        predictor: (_ref = parms ? dictNumber(parms, PDF_NAME_PREDICTOR) : undefined) !== null && _ref !== void 0 ? _ref : 1,
+        colors: (_ref1 = parms ? dictNumber(parms, PDF_NAME_COLORS) : undefined) !== null && _ref1 !== void 0 ? _ref1 : 1,
+        columns: (_ref2 = parms ? dictNumber(parms, PDF_NAME_COLUMNS) : undefined) !== null && _ref2 !== void 0 ? _ref2 : 1,
+        bitsPerComponent: (_ref3 = parms ? dictNumber(parms, PDF_NAME_BITS_PER_COMPONENT) : undefined) !== null && _ref3 !== void 0 ? _ref3 : 8
+    };
+    return result;
+}
+function unpredictFlateImageData(data, params) {
+    var predictor = params.predictor, colors = params.colors, columns = params.columns, bitsPerComponent = params.bitsPerComponent;
+    var result;
+    if (predictor === 1) {
+        result = data;
+    } else if (bitsPerComponent !== 8) {
+        result = undefined; // only 8-bit predictor data is supported
+    } else if (predictor === 2) {
+        result = unpredictTiffImageData(data, colors, columns);
+    } else if (predictor >= 10 && predictor <= 15) {
+        result = unpredictPngImageData(data, colors, columns);
+    }
+    return result;
+}
+/**
+ * Reverses TIFF Predictor 2 (horizontal differencing) on 8-bit sample data, in place.
+ *
+ * @param data - Predictor-encoded sample bytes.
+ * @param colors - Samples per pixel.
+ * @param columns - Pixels per row.
+ * @returns The same buffer with the differencing undone, or `undefined` when the length is not a whole number of rows.
+ */ function unpredictTiffImageData(data, colors, columns) {
+    var rowLength = colors * columns;
+    var result;
+    if (rowLength > 0 && data.byteLength % rowLength === 0) {
+        for(var rowStart = 0; rowStart < data.byteLength; rowStart += rowLength){
+            for(var i = colors; i < rowLength; i += 1){
+                data[rowStart + i] = data[rowStart + i] + data[rowStart + i - colors] & 0xff;
+            }
+        }
+        result = data;
+    }
+    return result;
+}
+/**
+ * Reverses PNG row filters (predictors 10–15) on 8-bit sample data.
+ *
+ * @param data - Predictor-encoded bytes: each row is one filter-type byte followed by `colors * columns` filtered bytes.
+ * @param colors - Samples per pixel.
+ * @param columns - Pixels per row.
+ * @returns The unfiltered raster bytes, or `undefined` for a malformed length or an unknown filter type.
+ */ function unpredictPngImageData(data, colors, columns) {
+    var rowLength = colors * columns;
+    var encodedRowLength = rowLength + 1;
+    var result;
+    if (rowLength > 0 && data.byteLength % encodedRowLength === 0) {
+        var rows = data.byteLength / encodedRowLength;
+        var output = Buffer.alloc(rows * rowLength);
+        var valid = true;
+        for(var row = 0; row < rows && valid; row += 1){
+            valid = unpredictPngRow({
+                filterType: data[row * encodedRowLength],
+                rowIn: data.subarray(row * encodedRowLength + 1, (row + 1) * encodedRowLength),
+                output: output,
+                outStart: row * rowLength,
+                prevStart: (row - 1) * rowLength,
+                colors: colors,
+                isFirstRow: row === 0
+            });
+        }
+        result = valid ? output : undefined;
+    }
+    return result;
+}
+function unpredictPngRow(input) {
+    var filterType = input.filterType, rowIn = input.rowIn, output = input.output, outStart = input.outStart, prevStart = input.prevStart, colors = input.colors, isFirstRow = input.isFirstRow;
+    var valid = true;
+    for(var i = 0; i < rowIn.length && valid; i += 1){
+        var left = i >= colors ? output[outStart + i - colors] : 0;
+        var up = isFirstRow ? 0 : output[prevStart + i];
+        var value = 0;
+        switch(filterType){
+            case 0:
+                value = rowIn[i];
+                break;
+            case 1:
+                value = rowIn[i] + left;
+                break;
+            case 2:
+                value = rowIn[i] + up;
+                break;
+            case 3:
+                value = rowIn[i] + (left + up >> 1);
+                break;
+            case 4:
+                {
+                    // Paeth
+                    var upLeft = !isFirstRow && i >= colors ? output[prevStart + i - colors] : 0;
+                    value = rowIn[i] + paethPredictor(left, up, upLeft);
+                    break;
+                }
+            default:
+                valid = false;
+        }
+        output[outStart + i] = value & 0xff;
+    }
+    return valid;
+}
+function paethPredictor(left, up, upLeft) {
+    var initial = left + up - upLeft;
+    var distanceLeft = Math.abs(initial - left);
+    var distanceUp = Math.abs(initial - up);
+    var distanceUpLeft = Math.abs(initial - upLeft);
+    var result;
+    if (distanceLeft <= distanceUp && distanceLeft <= distanceUpLeft) {
+        result = left;
+    } else if (distanceUp <= distanceUpLeft) {
+        result = up;
+    } else {
+        result = upLeft;
+    }
+    return result;
+}
+/**
+ * Inflates a FlateDecode image stream into raw interleaved 8-bit pixel data.
+ *
+ * @param pdfDoc - Document the stream belongs to, used to resolve indirect references.
+ * @param stream - The FlateDecode image XObject stream.
+ * @returns The decoded raster, or `undefined` when the stream's raster layout is
+ * unsupported: a non-8-bit depth, an image mask, a custom `/Decode` array, an
+ * unresolvable or non-gray/RGB color space, an unsupported predictor, or a decoded
+ * length that does not match the declared dimensions.
+ */ function decodeFlateRasterImage(pdfDoc, stream) {
+    var dict = stream.dict;
+    var width = dictNumber(dict, PDF_NAME_WIDTH);
+    var height = dictNumber(dict, PDF_NAME_HEIGHT);
+    var bitsPerComponent = dictNumber(dict, PDF_NAME_BITS_PER_COMPONENT);
+    var hasDecodeArray = dict.get(PDF_NAME_DECODE) !== undefined;
+    var isImageMask = dict.get(PDF_NAME_IMAGE_MASK) !== undefined;
+    var channels = resolveImageColorSpaceChannels(pdfDoc, dict.get(PDF_NAME_COLOR_SPACE));
+    var result;
+    if (width != null && width > 0 && height != null && height > 0 && bitsPerComponent === 8 && !hasDecodeArray && !isImageMask && channels != null) {
+        var predictorParams = readFlatePredictorParams(pdfDoc, dict);
+        // when a predictor is in play its params must describe the same raster layout the image dict declares
+        var predictorParamsOk = predictorParams.predictor === 1 || predictorParams.colors === channels && predictorParams.columns === width && predictorParams.bitsPerComponent === 8;
+        if (predictorParamsOk) {
+            var inflated = inflateSync(stream.contents);
+            var data = unpredictFlateImageData(inflated, predictorParams);
+            if ((data === null || data === void 0 ? void 0 : data.byteLength) === width * height * channels) {
+                result = {
+                    data: data,
+                    width: width,
+                    height: height,
+                    channels: channels
+                };
+            }
+        }
+    }
+    return result;
+}
 function replaceImageStream(input) {
-    var pdfDoc = input.pdfDoc, ref = input.ref, newImageBytes = input.newImageBytes, newWidth = input.newWidth, newHeight = input.newHeight;
+    var pdfDoc = input.pdfDoc, ref = input.ref, newImageBytes = input.newImageBytes, newWidth = input.newWidth, newHeight = input.newHeight, colorSpace = input.colorSpace;
     var context = pdfDoc.context;
     var newDict = context.obj({
         Type: 'XObject',
         Subtype: 'Image',
         Width: newWidth,
         Height: newHeight,
-        ColorSpace: 'DeviceRGB',
+        ColorSpace: colorSpace,
         BitsPerComponent: 8,
         Filter: 'DCTDecode',
         Length: newImageBytes.length

package/model/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@dereekb/firebase-server/model",
-  "version": "13.25.1",
+  "version": "13.27.0",
   "peerDependencies": {
-    "@dereekb/analytics": "13.25.1",
-    "@dereekb/date": "13.25.1",
-    "@dereekb/firebase": "13.25.1",
-    "@dereekb/firebase-server": "13.25.1",
-    "@dereekb/model": "13.25.1",
-    "@dereekb/nestjs": "13.25.1",
-    "@dereekb/rxjs": "13.25.1",
-    "@dereekb/util": "13.25.1",
+    "@dereekb/analytics": "13.27.0",
+    "@dereekb/date": "13.27.0",
+    "@dereekb/firebase": "13.27.0",
+    "@dereekb/firebase-server": "13.27.0",
+    "@dereekb/model": "13.27.0",
+    "@dereekb/nestjs": "13.27.0",
+    "@dereekb/rxjs": "13.27.0",
+    "@dereekb/util": "13.27.0",
     "@nestjs/common": "^11.1.19",
     "@nestjs/config": "^4.0.4",
     "archiver": "^7.0.1",