@sifxprime/krouter 0.5.166 → 0.5.167

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

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "detectContentType", {
+    enumerable: true,
+    get: function() {
+        return detectContentType;
+    }
+});
+const _detector = require("next/dist/compiled/image-detector/detector.js");
+const _imagetype = require("./image-type");
+async function detectContentType(buffer) {
+    if (buffer.byteLength === 0) {
+        return null;
+    }
+    if ([
+        0xff,
+        0xd8,
+        0xff
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.JPEG;
+    }
+    if ([
+        0x89,
+        0x50,
+        0x4e,
+        0x47,
+        0x0d,
+        0x0a,
+        0x1a,
+        0x0a
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.PNG;
+    }
+    if ([
+        0x47,
+        0x49,
+        0x46,
+        0x38
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.GIF;
+    }
+    if ([
+        0x52,
+        0x49,
+        0x46,
+        0x46,
+        0,
+        0,
+        0,
+        0,
+        0x57,
+        0x45,
+        0x42,
+        0x50
+    ].every((b, i)=>!b || buffer[i] === b)) {
+        return _imagetype.WEBP;
+    }
+    if ([
+        0x3c,
+        0x3f,
+        0x78,
+        0x6d,
+        0x6c
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.SVG;
+    }
+    if ([
+        0x3c,
+        0x73,
+        0x76,
+        0x67
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.SVG;
+    }
+    if ([
+        0,
+        0,
+        0,
+        0,
+        0x66,
+        0x74,
+        0x79,
+        0x70,
+        0x61,
+        0x76,
+        0x69,
+        0x66
+    ].every((b, i)=>!b || buffer[i] === b)) {
+        return _imagetype.AVIF;
+    }
+    if ([
+        0x00,
+        0x00,
+        0x01,
+        0x00
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.ICO;
+    }
+    if ([
+        0x69,
+        0x63,
+        0x6e,
+        0x73
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.ICNS;
+    }
+    if ([
+        0x49,
+        0x49,
+        0x2a,
+        0x00
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.TIFF;
+    }
+    if ([
+        0x42,
+        0x4d
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.BMP;
+    }
+    if ([
+        0xff,
+        0x0a
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.JXL;
+    }
+    if ([
+        0x00,
+        0x00,
+        0x00,
+        0x0c,
+        0x4a,
+        0x58,
+        0x4c,
+        0x20,
+        0x0d,
+        0x0a,
+        0x87,
+        0x0a
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.JXL;
+    }
+    if ([
+        0,
+        0,
+        0,
+        0,
+        0x66,
+        0x74,
+        0x79,
+        0x70,
+        0x68,
+        0x65,
+        0x69,
+        0x63
+    ].every((b, i)=>!b || buffer[i] === b)) {
+        return _imagetype.HEIC;
+    }
+    if ([
+        0x25,
+        0x50,
+        0x44,
+        0x46,
+        0x2d
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.PDF;
+    }
+    if ([
+        0x00,
+        0x00,
+        0x00,
+        0x0c,
+        0x6a,
+        0x50,
+        0x20,
+        0x20,
+        0x0d,
+        0x0a,
+        0x87,
+        0x0a
+    ].every((b, i)=>buffer[i] === b)) {
+        return _imagetype.JP2;
+    }
+    const format = (0, _detector.detector)(buffer.subarray(0, 1024));
+    switch(format){
+        case 'webp':
+            return _imagetype.WEBP;
+        case 'png':
+            return _imagetype.PNG;
+        case 'jpg':
+            return _imagetype.JPEG;
+        case 'gif':
+            return _imagetype.GIF;
+        case 'svg':
+            return _imagetype.SVG;
+        case 'jxl':
+        case 'jxl-stream':
+            return _imagetype.JXL;
+        case 'jp2':
+            return _imagetype.JP2;
+        case 'tiff':
+            return _imagetype.TIFF;
+        case 'bmp':
+            return _imagetype.BMP;
+        case 'ico':
+            return _imagetype.ICO;
+        case 'icns':
+            return _imagetype.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
+            ;
+    }
+}
+
+//# sourceMappingURL=detect-content-type.js.map

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    extractEtag: null,
+    getHash: null,
+    getImageEtag: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    extractEtag: function() {
+        return extractEtag;
+    },
+    getHash: function() {
+        return getHash;
+    },
+    getImageEtag: function() {
+        return getImageEtag;
+    }
+});
+const _crypto = require("crypto");
+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
+    ]);
+}
+
+//# sourceMappingURL=extract-etag.js.map

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getImageSize", {
+    enumerable: true,
+    get: function() {
+        return getImageSize;
+    }
+});
+const _imagesize = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/image-size"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function getImageSize(buffer) {
+    const { width, height } = (0, _imagesize.default)(buffer);
+    return {
+        width,
+        height
+    };
+}
+
+//# sourceMappingURL=get-image-size.js.map

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getMaxAge", {
+    enumerable: true,
+    get: function() {
+        return getMaxAge;
+    }
+});
+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;
+}
+
+//# sourceMappingURL=get-max-age.js.map

package/app/node_modules/next/dist/server/image-optimizer/get-previously-cached-image-or-null.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPreviouslyCachedImageOrNull", {
+    enumerable: true,
+    get: function() {
+        return getPreviouslyCachedImageOrNull;
+    }
+});
+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;
+}
+
+//# sourceMappingURL=get-previously-cached-image-or-null.js.map

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ImageError", {
+    enumerable: true,
+    get: function() {
+        return ImageError;
+    }
+});
+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;
+        }
+    }
+}
+
+//# sourceMappingURL=image-error.js.map

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AVIF: null,
+    BMP: null,
+    GIF: null,
+    HEIC: null,
+    ICNS: null,
+    ICO: null,
+    JP2: null,
+    JPEG: null,
+    JXL: null,
+    PDF: null,
+    PNG: null,
+    SVG: null,
+    TIFF: null,
+    WEBP: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AVIF: function() {
+        return AVIF;
+    },
+    BMP: function() {
+        return BMP;
+    },
+    GIF: function() {
+        return GIF;
+    },
+    HEIC: function() {
+        return HEIC;
+    },
+    ICNS: function() {
+        return ICNS;
+    },
+    ICO: function() {
+        return ICO;
+    },
+    JP2: function() {
+        return JP2;
+    },
+    JPEG: function() {
+        return JPEG;
+    },
+    JXL: function() {
+        return JXL;
+    },
+    PDF: function() {
+        return PDF;
+    },
+    PNG: function() {
+        return PNG;
+    },
+    SVG: function() {
+        return SVG;
+    },
+    TIFF: function() {
+        return TIFF;
+    },
+    WEBP: function() {
+        return WEBP;
+    }
+});
+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';
+
+//# sourceMappingURL=image-type.js.map

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

@@ -0,0 +1,227 @@
+// WARNING: Please keep this module lightweight with very few imports since
+// we intend to run it in a child process in the future. Please do NOT
+// add new imports without considering their impact on its dependency graph.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getSharp: null,
+    imageOptimizerTransform: null,
+    optimizeImage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getSharp: function() {
+        return getSharp;
+    },
+    imageOptimizerTransform: function() {
+        return imageOptimizerTransform;
+    },
+    optimizeImage: function() {
+        return optimizeImage;
+    }
+});
+const _isanimated = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/is-animated"));
+const _iserror = /*#__PURE__*/ _interop_require_default(require("../../lib/is-error"));
+const _detectcontenttype = require("./detect-content-type");
+const _imagetype = require("./image-type");
+const _extractetag = require("./extract-etag");
+const _getmaxage = require("./get-max-age");
+const _imageerror = require("./image-error");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const ANIMATABLE_TYPES = [
+    _imagetype.WEBP,
+    _imagetype.PNG,
+    _imagetype.GIF
+];
+const BYPASS_TYPES = [
+    _imagetype.SVG,
+    _imagetype.ICO,
+    _imagetype.ICNS,
+    _imagetype.BMP,
+    _imagetype.JXL,
+    _imagetype.HEIC
+];
+let _sharp;
+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 new Error('Module `sharp` not found. Please run `npm install --cpu=wasm32 sharp` to install it.');
+        }
+        throw e;
+    }
+    return _sharp;
+}
+async function optimizeImage({ buffer, contentType, quality, width, height, concurrency, operationCache, limitInputPixels, sequentialRead, timeoutInSeconds, mozjpeg = true }) {
+    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 === _imagetype.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 === _imagetype.WEBP) {
+        transformer.webp({
+            quality
+        });
+    } else if (contentType === _imagetype.PNG) {
+        transformer.png({
+            quality
+        });
+    } else if (contentType === _imagetype.JPEG) {
+        transformer.jpeg({
+            quality,
+            mozjpeg
+        });
+    }
+    const optimizedBuffer = await transformer.toBuffer();
+    return optimizedBuffer;
+}
+async function imageOptimizerTransform(imageUpstream, paramsResult, nextConfig, opts = {}) {
+    const { href, quality, width, mimeType } = paramsResult;
+    const { buffer: upstreamBuffer, etag: upstreamEtag } = imageUpstream;
+    const maxAge = Math.max(nextConfig.images.minimumCacheTTL, (0, _getmaxage.getMaxAge)(imageUpstream.cacheControl));
+    const upstreamType = await (0, _detectcontenttype.detectContentType)(upstreamBuffer);
+    if (!upstreamType || !upstreamType.startsWith('image/') || upstreamType.includes(',')) {
+        var _opts_logger;
+        (_opts_logger = opts.logger) == null ? void 0 : _opts_logger.error("The requested resource isn't a valid image for", href, 'received', upstreamType);
+        throw new _imageerror.ImageError(400, "The requested resource isn't a valid image.");
+    }
+    if (upstreamType.startsWith('image/svg') && !nextConfig.images.dangerouslyAllowSVG) {
+        var _opts_logger1;
+        (_opts_logger1 = opts.logger) == null ? void 0 : _opts_logger1.error(`The requested resource "${href}" has type "${upstreamType}" but dangerouslyAllowSVG is disabled. Consider adding the "unoptimized" property to the <Image>.`);
+        throw new _imageerror.ImageError(400, '"url" parameter is valid but image type is not allowed');
+    }
+    if (ANIMATABLE_TYPES.includes(upstreamType) && (0, _isanimated.default)(upstreamBuffer)) {
+        var _opts_logger2;
+        (_opts_logger2 = opts.logger) == null ? void 0 : _opts_logger2.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 (upstreamType === _imagetype.WEBP || upstreamType === _imagetype.AVIF) {
+        // Downlevel WebP and AVIF when the client does not advertise support.
+        contentType = _imagetype.JPEG;
+    } else {
+        contentType = upstreamType;
+    }
+    if (opts.previousOutput) {
+        return {
+            buffer: opts.previousOutput.buffer,
+            contentType,
+            maxAge: opts.previousOutput.maxAge || maxAge,
+            etag: opts.previousOutput.etag,
+            upstreamEtag: opts.previousOutput.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,
+            mozjpeg: nextConfig.experimental.imgOptMozjpeg
+        });
+        if (opts.handleDevOutput) {
+            const output = await opts.handleDevOutput(optimizedBuffer, contentType);
+            optimizedBuffer = output.buffer;
+            contentType = output.contentType;
+        }
+        return {
+            buffer: optimizedBuffer,
+            contentType,
+            maxAge,
+            etag: (0, _extractetag.getImageEtag)(optimizedBuffer),
+            upstreamEtag
+        };
+    } catch (error) {
+        // If we fail to optimize, fallback to the original image
+        return {
+            buffer: upstreamBuffer,
+            contentType: upstreamType,
+            maxAge: nextConfig.images.minimumCacheTTL,
+            etag: upstreamEtag,
+            upstreamEtag,
+            error
+        };
+    }
+}
+
+//# sourceMappingURL=transform.js.map