@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/server/image-optimizer.js

@@ -6,18 +6,9 @@ Object.defineProperty(exports, "__esModule", {
     ImageError: null,
     ImageOptimizerCache: null,
     createPinnedLookup: null,
-    detectContentType: null,
-    extractEtag: null,
     fetchExternalImage: null,
     fetchInternalImage: null,
-    getHash: null,
-    getImageEtag: null,
-    getImageSize: null,
-    getMaxAge: null,
-    getPreviouslyCachedImageOrNull: null,
-    getSharp: null,
     imageOptimizer: null,
-    optimizeImage: null,
     sendResponse: null
 });
 function _export(target, all) {
@@ -28,7 +19,7 @@ function _export(target, all) {
 }
 _export(exports, {
     ImageError: function() {
-        return ImageError;
+        return _imageerror.ImageError;
     },
     ImageOptimizerCache: function() {
         return ImageOptimizerCache;
@@ -36,55 +27,24 @@ _export(exports, {
     createPinnedLookup: function() {
         return createPinnedLookup;
     },
-    detectContentType: function() {
-        return detectContentType;
-    },
-    extractEtag: function() {
-        return extractEtag;
-    },
     fetchExternalImage: function() {
         return fetchExternalImage;
     },
     fetchInternalImage: function() {
         return fetchInternalImage;
     },
-    getHash: function() {
-        return getHash;
-    },
-    getImageEtag: function() {
-        return getImageEtag;
-    },
-    getImageSize: function() {
-        return getImageSize;
-    },
-    getMaxAge: function() {
-        return getMaxAge;
-    },
-    getPreviouslyCachedImageOrNull: function() {
-        return getPreviouslyCachedImageOrNull;
-    },
-    getSharp: function() {
-        return getSharp;
-    },
     imageOptimizer: function() {
         return imageOptimizer;
     },
-    optimizeImage: function() {
-        return optimizeImage;
-    },
     sendResponse: function() {
         return sendResponse;
     }
 });
-const _crypto = require("crypto");
 const _fs = require("fs");
 const _http = require("http");
 const _https = require("https");
 const _accept = require("next/dist/compiled/@hapi/accept");
 const _contentdisposition = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/content-disposition"));
-const _imagesize = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/image-size"));
-const _detector = require("next/dist/compiled/image-detector/detector.js");
-const _isanimated = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/is-animated"));
 const _path = require("path");
 const _imageblursvg = require("../shared/lib/image-blur-svg");
 const _matchlocalpattern = require("../shared/lib/match-local-pattern");
@@ -94,7 +54,6 @@ const _responsecache = require("./response-cache");
 const _sendpayload = require("./send-payload");
 const _servestatic = require("./serve-static");
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
-const _iserror = /*#__PURE__*/ _interop_require_default(require("../lib/is-error"));
 const _isprivateip = require("./is-private-ip");
 const _disklrucacheexternal = require("./lib/disk-lru-cache.external");
 const _url = require("../lib/url");
@@ -104,6 +63,11 @@ const _net = require("net");
 const _dns = require("dns");
 const _stream = require("stream");
 const _zlib = require("zlib");
+const _transform = require("./image-optimizer/transform");
+const _extractetag = require("./image-optimizer/extract-etag");
+const _getpreviouslycachedimageornull = require("./image-optimizer/get-previously-cached-image-or-null");
+const _getimagesize = require("./image-optimizer/get-image-size");
+const _imageerror = require("./image-optimizer/image-error");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -150,39 +114,11 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const AVIF = 'image/avif';
-const WEBP = 'image/webp';
-const PNG = 'image/png';
-const JPEG = 'image/jpeg';
-const JXL = 'image/jxl';
-const JP2 = 'image/jp2';
-const HEIC = 'image/heic';
-const GIF = 'image/gif';
-const SVG = 'image/svg+xml';
-const ICO = 'image/x-icon';
-const ICNS = 'image/x-icns';
-const TIFF = 'image/tiff';
-const BMP = 'image/bmp';
-const PDF = 'application/pdf';
 const CACHE_VERSION = 4;
-const ANIMATABLE_TYPES = [
-    WEBP,
-    PNG,
-    GIF
-];
-const BYPASS_TYPES = [
-    SVG,
-    ICO,
-    ICNS,
-    BMP,
-    JXL,
-    HEIC
-];
 const BLUR_IMG_SIZE = 8 // should match `next-image-loader`
 ;
 const BLUR_QUALITY = 70 // should match `next-image-loader`
 ;
-let _sharp;
 async function initCacheEntries(cacheDir) {
     const cacheKeys = await _fs.promises.readdir(cacheDir).catch(()=>[]);
     const entries = [];
@@ -201,85 +137,13 @@ async function initCacheEntries(cacheDir) {
     // Sort oldest-first so we can replay them chronologically into LRU
     return entries.sort((a, b)=>a.expireAt - b.expireAt);
 }
-function getSharp(concurrency, operationCache) {
-    if (_sharp) {
-        return _sharp;
-    }
-    try {
-        _sharp = require('sharp');
-        _sharp.block({
-            operation: [
-                'VipsForeignLoad'
-            ]
-        });
-        _sharp.unblock({
-            operation: [
-                'VipsForeignLoadHeif',
-                'VipsForeignLoadJpeg',
-                'VipsForeignLoadNsgif',
-                'VipsForeignLoadPng',
-                'VipsForeignLoadSvg',
-                'VipsForeignLoadTiff',
-                'VipsForeignLoadWebp'
-            ]
-        });
-        if (typeof operationCache === 'boolean') {
-            _sharp.cache(operationCache);
-        }
-        if (_sharp.concurrency() > 1) {
-            // Reducing concurrency should reduce the memory usage too.
-            // We more aggressively reduce in dev but also reduce in prod.
-            // https://sharp.pixelplumbing.com/api-utility#concurrency
-            const divisor = process.env.NODE_ENV === 'development' ? 4 : 2;
-            _sharp.concurrency(concurrency ?? Math.floor(Math.max(_sharp.concurrency() / divisor, 1)));
-        }
-    } catch (e) {
-        if ((0, _iserror.default)(e) && e.code === 'MODULE_NOT_FOUND') {
-            throw Object.defineProperty(new Error('Module `sharp` not found. Please run `npm install --cpu=wasm32 sharp` to install it.'), "__NEXT_ERROR_CODE", {
-                value: "E47",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        throw e;
-    }
-    return _sharp;
-}
 function getSupportedMimeType(options, accept = '') {
     const mimeType = (0, _accept.mediaType)(accept, options);
     return accept.includes(mimeType) ? mimeType : '';
 }
-function getHash(items) {
-    const hash = (0, _crypto.createHash)('sha256');
-    for (let item of items){
-        if (typeof item === 'number') hash.update(String(item));
-        else {
-            hash.update(item);
-        }
-    }
-    // See https://en.wikipedia.org/wiki/Base64#URL_applications
-    return hash.digest('base64url');
-}
-function extractEtag(etag, imageBuffer) {
-    if (etag) {
-        // upstream etag needs to be base64url encoded due to weak etag signature
-        // as we store this in the cache-entry file name.
-        return Buffer.from(etag).toString('base64url');
-    }
-    return getImageEtag(imageBuffer);
-}
-function getImageEtag(image) {
-    return getHash([
-        image
-    ]);
-}
 async function writeToCacheDir(cacheDir, cacheKey, extension, maxAge, expireAt, buffer, etag, upstreamEtag) {
     if (buffer.byteLength === 0) {
-        throw Object.defineProperty(new Error('Invariant: cannot write an empty buffer to the image cache'), "__NEXT_ERROR_CODE", {
-            value: "E1470",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Invariant: cannot write an empty buffer to the image cache');
     }
     const dir = (0, _path.join)(/* turbopackIgnore: true */ cacheDir, cacheKey);
     const filename = (0, _path.join)(/* turbopackIgnore: true */ dir, `${maxAge}.${expireAt}.${etag}.${upstreamEtag}.${extension}`);
@@ -297,21 +161,13 @@ async function readFromCacheDir(cacheDir, cacheKey) {
     const files = await _fs.promises.readdir(dir);
     const file = files[0];
     if (!file) {
-        throw Object.defineProperty(new Error(`Invariant: cache entry "${cacheKey}" not found in dir "${cacheDir}"`), "__NEXT_ERROR_CODE", {
-            value: "E1069",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invariant: cache entry "${cacheKey}" not found in dir "${cacheDir}"`);
     }
     const [maxAgeSt, expireAtSt, etag, upstreamEtag, extension] = file.split('.', 5);
     const filePath = (0, _path.join)(/* turbopackIgnore: true */ dir, file);
     const buffer = await _fs.promises.readFile(/* turbopackIgnore: true */ filePath);
     if (buffer.byteLength === 0) {
-        throw Object.defineProperty(new Error(`Invariant: image cache entry "${cacheKey}" is empty`), "__NEXT_ERROR_CODE", {
-            value: "E1469",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invariant: image cache entry "${cacheKey}" is empty`);
     }
     const expireAt = Number(expireAtSt);
     const maxAge = Number(maxAgeSt);
@@ -332,221 +188,6 @@ async function deleteFromCacheDir(cacheDir, cacheKey) {
         _log.error(`Failed to delete cache key ${cacheKey}`, err);
     });
 }
-async function detectContentType(buffer) {
-    if (buffer.byteLength === 0) {
-        return null;
-    }
-    if ([
-        0xff,
-        0xd8,
-        0xff
-    ].every((b, i)=>buffer[i] === b)) {
-        return JPEG;
-    }
-    if ([
-        0x89,
-        0x50,
-        0x4e,
-        0x47,
-        0x0d,
-        0x0a,
-        0x1a,
-        0x0a
-    ].every((b, i)=>buffer[i] === b)) {
-        return PNG;
-    }
-    if ([
-        0x47,
-        0x49,
-        0x46,
-        0x38
-    ].every((b, i)=>buffer[i] === b)) {
-        return GIF;
-    }
-    if ([
-        0x52,
-        0x49,
-        0x46,
-        0x46,
-        0,
-        0,
-        0,
-        0,
-        0x57,
-        0x45,
-        0x42,
-        0x50
-    ].every((b, i)=>!b || buffer[i] === b)) {
-        return WEBP;
-    }
-    if ([
-        0x3c,
-        0x3f,
-        0x78,
-        0x6d,
-        0x6c
-    ].every((b, i)=>buffer[i] === b)) {
-        return SVG;
-    }
-    if ([
-        0x3c,
-        0x73,
-        0x76,
-        0x67
-    ].every((b, i)=>buffer[i] === b)) {
-        return SVG;
-    }
-    if ([
-        0,
-        0,
-        0,
-        0,
-        0x66,
-        0x74,
-        0x79,
-        0x70,
-        0x61,
-        0x76,
-        0x69,
-        0x66
-    ].every((b, i)=>!b || buffer[i] === b)) {
-        return AVIF;
-    }
-    if ([
-        0x00,
-        0x00,
-        0x01,
-        0x00
-    ].every((b, i)=>buffer[i] === b)) {
-        return ICO;
-    }
-    if ([
-        0x69,
-        0x63,
-        0x6e,
-        0x73
-    ].every((b, i)=>buffer[i] === b)) {
-        return ICNS;
-    }
-    if ([
-        0x49,
-        0x49,
-        0x2a,
-        0x00
-    ].every((b, i)=>buffer[i] === b)) {
-        return TIFF;
-    }
-    if ([
-        0x42,
-        0x4d
-    ].every((b, i)=>buffer[i] === b)) {
-        return BMP;
-    }
-    if ([
-        0xff,
-        0x0a
-    ].every((b, i)=>buffer[i] === b)) {
-        return JXL;
-    }
-    if ([
-        0x00,
-        0x00,
-        0x00,
-        0x0c,
-        0x4a,
-        0x58,
-        0x4c,
-        0x20,
-        0x0d,
-        0x0a,
-        0x87,
-        0x0a
-    ].every((b, i)=>buffer[i] === b)) {
-        return JXL;
-    }
-    if ([
-        0,
-        0,
-        0,
-        0,
-        0x66,
-        0x74,
-        0x79,
-        0x70,
-        0x68,
-        0x65,
-        0x69,
-        0x63
-    ].every((b, i)=>!b || buffer[i] === b)) {
-        return HEIC;
-    }
-    if ([
-        0x25,
-        0x50,
-        0x44,
-        0x46,
-        0x2d
-    ].every((b, i)=>buffer[i] === b)) {
-        return PDF;
-    }
-    if ([
-        0x00,
-        0x00,
-        0x00,
-        0x0c,
-        0x6a,
-        0x50,
-        0x20,
-        0x20,
-        0x0d,
-        0x0a,
-        0x87,
-        0x0a
-    ].every((b, i)=>buffer[i] === b)) {
-        return JP2;
-    }
-    const format = (0, _detector.detector)(buffer.subarray(0, 1024));
-    switch(format){
-        case 'webp':
-            return WEBP;
-        case 'png':
-            return PNG;
-        case 'jpg':
-            return JPEG;
-        case 'gif':
-            return GIF;
-        case 'svg':
-            return SVG;
-        case 'jxl':
-        case 'jxl-stream':
-            return JXL;
-        case 'jp2':
-            return JP2;
-        case 'tiff':
-            return TIFF;
-        case 'bmp':
-            return BMP;
-        case 'ico':
-            return ICO;
-        case 'icns':
-            return ICNS;
-        case 'heif':
-        case 'cur':
-        case 'dds':
-        case 'j2c':
-        case 'ktx':
-        case 'pnm':
-        case 'psd':
-        case 'tga':
-        case undefined:
-            return null // unsupported formats
-            ;
-        default:
-            format; // exhaustive check
-            return null // impossible to reach
-            ;
-    }
-}
 class ImageOptimizerCache {
     static validateParams(req, query, nextConfig, isDev) {
         var _nextConfig_images, _nextConfig_images1, _nextConfig_images2;
@@ -672,15 +313,10 @@ class ImageOptimizerCache {
                 errorMessage: '"q" parameter (quality) must be an integer between 1 and 100'
             };
         }
-        if (qualities) {
-            if (isDev) {
-                qualities.push(BLUR_QUALITY);
-            }
-            if (!qualities.includes(quality)) {
-                return {
-                    errorMessage: `"q" parameter (quality) of ${q} is not allowed`
-                };
-            }
+        if (qualities && !qualities.includes(quality) && !(isDev && quality === BLUR_QUALITY)) {
+            return {
+                errorMessage: `"q" parameter (quality) of ${q} is not allowed`
+            };
         }
         const mimeType = getSupportedMimeType(formats || [], req.headers['accept']);
         const isStatic = url.startsWith(`${nextConfig.basePath || ''}/_next/static/media`) || url.startsWith(`${nextConfig.basePath || ''}/_next/static/immutable/media`);
@@ -696,7 +332,7 @@ class ImageOptimizerCache {
         };
     }
     static getCacheKey({ href, width, quality, mimeType }) {
-        return getHash([
+        return (0, _extractetag.getHash)([
             CACHE_VERSION,
             href,
             width,
@@ -780,19 +416,11 @@ class ImageOptimizerCache {
     }
     async set(cacheKey, value, { cacheControl }) {
         if ((value == null ? void 0 : value.kind) !== _responsecache.CachedRouteKind.IMAGE) {
-            throw Object.defineProperty(new Error('invariant attempted to set non-image to image-cache'), "__NEXT_ERROR_CODE", {
-                value: "E366",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('invariant attempted to set non-image to image-cache');
         }
         const revalidate = cacheControl == null ? void 0 : cacheControl.revalidate;
         if (typeof revalidate !== 'number') {
-            throw Object.defineProperty(new _invarianterror.InvariantError('revalidate must be a number for image-cache'), "__NEXT_ERROR_CODE", {
-                value: "E657",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('revalidate must be a number for image-cache');
         }
         // If a custom cache handler is provided, use it
         if (this.cacheHandler) {
@@ -825,11 +453,7 @@ class ImageOptimizerCache {
             const lru = await this.cacheDiskLRU;
             const success = lru == null ? void 0 : lru.set(cacheKey, value.buffer.byteLength);
             if (success === false) {
-                throw Object.defineProperty(new Error(`image of size ${value.buffer.byteLength} could not be tracked by lru cache`), "__NEXT_ERROR_CODE", {
-                    value: "E1070",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`image of size ${value.buffer.byteLength} could not be tracked by lru cache`);
             }
             await writeToCacheDir(this.cacheDir, cacheKey, value.extension, revalidate, expireAt, value.buffer, value.etag, value.upstreamEtag);
         } catch (err) {
@@ -837,101 +461,6 @@ class ImageOptimizerCache {
         }
     }
 }
-class ImageError extends Error {
-    constructor(statusCode, message){
-        super(message);
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
-        // ensure an error status is used > 400
-        if (statusCode >= 400) {
-            this.statusCode = statusCode;
-        } else {
-            this.statusCode = 500;
-        }
-    }
-}
-function parseCacheControl(str) {
-    const map = new Map();
-    if (!str) {
-        return map;
-    }
-    for (let directive of str.split(',')){
-        let [key, value] = directive.trim().split('=', 2);
-        key = key.toLowerCase();
-        if (value) {
-            value = value.toLowerCase();
-        }
-        map.set(key, value);
-    }
-    return map;
-}
-function getMaxAge(str) {
-    const map = parseCacheControl(str);
-    if (map) {
-        let age = map.get('s-maxage') || map.get('max-age') || '';
-        if (age.startsWith('"') && age.endsWith('"')) {
-            age = age.slice(1, -1);
-        }
-        const n = parseInt(age, 10);
-        if (!isNaN(n)) {
-            return n;
-        }
-    }
-    return 0;
-}
-function getPreviouslyCachedImageOrNull(upstreamImage, previousCacheEntry) {
-    var _previousCacheEntry_value;
-    if ((previousCacheEntry == null ? void 0 : (_previousCacheEntry_value = previousCacheEntry.value) == null ? void 0 : _previousCacheEntry_value.kind) === 'IMAGE' && // Images that are SVGs, animated or failed the optimization previously end up using upstreamEtag as their etag as well,
-    // in these cases we want to trigger a new "optimization" attempt.
-    previousCacheEntry.value.upstreamEtag !== previousCacheEntry.value.etag && // and the upstream etag is the same as the previous cache entry's
-    upstreamImage.etag === previousCacheEntry.value.upstreamEtag) {
-        return previousCacheEntry.value;
-    }
-    return null;
-}
-async function optimizeImage({ buffer, contentType, quality, width, height, concurrency, operationCache, limitInputPixels, sequentialRead, timeoutInSeconds }) {
-    const sharp = getSharp(concurrency, operationCache);
-    const transformer = sharp(buffer, {
-        limitInputPixels,
-        sequentialRead: sequentialRead ?? undefined
-    }).timeout({
-        seconds: timeoutInSeconds ?? 7
-    }).rotate();
-    if (height) {
-        transformer.resize(width, height);
-    } else {
-        transformer.resize(width, undefined, {
-            withoutEnlargement: true
-        });
-    }
-    if (contentType === AVIF) {
-        transformer.avif({
-            // Scale the quality to try and match webp. This ratio was derived
-            // from sharp's default 80 (webp) and 50 (avif), and then verified
-            // using dssim and ssimulacra2 visual quality tests.
-            quality: Math.max(Math.round(quality * (50 / 80)), 1),
-            effort: 3
-        });
-    } else if (contentType === WEBP) {
-        transformer.webp({
-            quality
-        });
-    } else if (contentType === PNG) {
-        transformer.png({
-            quality
-        });
-    } else if (contentType === JPEG) {
-        transformer.jpeg({
-            quality,
-            mozjpeg: true
-        });
-    }
-    const optimizedBuffer = await transformer.toBuffer();
-    return optimizedBuffer;
-}
 function isRedirect(statusCode) {
     return [
         301,
@@ -943,11 +472,7 @@ function isRedirect(statusCode) {
 }
 function upstreamTimedOut(href) {
     _log.error('upstream image response timed out for', href);
-    return Object.defineProperty(new ImageError(504, '"url" parameter is valid but upstream response timed out'), "__NEXT_ERROR_CODE", {
-        value: "E394",
-        enumerable: false,
-        configurable: true
-    });
+    return new _imageerror.ImageError(504, '"url" parameter is valid but upstream response timed out');
 }
 const agentOptions = {
     keepAlive: true,
@@ -1087,11 +612,7 @@ function decodeResponseBody(res, href) {
     const codings = contentEncoding.toLowerCase().split(',');
     if (codings.length > MAX_CONTENT_ENCODINGS) {
         _log.error('upstream image response had too many content encodings for', href);
-        throw Object.defineProperty(new ImageError(400, '"url" parameter is valid but upstream response is invalid'), "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _imageerror.ImageError(400, '"url" parameter is valid but upstream response is invalid');
     }
     const decoders = [];
     for(let i = codings.length - 1; i >= 0; i--){
@@ -1147,11 +668,7 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
         const privateIps = addresses.map((record)=>record.address).filter((ip)=>(0, _isprivateip.isPrivateIp)(ip));
         if (privateIps.length > 0) {
             _log.error('upstream image', href, 'hostname resolved to private IP', JSON.stringify(privateIps), 'If this is expected and you understand SSRF risk, use images.dangerouslyAllowLocalIP = true to continue.');
-            throw Object.defineProperty(new ImageError(400, '"url" parameter is not allowed'), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _imageerror.ImageError(400, '"url" parameter is not allowed');
         }
     }
     // The signal is owned here rather than by `requestUpstreamImage()` because it
@@ -1181,11 +698,7 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
         res.destroy();
         if (count === 0) {
             _log.error('upstream image response had too many redirects', href);
-            throw Object.defineProperty(new ImageError(508, '"url" parameter is valid but upstream response is invalid'), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _imageerror.ImageError(508, '"url" parameter is valid but upstream response is invalid');
         }
         const redirect = new URL(locationHeader, href).href;
         return fetchExternalImage(redirect, dangerouslyAllowLocalIP, maximumResponseBody, count - 1);
@@ -1193,11 +706,7 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
     if (statusCode < 200 || statusCode > 299) {
         res.destroy();
         _log.error('upstream image response failed for', href, statusCode);
-        throw Object.defineProperty(new ImageError(statusCode, '"url" parameter is valid but upstream response is invalid'), "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _imageerror.ImageError(statusCode, '"url" parameter is valid but upstream response is invalid');
     }
     const chunks = [];
     let totalSize = 0;
@@ -1209,11 +718,7 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
             totalSize += chunk.byteLength;
             if (totalSize > maximumResponseBody) {
                 _log.error('upstream image response exceeded maximum size for', href, totalSize);
-                throw Object.defineProperty(new ImageError(413, '"url" parameter is valid but upstream response is invalid'), "__NEXT_ERROR_CODE", {
-                    value: "E394",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _imageerror.ImageError(413, '"url" parameter is valid but upstream response is invalid');
             }
             chunks.push(chunk);
         }
@@ -1226,16 +731,12 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
     }
     if (totalSize === 0) {
         _log.error('upstream image response is empty for', href);
-        throw Object.defineProperty(new ImageError(400, '"url" parameter is valid but upstream response is invalid'), "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _imageerror.ImageError(400, '"url" parameter is valid but upstream response is invalid');
     }
     const buffer = Buffer.concat(chunks);
     const contentType = res.headers['content-type'];
     const cacheControl = res.headers['cache-control'];
-    const etag = extractEtag(res.headers.etag, buffer);
+    const etag = (0, _extractetag.extractEtag)(res.headers.etag, buffer);
     return {
         buffer,
         contentType,
@@ -1247,34 +748,40 @@ async function fetchInternalImage(href, _req, _res, maximumResponseBody, handleR
     try {
         // Coerce HEAD to GET to avoid issues with the image optimizer
         const method = !_req.method || _req.method === 'HEAD' ? 'GET' : _req.method;
-        const mocked = (0, _mockrequest.createRequestResponseMocks)({
-            url: href,
-            method,
-            socket: _req.socket,
-            maximumResponseBody
-        });
+        // The mocked request keeps the requester's socket so that protocol and
+        // remote address detection keep working, but the mocked response must not
+        // reference it. `send` (used by `serveStatic`) watches `res.socket` through
+        // `on-finished` and treats the response as finished as soon as that socket
+        // stops being writable. When the requester disconnected mid-transfer this
+        // tore down the file stream without ever ending the mocked response, and
+        // since `ResponseCache` coalesces every request for the same cache key onto
+        // this single fetch, the key stayed pending for every later requester until
+        // the server restarted.
+        const mocked = {
+            req: new _mockrequest.MockedRequest({
+                url: href,
+                method,
+                headers: {},
+                socket: _req.socket
+            }),
+            res: new _mockrequest.MockedResponse({
+                maximumResponseBody
+            })
+        };
         await handleRequest(mocked.req, mocked.res, (0, _url.parseReqUrl)(href));
         await mocked.res.hasStreamed;
-        if (!mocked.res.statusCode) {
-            _log.error('image response failed for', href, mocked.res.statusCode);
-            throw Object.defineProperty(new ImageError(mocked.res.statusCode, '"url" parameter is valid but internal response is invalid'), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+        if (!mocked.res.statusCode || mocked.res.statusCode < 200 || mocked.res.statusCode > 299) {
+            _log.error('internal image response failed for', href, mocked.res.statusCode);
+            throw new _imageerror.ImageError(mocked.res.statusCode, '"url" parameter is valid but internal response is invalid');
         }
         if (mocked.res.buffers.length === 0) {
             _log.error('internal image response is empty for', href);
-            throw Object.defineProperty(new ImageError(400, '"url" parameter is valid but internal response is invalid'), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _imageerror.ImageError(400, '"url" parameter is valid but internal response is invalid');
         }
         const buffer = Buffer.concat(mocked.res.buffers);
         const contentType = mocked.res.getHeader('Content-Type');
         const cacheControl = mocked.res.getHeader('Cache-Control');
-        const etag = extractEtag(mocked.res.getHeader('ETag'), buffer);
+        const etag = (0, _extractetag.extractEtag)(mocked.res.getHeader('ETag'), buffer);
         return {
             buffer,
             contentType,
@@ -1282,141 +789,45 @@ async function fetchInternalImage(href, _req, _res, maximumResponseBody, handleR
             etag
         };
     } catch (err) {
-        if (err instanceof ImageError) {
+        if (err instanceof _imageerror.ImageError) {
             throw err;
         }
         if (err && typeof err === 'object' && 'code' in err && err.code === 'ERR_MAX_BODY_SIZE_EXCEEDED') {
             _log.error('internal image response exceeded maximum size for', href);
-            throw Object.defineProperty(new ImageError(413, '"url" parameter is valid but internal response is invalid'), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _imageerror.ImageError(413, '"url" parameter is valid but internal response is invalid');
         }
         _log.error('upstream image response failed for', href, err);
-        throw Object.defineProperty(new ImageError(500, '"url" parameter is valid but upstream response is invalid'), "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
-    }
+        throw new _imageerror.ImageError(500, '"url" parameter is valid but upstream response is invalid');
+    }
+}
+async function makeBlurPlaceholder(buffer, contentType) {
+    // During `next dev`, we don't want to generate blur placeholders with webpack
+    // because it can delay starting the dev server. Instead, `next-image-loader.js`
+    // will inline a special url to lazily generate the blur placeholder at request time.
+    const meta = await (0, _getimagesize.getImageSize)(buffer);
+    const blurOpts = {
+        blurWidth: meta.width,
+        blurHeight: meta.height,
+        blurDataURL: `data:${contentType};base64,${buffer.toString('base64')}`
+    };
+    return {
+        buffer: Buffer.from(unescape((0, _imageblursvg.getImageBlurSvg)(blurOpts))),
+        contentType: 'image/svg+xml'
+    };
 }
 async function imageOptimizer(imageUpstream, paramsResult, nextConfig, opts) {
-    const { href, quality, width, mimeType } = paramsResult;
-    const { buffer: upstreamBuffer, etag: upstreamEtag } = imageUpstream;
-    const maxAge = Math.max(nextConfig.images.minimumCacheTTL, getMaxAge(imageUpstream.cacheControl));
-    const upstreamType = await detectContentType(upstreamBuffer);
-    if (!upstreamType || !upstreamType.startsWith('image/') || upstreamType.includes(',')) {
-        if (!opts.silent) {
-            _log.error("The requested resource isn't a valid image for", href, 'received', upstreamType);
-        }
-        throw Object.defineProperty(new ImageError(400, "The requested resource isn't a valid image."), "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    if (upstreamType.startsWith('image/svg') && !nextConfig.images.dangerouslyAllowSVG) {
-        if (!opts.silent) {
-            _log.error(`The requested resource "${href}" has type "${upstreamType}" but dangerouslyAllowSVG is disabled. Consider adding the "unoptimized" property to the <Image>.`);
-        }
-        throw Object.defineProperty(new ImageError(400, '"url" parameter is valid but image type is not allowed'), "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    if (ANIMATABLE_TYPES.includes(upstreamType) && (0, _isanimated.default)(upstreamBuffer)) {
-        if (!opts.silent) {
-            _log.warnOnce(`The requested resource "${href}" is an animated image so it will not be optimized. Consider adding the "unoptimized" property to the <Image>.`);
-        }
-        return {
-            buffer: upstreamBuffer,
-            contentType: upstreamType,
-            maxAge,
-            etag: upstreamEtag,
-            upstreamEtag
-        };
-    }
-    if (BYPASS_TYPES.includes(upstreamType)) {
-        return {
-            buffer: upstreamBuffer,
-            contentType: upstreamType,
-            maxAge,
-            etag: upstreamEtag,
-            upstreamEtag
-        };
-    }
-    let contentType;
-    if (mimeType) {
-        contentType = mimeType;
-    } else if ((0, _servestatic.getExtension)(upstreamType) && upstreamType !== WEBP && upstreamType !== AVIF) {
-        contentType = upstreamType;
-    } else {
-        contentType = JPEG;
-    }
-    const previouslyCachedImage = getPreviouslyCachedImageOrNull(imageUpstream, opts.previousCacheEntry);
-    if (previouslyCachedImage) {
-        var _opts_previousCacheEntry_cacheControl, _opts_previousCacheEntry;
-        return {
+    var _opts_previousCacheEntry_cacheControl, _opts_previousCacheEntry;
+    const previouslyCachedImage = (0, _getpreviouslycachedimageornull.getPreviouslyCachedImageOrNull)(imageUpstream, opts.previousCacheEntry);
+    return (0, _transform.imageOptimizerTransform)(imageUpstream, paramsResult, nextConfig, {
+        previousOutput: previouslyCachedImage ? {
             buffer: previouslyCachedImage.buffer,
-            contentType,
-            maxAge: (opts == null ? void 0 : (_opts_previousCacheEntry = opts.previousCacheEntry) == null ? void 0 : (_opts_previousCacheEntry_cacheControl = _opts_previousCacheEntry.cacheControl) == null ? void 0 : _opts_previousCacheEntry_cacheControl.revalidate) || maxAge,
+            maxAge: ((_opts_previousCacheEntry = opts.previousCacheEntry) == null ? void 0 : (_opts_previousCacheEntry_cacheControl = _opts_previousCacheEntry.cacheControl) == null ? void 0 : _opts_previousCacheEntry_cacheControl.revalidate) || undefined,
             etag: previouslyCachedImage.etag,
             upstreamEtag: previouslyCachedImage.upstreamEtag
-        };
-    }
-    try {
-        let optimizedBuffer = await optimizeImage({
-            buffer: upstreamBuffer,
-            contentType,
-            quality,
-            width,
-            concurrency: nextConfig.experimental.imgOptConcurrency,
-            operationCache: nextConfig.experimental.imgOptOperationCache,
-            limitInputPixels: nextConfig.experimental.imgOptMaxInputPixels,
-            sequentialRead: nextConfig.experimental.imgOptSequentialRead,
-            timeoutInSeconds: nextConfig.experimental.imgOptTimeoutInSeconds
-        });
-        if (opts.isDev && width <= BLUR_IMG_SIZE && quality === BLUR_QUALITY) {
-            // During `next dev`, we don't want to generate blur placeholders with webpack
-            // because it can delay starting the dev server. Instead, `next-image-loader.js`
-            // will inline a special url to lazily generate the blur placeholder at request time.
-            const meta = await getImageSize(optimizedBuffer);
-            const blurOpts = {
-                blurWidth: meta.width,
-                blurHeight: meta.height,
-                blurDataURL: `data:${contentType};base64,${optimizedBuffer.toString('base64')}`
-            };
-            optimizedBuffer = Buffer.from(unescape((0, _imageblursvg.getImageBlurSvg)(blurOpts)));
-            contentType = 'image/svg+xml';
-        }
-        return {
-            buffer: optimizedBuffer,
-            contentType,
-            maxAge,
-            etag: getImageEtag(optimizedBuffer),
-            upstreamEtag
-        };
-    } catch (error) {
-        if (upstreamType) {
-            // If we fail to optimize, fallback to the original image
-            return {
-                buffer: upstreamBuffer,
-                contentType: upstreamType,
-                maxAge: nextConfig.images.minimumCacheTTL,
-                etag: upstreamEtag,
-                upstreamEtag,
-                error
-            };
-        } else {
-            throw Object.defineProperty(new ImageError(400, 'Unable to optimize image and unable to fallback to upstream image'), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
-        }
-    }
+        } : undefined,
+        logger: opts.silent ? undefined : _log,
+        handleDevOutput: opts.isDev && paramsResult.width <= BLUR_IMG_SIZE && paramsResult.quality === BLUR_QUALITY ? makeBlurPlaceholder : undefined
+    });
 }
 function getFileNameWithExtension(url, contentType) {
     const [urlWithoutQueryParams] = url.split('?', 1);
@@ -1463,12 +874,5 @@ function sendResponse(req, res, url, extension, buffer, etag, isStatic, xCache,
         }
     }
 }
-async function getImageSize(buffer) {
-    const { width, height } = (0, _imagesize.default)(buffer);
-    return {
-        width,
-        height
-    };
-}
 
 //# sourceMappingURL=image-optimizer.js.map