db-json-cli 2.0.1 → 2.0.2

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

@@ -0,0 +1,914 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ImageError: null,
+    ImageOptimizerCache: null,
+    detectContentType: null,
+    fetchExternalImage: null,
+    fetchInternalImage: null,
+    getHash: null,
+    getImageSize: null,
+    getMaxAge: null,
+    imageOptimizer: null,
+    optimizeImage: null,
+    sendResponse: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ImageError: function() {
+        return ImageError;
+    },
+    ImageOptimizerCache: function() {
+        return ImageOptimizerCache;
+    },
+    detectContentType: function() {
+        return detectContentType;
+    },
+    fetchExternalImage: function() {
+        return fetchExternalImage;
+    },
+    fetchInternalImage: function() {
+        return fetchInternalImage;
+    },
+    getHash: function() {
+        return getHash;
+    },
+    getImageSize: function() {
+        return getImageSize;
+    },
+    getMaxAge: function() {
+        return getMaxAge;
+    },
+    imageOptimizer: function() {
+        return imageOptimizer;
+    },
+    optimizeImage: function() {
+        return optimizeImage;
+    },
+    sendResponse: function() {
+        return sendResponse;
+    }
+});
+const _crypto = require("crypto");
+const _fs = require("fs");
+const _os = require("os");
+const _accept = require("next/dist/compiled/@hapi/accept");
+const _contentdisposition = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/content-disposition"));
+const _getorientation = require("next/dist/compiled/get-orientation");
+const _imagesize = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/image-size"));
+const _isanimated = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/is-animated"));
+const _path = require("path");
+const _url = /*#__PURE__*/ _interop_require_default(require("url"));
+const _imageblursvg = require("../shared/lib/image-blur-svg");
+const _matchlocalpattern = require("../shared/lib/match-local-pattern");
+const _matchremotepattern = require("../shared/lib/match-remote-pattern");
+const _mockrequest = require("./lib/mock-request");
+const _sendpayload = require("./send-payload");
+const _servestatic = require("./serve-static");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
+const _url1 = require("../lib/url");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    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 = 3;
+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;
+try {
+    sharp = require(process.env.NEXT_SHARP_PATH || "sharp");
+    if (sharp && 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(Math.floor(Math.max((0, _os.cpus)().length / divisor, 1)));
+    }
+} catch (e) {
+// Sharp not present on the server, Squoosh fallback will be used
+}
+let showSharpMissingWarning = process.env.NODE_ENV === "production";
+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#Filenames
+    return hash.digest("base64").replace(/\//g, "-");
+}
+async function writeToCacheDir(dir, extension, maxAge, expireAt, buffer, etag) {
+    const filename = (0, _path.join)(dir, `${maxAge}.${expireAt}.${etag}.${extension}`);
+    await _fs.promises.rm(dir, {
+        recursive: true,
+        force: true
+    }).catch(()=>{});
+    await _fs.promises.mkdir(dir, {
+        recursive: true
+    });
+    await _fs.promises.writeFile(filename, buffer);
+}
+async function detectContentType(buffer) {
+    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 ([
+        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;
+    }
+    // Fallback to sharp if available
+    if (sharp) {
+        const meta = await sharp(buffer).metadata().catch((_)=>null);
+        switch(meta == null ? void 0 : meta.format){
+            case "avif":
+                return AVIF;
+            case "webp":
+                return WEBP;
+            case "png":
+                return PNG;
+            case "jpeg":
+            case "jpg":
+                return JPEG;
+            case "gif":
+                return GIF;
+            case "svg":
+                return SVG;
+            case "tiff":
+            case "tif":
+                return TIFF;
+            case "heif":
+                return HEIC;
+            default:
+                return null;
+        }
+    }
+    return null;
+}
+class ImageOptimizerCache {
+    static validateParams(req, query, nextConfig, isDev) {
+        var _nextConfig_images, _nextConfig_images1, _nextConfig_images2;
+        const imageData = nextConfig.images;
+        const { deviceSizes = [], imageSizes = [], domains = [], minimumCacheTTL = 60, formats = [
+            "image/webp"
+        ] } = imageData;
+        const remotePatterns = ((_nextConfig_images = nextConfig.images) == null ? void 0 : _nextConfig_images.remotePatterns) || [];
+        const localPatterns = (_nextConfig_images1 = nextConfig.images) == null ? void 0 : _nextConfig_images1.localPatterns;
+        const qualities = (_nextConfig_images2 = nextConfig.images) == null ? void 0 : _nextConfig_images2.qualities;
+        const { url, w, q } = query;
+        let href;
+        if (domains.length > 0) {
+            _log.warnOnce('The "images.domains" configuration is deprecated. Please use "images.remotePatterns" configuration instead.');
+        }
+        if (!url) {
+            return {
+                errorMessage: '"url" parameter is required'
+            };
+        } else if (Array.isArray(url)) {
+            return {
+                errorMessage: '"url" parameter cannot be an array'
+            };
+        }
+        if (url.length > 3072) {
+            return {
+                errorMessage: '"url" parameter is too long'
+            };
+        }
+        if (url.startsWith("//")) {
+            return {
+                errorMessage: '"url" parameter cannot be a protocol-relative URL (//)'
+            };
+        }
+        let isAbsolute;
+        if (url.startsWith("/")) {
+            var _parseUrl;
+            href = url;
+            isAbsolute = false;
+            if (/\/_next\/image($|\/)/.test(decodeURIComponent(((_parseUrl = (0, _url1.parseUrl)(url)) == null ? void 0 : _parseUrl.pathname) ?? ""))) {
+                return {
+                    errorMessage: '"url" parameter cannot be recursive'
+                };
+            }
+            if (!(0, _matchlocalpattern.hasLocalMatch)(localPatterns, url)) {
+                return {
+                    errorMessage: '"url" parameter is not allowed'
+                };
+            }
+        } else {
+            let hrefParsed;
+            try {
+                hrefParsed = new URL(url);
+                href = hrefParsed.toString();
+                isAbsolute = true;
+            } catch (_error) {
+                return {
+                    errorMessage: '"url" parameter is invalid'
+                };
+            }
+            if (![
+                "http:",
+                "https:"
+            ].includes(hrefParsed.protocol)) {
+                return {
+                    errorMessage: '"url" parameter is invalid'
+                };
+            }
+            if (!(0, _matchremotepattern.hasRemoteMatch)(domains, remotePatterns, hrefParsed)) {
+                return {
+                    errorMessage: '"url" parameter is not allowed'
+                };
+            }
+        }
+        if (!w) {
+            return {
+                errorMessage: '"w" parameter (width) is required'
+            };
+        } else if (Array.isArray(w)) {
+            return {
+                errorMessage: '"w" parameter (width) cannot be an array'
+            };
+        }
+        if (!q) {
+            return {
+                errorMessage: '"q" parameter (quality) is required'
+            };
+        } else if (Array.isArray(q)) {
+            return {
+                errorMessage: '"q" parameter (quality) cannot be an array'
+            };
+        }
+        const width = parseInt(w, 10);
+        if (width <= 0 || isNaN(width)) {
+            return {
+                errorMessage: '"w" parameter (width) must be a number greater than 0'
+            };
+        }
+        const sizes = [
+            ...deviceSizes || [],
+            ...imageSizes || []
+        ];
+        if (isDev) {
+            sizes.push(BLUR_IMG_SIZE);
+        }
+        const isValidSize = sizes.includes(width) || isDev && width <= BLUR_IMG_SIZE;
+        if (!isValidSize) {
+            return {
+                errorMessage: `"w" parameter (width) of ${width} is not allowed`
+            };
+        }
+        const quality = parseInt(q);
+        if (isNaN(quality) || quality < 1 || quality > 100) {
+            return {
+                errorMessage: '"q" parameter (quality) must be a number 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`
+                };
+            }
+        }
+        const mimeType = getSupportedMimeType(formats || [], req.headers["accept"]);
+        const isStatic = url.startsWith(`${nextConfig.basePath || ""}/_next/static/media`);
+        return {
+            href,
+            sizes,
+            isAbsolute,
+            isStatic,
+            width,
+            quality,
+            mimeType,
+            minimumCacheTTL
+        };
+    }
+    static getCacheKey({ href, width, quality, mimeType }) {
+        return getHash([
+            CACHE_VERSION,
+            href,
+            width,
+            quality,
+            mimeType
+        ]);
+    }
+    constructor({ distDir, nextConfig }){
+        this.cacheDir = (0, _path.join)(distDir, "cache", "images");
+        this.nextConfig = nextConfig;
+    }
+    async get(cacheKey) {
+        try {
+            const cacheDir = (0, _path.join)(this.cacheDir, cacheKey);
+            const files = await _fs.promises.readdir(cacheDir);
+            const now = Date.now();
+            for (const file of files){
+                const [maxAgeSt, expireAtSt, etag, extension] = file.split(".", 4);
+                const buffer = await _fs.promises.readFile((0, _path.join)(cacheDir, file));
+                const expireAt = Number(expireAtSt);
+                const maxAge = Number(maxAgeSt);
+                return {
+                    value: {
+                        kind: "IMAGE",
+                        etag,
+                        buffer,
+                        extension
+                    },
+                    revalidateAfter: Math.max(maxAge, this.nextConfig.images.minimumCacheTTL) * 1000 + Date.now(),
+                    curRevalidate: maxAge,
+                    isStale: now > expireAt
+                };
+            }
+        } catch (_) {
+        // failed to read from cache dir, treat as cache miss
+        }
+        return null;
+    }
+    async set(cacheKey, value, { revalidate }) {
+        if ((value == null ? void 0 : value.kind) !== "IMAGE") {
+            throw new Error("invariant attempted to set non-image to image-cache");
+        }
+        if (typeof revalidate !== "number") {
+            throw new Error("invariant revalidate must be a number for image-cache");
+        }
+        const expireAt = Math.max(revalidate, this.nextConfig.images.minimumCacheTTL) * 1000 + Date.now();
+        try {
+            await writeToCacheDir((0, _path.join)(this.cacheDir, cacheKey), value.extension, revalidate, expireAt, value.buffer, value.etag);
+        } catch (err) {
+            _log.error(`Failed to write image to cache ${cacheKey}`, err);
+        }
+    }
+}
+class ImageError extends Error {
+    constructor(statusCode, message){
+        super(message);
+        // 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;
+}
+async function optimizeImage({ buffer, contentType, quality, width, height, nextConfigOutput }) {
+    let optimizedBuffer = buffer;
+    if (sharp) {
+        // Begin sharp transformation logic
+        const transformer = sharp(buffer, {
+            sequentialRead: true
+        });
+        transformer.rotate();
+        if (height) {
+            transformer.resize(width, height);
+        } else {
+            transformer.resize(width, undefined, {
+                withoutEnlargement: true
+            });
+        }
+        if (contentType === AVIF) {
+            if (transformer.avif) {
+                const avifQuality = quality - 15;
+                transformer.avif({
+                    quality: Math.max(avifQuality, 0),
+                    chromaSubsampling: "4:2:0"
+                });
+            } else {
+                _log.warnOnce(`Your installed version of the 'sharp' package does not support AVIF images. Run 'npm i sharp@latest' to upgrade to the latest version.\n` + "Read more: https://nextjs.org/docs/messages/sharp-version-avif");
+                transformer.webp({
+                    quality
+                });
+            }
+        } else if (contentType === WEBP) {
+            transformer.webp({
+                quality
+            });
+        } else if (contentType === PNG) {
+            transformer.png({
+                quality
+            });
+        } else if (contentType === JPEG) {
+            transformer.jpeg({
+                quality,
+                progressive: true
+            });
+        }
+        optimizedBuffer = await transformer.toBuffer();
+    // End sharp transformation logic
+    } else {
+        if (showSharpMissingWarning && nextConfigOutput === "standalone") {
+            _log.error(`Error: 'sharp' is required to be installed in standalone mode for the image optimization to function correctly. Read more at: https://nextjs.org/docs/messages/sharp-missing-in-production`);
+            throw new ImageError(500, "Internal Server Error");
+        }
+        // Show sharp warning in production once
+        if (showSharpMissingWarning) {
+            _log.warnOnce(`For production Image Optimization with Next.js, the optional 'sharp' package is strongly recommended. Run 'npm i sharp', and Next.js will use it automatically for Image Optimization.\n` + "Read more: https://nextjs.org/docs/messages/sharp-missing-in-production");
+            showSharpMissingWarning = false;
+        }
+        // Begin Squoosh transformation logic
+        const orientation = await (0, _getorientation.getOrientation)(buffer);
+        const operations = [];
+        if (orientation === _getorientation.Orientation.RIGHT_TOP) {
+            operations.push({
+                type: "rotate",
+                numRotations: 1
+            });
+        } else if (orientation === _getorientation.Orientation.BOTTOM_RIGHT) {
+            operations.push({
+                type: "rotate",
+                numRotations: 2
+            });
+        } else if (orientation === _getorientation.Orientation.LEFT_BOTTOM) {
+            operations.push({
+                type: "rotate",
+                numRotations: 3
+            });
+        } else {
+        // TODO: support more orientations
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        // const _: never = orientation
+        }
+        if (height) {
+            operations.push({
+                type: "resize",
+                width,
+                height
+            });
+        } else {
+            operations.push({
+                type: "resize",
+                width
+            });
+        }
+        const { processBuffer } = require("./lib/squoosh/main");
+        if (contentType === AVIF) {
+            optimizedBuffer = await processBuffer(buffer, operations, "avif", quality);
+        } else if (contentType === WEBP) {
+            optimizedBuffer = await processBuffer(buffer, operations, "webp", quality);
+        } else if (contentType === PNG) {
+            optimizedBuffer = await processBuffer(buffer, operations, "png", quality);
+        } else if (contentType === JPEG) {
+            optimizedBuffer = await processBuffer(buffer, operations, "jpeg", quality);
+        }
+    }
+    return optimizedBuffer;
+}
+async function fetchExternalImage(href) {
+    const res = await fetch(href);
+    if (!res.ok) {
+        _log.error("upstream image response failed for", href, res.status);
+        throw new ImageError(res.status, '"url" parameter is valid but upstream response is invalid');
+    }
+    const buffer = Buffer.from(await res.arrayBuffer());
+    const contentType = res.headers.get("Content-Type");
+    const cacheControl = res.headers.get("Cache-Control");
+    return {
+        buffer,
+        contentType,
+        cacheControl
+    };
+}
+async function fetchInternalImage(href, _req, _res, handleRequest) {
+    try {
+        const mocked = (0, _mockrequest.createRequestResponseMocks)({
+            url: href,
+            method: _req.method || "GET",
+            socket: _req.socket
+        });
+        await handleRequest(mocked.req, mocked.res, _url.default.parse(href, true));
+        await mocked.res.hasStreamed;
+        if (!mocked.res.statusCode) {
+            _log.error("image response failed for", href, mocked.res.statusCode);
+            throw new ImageError(mocked.res.statusCode, '"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");
+        return {
+            buffer,
+            contentType,
+            cacheControl
+        };
+    } catch (err) {
+        _log.error("upstream image response failed for", href, err);
+        throw new ImageError(500, '"url" parameter is valid but upstream response is invalid');
+    }
+}
+async function imageOptimizer(imageUpstream, paramsResult, nextConfig, isDev) {
+    const { href, quality, width, mimeType } = paramsResult;
+    const upstreamBuffer = imageUpstream.buffer;
+    const maxAge = getMaxAge(imageUpstream.cacheControl);
+    const upstreamType = await detectContentType(upstreamBuffer);
+    if (!upstreamType || !upstreamType.startsWith("image/") || upstreamType.includes(",")) {
+        _log.error("The requested resource isn't a valid image for", href, "received", upstreamType);
+        throw new ImageError(400, "The requested resource isn't a valid image.");
+    }
+    if (upstreamType.startsWith("image/svg") && !nextConfig.images.dangerouslyAllowSVG) {
+        _log.error(`The requested resource "${href}" has type "${upstreamType}" but dangerouslyAllowSVG is disabled`);
+        throw new ImageError(400, '"url" parameter is valid but image type is not allowed');
+    }
+    if (ANIMATABLE_TYPES.includes(upstreamType) && (0, _isanimated.default)(upstreamBuffer)) {
+        _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
+        };
+    }
+    if (BYPASS_TYPES.includes(upstreamType)) {
+        return {
+            buffer: upstreamBuffer,
+            contentType: upstreamType,
+            maxAge
+        };
+    }
+    let contentType;
+    if (mimeType) {
+        contentType = mimeType;
+    } else if ((0, _servestatic.getExtension)(upstreamType) && upstreamType !== WEBP && upstreamType !== AVIF) {
+        contentType = upstreamType;
+    } else {
+        contentType = JPEG;
+    }
+    try {
+        let optimizedBuffer = await optimizeImage({
+            buffer: upstreamBuffer,
+            contentType,
+            quality,
+            width,
+            nextConfigOutput: nextConfig.output
+        });
+        if (optimizedBuffer) {
+            if (isDev && width <= BLUR_IMG_SIZE && quality === BLUR_QUALITY) {
+                const { getMetadata } = require("./lib/squoosh/main");
+                // 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 getMetadata(optimizedBuffer);
+                const opts = {
+                    blurWidth: meta.width,
+                    blurHeight: meta.height,
+                    blurDataURL: `data:${contentType};base64,${optimizedBuffer.toString("base64")}`
+                };
+                optimizedBuffer = Buffer.from(unescape((0, _imageblursvg.getImageBlurSvg)(opts)));
+                contentType = "image/svg+xml";
+            }
+            return {
+                buffer: optimizedBuffer,
+                contentType,
+                maxAge: Math.max(maxAge, nextConfig.images.minimumCacheTTL)
+            };
+        } else {
+            throw new ImageError(500, "Unable to optimize buffer");
+        }
+    } catch (error) {
+        if (upstreamBuffer && upstreamType) {
+            // If we fail to optimize, fallback to the original image
+            return {
+                buffer: upstreamBuffer,
+                contentType: upstreamType,
+                maxAge: nextConfig.images.minimumCacheTTL
+            };
+        } else {
+            throw new ImageError(400, "Unable to optimize image and unable to fallback to upstream image");
+        }
+    }
+}
+function getFileNameWithExtension(url, contentType) {
+    const [urlWithoutQueryParams] = url.split("?", 1);
+    const fileNameWithExtension = urlWithoutQueryParams.split("/").pop();
+    if (!contentType || !fileNameWithExtension) {
+        return "image.bin";
+    }
+    const [fileName] = fileNameWithExtension.split(".", 1);
+    const extension = (0, _servestatic.getExtension)(contentType);
+    return `${fileName}.${extension}`;
+}
+function setResponseHeaders(req, res, url, etag, contentType, isStatic, xCache, imagesConfig, maxAge, isDev) {
+    res.setHeader("Vary", "Accept");
+    res.setHeader("Cache-Control", isStatic ? "public, max-age=315360000, immutable" : `public, max-age=${isDev ? 0 : maxAge}, must-revalidate`);
+    if ((0, _sendpayload.sendEtagResponse)(req, res, etag)) {
+        // already called res.end() so we're finished
+        return {
+            finished: true
+        };
+    }
+    if (contentType) {
+        res.setHeader("Content-Type", contentType);
+    }
+    const fileName = getFileNameWithExtension(url, contentType);
+    res.setHeader("Content-Disposition", (0, _contentdisposition.default)(fileName, {
+        type: imagesConfig.contentDispositionType
+    }));
+    res.setHeader("Content-Security-Policy", imagesConfig.contentSecurityPolicy);
+    res.setHeader("X-Nextjs-Cache", xCache);
+    return {
+        finished: false
+    };
+}
+function sendResponse(req, res, url, extension, buffer, isStatic, xCache, imagesConfig, maxAge, isDev) {
+    const contentType = (0, _servestatic.getContentType)(extension);
+    const etag = getHash([
+        buffer
+    ]);
+    const result = setResponseHeaders(req, res, url, etag, contentType, isStatic, xCache, imagesConfig, maxAge, isDev);
+    if (!result.finished) {
+        res.setHeader("Content-Length", Buffer.byteLength(buffer));
+        res.end(buffer);
+    }
+}
+async function getImageSize(buffer, // Should match VALID_BLUR_EXT
+extension) {
+    // TODO: upgrade "image-size" package to support AVIF
+    // See https://github.com/image-size/image-size/issues/348
+    if (extension === "avif") {
+        if (sharp) {
+            const transformer = sharp(buffer);
+            const { width, height } = await transformer.metadata();
+            return {
+                width,
+                height
+            };
+        } else {
+            const { decodeBuffer } = require("./lib/squoosh/main");
+            const { width, height } = await decodeBuffer(buffer);
+            return {
+                width,
+                height
+            };
+        }
+    }
+    const { width, height } = (0, _imagesize.default)(buffer);
+    return {
+        width,
+        height
+    };
+}
+
+//# sourceMappingURL=image-optimizer.js.map