@sifxprime/krouter 0.5.160 → 0.5.162

package/app/node_modules/next/dist/lib/patch-incorrect-lockfile.js

@@ -72,7 +72,7 @@ async function fetchPkgInfo(pkg) {
         });
     }
     const data = await res.json();
-    const versionData = data.versions["16.3.4"];
+    const versionData = data.versions["16.3.8"];
     return {
         os: versionData.os,
         cpu: versionData.cpu,
@@ -100,7 +100,7 @@ async function patchIncorrectLockfile(dir) {
     const expectedSwcPkgs = Object.keys(_packagejson.optionalDependencies || {}).filter((pkg)=>pkg.startsWith('@next/swc-'));
     const patchDependency = (pkg, pkgData)=>{
         lockfileParsed.dependencies[pkg] = {
-            version: "16.3.4",
+            version: "16.3.8",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             optional: true
@@ -108,7 +108,7 @@ async function patchIncorrectLockfile(dir) {
     };
     const patchPackage = (pkg, pkgData)=>{
         lockfileParsed.packages[pkg] = {
-            version: "16.3.4",
+            version: "16.3.8",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             cpu: pkgData.cpu,

package/app/node_modules/next/dist/server/app-render/create-component-styles-and-scripts.js

@@ -23,7 +23,8 @@ async function createComponentStylesAndScripts({ filePath, getComponent, injecte
         scripts.push(createElement('script', {
             src: `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(href)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`,
             async: true,
-            key: `script-${scriptIndex}`
+            key: `script-${scriptIndex}`,
+            nonce: ctx.nonce
         }));
         scriptIndex++;
     }

package/app/node_modules/next/dist/server/base-server.js

@@ -1569,8 +1569,7 @@ class Server {
         const isAppPath = Array.isArray(appPaths);
         let page = pathname;
         if (isAppPath) {
-            // the last item in the array is the root page, if there are parallel routes
-            page = appPaths[appPaths.length - 1];
+            page = (0, _apppaths.selectAppPageEntry)(pathname, appPaths);
         }
         const result = await this.findPageComponents({
             locale: (0, _requestmeta.getRequestMeta)(ctx.req, 'locale'),

package/app/node_modules/next/dist/server/config.js

@@ -1305,7 +1305,7 @@ async function applyModifyConfig(config, phase, silent, dir) {
             }
             config = await adapterMod.modifyConfig(config, {
                 phase,
-                nextVersion: "16.3.4",
+                nextVersion: "16.3.8",
                 projectDir: dir
             });
         }

package/app/node_modules/next/dist/server/dev/hot-reloader-turbopack.js

@@ -302,7 +302,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     }
     const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
     const hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-        version: "16.3.4"
+        version: "16.3.8"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.
@@ -362,7 +362,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         writeRoutesHashesManifest: false,
         currentNodeJsVersion,
         isPersistentCachingEnabled: (0, _utils2.isFileSystemCacheEnabledForDev)(opts.nextConfig),
-        nextVersion: "16.3.4",
+        nextVersion: "16.3.8",
         serverHmr: serverFastRefresh
     }, {
         turbopackMemoryEviction: opts.nextConfig.experimental.turbopackMemoryEvictionMode,

package/app/node_modules/next/dist/server/dev/hot-reloader-webpack.js

@@ -234,7 +234,7 @@ class HotReloaderWebpack {
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-            version: "16.3.4"
+            version: "16.3.8"
         });
         // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
         // of the current `next dev` invocation.

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     ImageError: null,
     ImageOptimizerCache: null,
+    createPinnedLookup: null,
     detectContentType: null,
     extractEtag: null,
     fetchExternalImage: null,
@@ -32,6 +33,9 @@ _export(exports, {
     ImageOptimizerCache: function() {
         return ImageOptimizerCache;
     },
+    createPinnedLookup: function() {
+        return createPinnedLookup;
+    },
     detectContentType: function() {
         return detectContentType;
     },
@@ -74,6 +78,8 @@ _export(exports, {
 });
 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"));
@@ -96,6 +102,8 @@ const _invarianterror = require("../shared/lib/invariant-error");
 const _promises = require("dns/promises");
 const _net = require("net");
 const _dns = require("dns");
+const _stream = require("stream");
+const _zlib = require("zlib");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -266,6 +274,13 @@ function getImageEtag(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
+        });
+    }
     const dir = (0, _path.join)(/* turbopackIgnore: true */ cacheDir, cacheKey);
     const filename = (0, _path.join)(/* turbopackIgnore: true */ dir, `${maxAge}.${expireAt}.${etag}.${upstreamEtag}.${extension}`);
     await _fs.promises.rm(dir, {
@@ -291,6 +306,13 @@ async function readFromCacheDir(cacheDir, cacheKey) {
     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
+        });
+    }
     const expireAt = Number(expireAtSt);
     const maxAge = Number(maxAgeSt);
     return {
@@ -782,6 +804,7 @@ class ImageOptimizerCache {
                     revalidate: effectiveRevalidate
                 };
                 await this.cacheHandler.set(cacheKey, valueWithRevalidate, {
+                    kind: _responsecache.IncrementalCacheKind.IMAGE,
                     cacheControl: {
                         revalidate: effectiveRevalidate,
                         expire: cacheControl == null ? void 0 : cacheControl.expire
@@ -918,25 +941,210 @@ function isRedirect(statusCode) {
         308
     ].includes(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
+    });
+}
+const agentOptions = {
+    keepAlive: true,
+    timeout: 7000
+};
+const getHttpAgentName = _http.Agent.prototype.getName;
+const getHttpsAgentName = _https.Agent.prototype.getName;
+class ImageHttpAgent extends _http.Agent {
+    getName(options = {}) {
+        return `${getHttpAgentName.call(this, options)}:${options.imageLookupKey ?? ''}`;
+    }
+}
+class ImageHttpsAgent extends _https.Agent {
+    getName(options = {}) {
+        return `${getHttpsAgentName.call(this, options)}:${options.imageLookupKey ?? ''}`;
+    }
+}
+let protectedHttpAgent;
+let protectedHttpsAgent;
+let permissiveHttpAgent;
+let permissiveHttpsAgent;
+function getImageAgent(dangerouslyAllowLocalIP, isHttps) {
+    if (isHttps) {
+        if (dangerouslyAllowLocalIP) {
+            return permissiveHttpsAgent ??= new ImageHttpsAgent(agentOptions);
+        }
+        return protectedHttpsAgent ??= new ImageHttpsAgent(agentOptions);
+    }
+    if (dangerouslyAllowLocalIP) {
+        return permissiveHttpAgent ??= new ImageHttpAgent(agentOptions);
+    }
+    return protectedHttpAgent ??= new ImageHttpAgent(agentOptions);
+}
+const BASE_REQ_HEADERS = {
+    accept: '*/*',
+    'accept-language': '*',
+    'sec-fetch-mode': 'cors',
+    'user-agent': 'node'
+};
+const HTTP_FETCH_HEADERS = {
+    ...BASE_REQ_HEADERS,
+    'accept-encoding': 'gzip, deflate'
+};
+const HTTPS_FETCH_HEADERS = {
+    ...BASE_REQ_HEADERS,
+    'accept-encoding': 'br, gzip, deflate'
+};
+/**
+ * Resolves `hostname` with the DNS options the socket itself would have used,
+ * so the addresses checked below are the exact set the connection can reach.
+ * Mirrors `lookupAndConnect()` in Node's `lib/net.js`.
+ */ function lookupAsSocketWould(hostname) {
+    return (0, _promises.lookup)(hostname, {
+        all: true,
+        // Node applies ADDRCONFIG whenever no address family is requested,
+        // on every platform except Windows.
+        hints: process.platform === 'win32' ? 0 : _dns.ADDRCONFIG
+    });
+}
+function createPinnedLookup(hostname, addresses) {
+    return (lookupHostname, options, callback)=>{
+        if (lookupHostname !== hostname) {
+            callback(new _invarianterror.InvariantError(`Image lookup hostname "${lookupHostname}" does not match request hostname "${hostname}"`), []);
+            return;
+        }
+        const family = typeof options.family === 'number' ? options.family : 0;
+        const matched = family ? addresses.filter((address)=>address.family === family) : addresses;
+        if (matched.length === 0) {
+            // Reporting this as an error rather than an empty list is not optional:
+            // Node destructures the first address, so the resulting TypeError is
+            // thrown inside the socket and escapes the request entirely.
+            const err = new Error(`No IPv${family} address available for ${hostname}`);
+            err.code = 'ENODATA';
+            callback(err, []);
+            return;
+        }
+        if (options.all) {
+            callback(null, matched);
+        } else {
+            callback(null, matched[0].address, matched[0].family);
+        }
+    };
+}
+function requestUpstreamImage(url, pinnedLookup, imageLookupKey, dangerouslyAllowLocalIP, signal) {
+    return new Promise((resolve, reject)=>{
+        const isHttps = url.protocol === 'https:';
+        const request = isHttps ? _https.request : _http.request;
+        const options = {
+            agent: getImageAgent(dangerouslyAllowLocalIP, isHttps),
+            headers: isHttps ? HTTPS_FETCH_HEADERS : HTTP_FETCH_HEADERS,
+            imageLookupKey,
+            lookup: pinnedLookup,
+            signal
+        };
+        const req = request(url, options, resolve);
+        req.on('error', reject);
+        req.end();
+    });
+}
+class DeflateDecoder extends _stream.Transform {
+    constructor(){
+        super();
+        this.decoder = undefined;
+    }
+    _transform(chunk, encoding, callback) {
+        if (!this.decoder) {
+            if (chunk.length === 0) {
+                callback();
+                return;
+            }
+            const options = {
+                flush: _zlib.constants.Z_SYNC_FLUSH,
+                finishFlush: _zlib.constants.Z_SYNC_FLUSH
+            };
+            this.decoder = (chunk[0] & 0x0f) === 0x08 ? (0, _zlib.createInflate)(options) : (0, _zlib.createInflateRaw)(options);
+            this.decoder.on('data', (data)=>this.push(data));
+            this.decoder.on('end', ()=>this.push(null));
+            this.decoder.on('error', (err)=>this.destroy(err));
+        }
+        this.decoder.write(chunk, encoding, callback);
+    }
+    _final(callback) {
+        var _this_decoder;
+        (_this_decoder = this.decoder) == null ? void 0 : _this_decoder.end();
+        this.decoder = undefined;
+        callback();
+    }
+}
+// Matches the chain limit of native fetch (undici), so an upstream cannot
+// force unbounded decoder allocations with the header alone.
+const MAX_CONTENT_ENCODINGS = 5;
+function decodeResponseBody(res, href) {
+    const contentEncoding = res.headers['content-encoding'];
+    if (!contentEncoding) {
+        return res;
+    }
+    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
+        });
+    }
+    const decoders = [];
+    for(let i = codings.length - 1; i >= 0; i--){
+        switch(codings[i].trim()){
+            case 'x-gzip':
+            case 'gzip':
+                decoders.push((0, _zlib.createGunzip)({
+                    flush: _zlib.constants.Z_SYNC_FLUSH,
+                    finishFlush: _zlib.constants.Z_SYNC_FLUSH
+                }));
+                break;
+            case 'deflate':
+                decoders.push(new DeflateDecoder());
+                break;
+            case 'br':
+                decoders.push((0, _zlib.createBrotliDecompress)({
+                    flush: _zlib.constants.BROTLI_OPERATION_FLUSH,
+                    finishFlush: _zlib.constants.BROTLI_OPERATION_FLUSH
+                }));
+                break;
+            default:
+                return res;
+        }
+    }
+    (0, _stream.pipeline)([
+        res,
+        ...decoders
+    ], ()=>{});
+    return decoders[decoders.length - 1];
+}
 async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponseBody, count = 3) {
+    const url = new URL(href);
+    // `URL.hostname` keeps the brackets around an IPv6 literal, the socket does not
+    const hostname = url.hostname.replace(/^\[|\]$/g, '');
+    let pinnedLookup;
+    let imageLookupKey;
     if (!dangerouslyAllowLocalIP) {
-        const { hostname } = new URL(href);
-        let ips = [
-            hostname
-        ];
-        if (!(0, _net.isIP)(hostname)) {
-            const records = await (0, _promises.lookup)(hostname, {
-                family: 0,
-                all: true,
-                hints: _dns.ALL
-            }).catch((_)=>[
-                    {
-                        address: hostname
-                    }
-                ]);
-            ips = records.map((record)=>record.address);
+        const literalFamily = (0, _net.isIP)(hostname);
+        let addresses;
+        if (literalFamily > 0) {
+            // A literal address is connected to as-is, without any DNS resolution
+            addresses = [
+                {
+                    address: hostname,
+                    family: literalFamily
+                }
+            ];
+        } else {
+            addresses = await lookupAsSocketWould(hostname);
+            pinnedLookup = createPinnedLookup(hostname, addresses);
         }
-        const privateIps = ips.filter((ip)=>(0, _isprivateip.isPrivateIp)(ip));
+        imageLookupKey = addresses.map((address)=>`${address.family}:${address.address}`).join(',');
+        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", {
@@ -946,24 +1154,31 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
             });
         }
     }
-    const res = await fetch(href, {
-        signal: AbortSignal.timeout(7000),
-        redirect: 'manual'
-    }).catch((err)=>err);
-    if (res instanceof Error) {
-        const err = res;
-        if (err.name === 'TimeoutError') {
-            _log.error('upstream image response timed out for', href);
-            throw Object.defineProperty(new ImageError(504, '"url" parameter is valid but upstream response timed out'), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+    // The signal is owned here rather than by `requestUpstreamImage()` because it
+    // has to stay readable while the body streams. Node reports an abort during
+    // the body as a plain `ECONNRESET` on the response, so the signal is the only
+    // way to tell a timeout apart from the upstream resetting the connection.
+    const signal = AbortSignal.timeout(agentOptions.timeout);
+    let res;
+    try {
+        res = await requestUpstreamImage(url, pinnedLookup, imageLookupKey, dangerouslyAllowLocalIP, signal);
+    } catch (err) {
+        if (signal.aborted) {
+            throw upstreamTimedOut(href);
         }
         throw err;
     }
-    const locationHeader = res.headers.get('Location');
-    if (isRedirect(res.status) && locationHeader && URL.canParse(locationHeader, href)) {
+    const statusCode = res.statusCode;
+    if (statusCode === undefined) {
+        res.destroy();
+        throw new _invarianterror.InvariantError('Expected statusCode on upstream image response');
+    }
+    const locationHeader = res.headers.location;
+    if (isRedirect(statusCode) && locationHeader && URL.canParse(locationHeader, href)) {
+        // Discard the body rather than draining it. A redirect body is never used,
+        // and draining one would download unlimited bytes from the upstream because
+        // `maximumResponseBody` is only enforced on the final response.
+        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", {
@@ -975,15 +1190,41 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
         const redirect = new URL(locationHeader, href).href;
         return fetchExternalImage(redirect, dangerouslyAllowLocalIP, maximumResponseBody, count - 1);
     }
-    if (!res.ok) {
-        _log.error('upstream image response failed for', href, res.status);
-        throw Object.defineProperty(new ImageError(res.status, '"url" parameter is valid but upstream response is invalid'), "__NEXT_ERROR_CODE", {
+    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
         });
     }
-    if (!res.body) {
+    const chunks = [];
+    let totalSize = 0;
+    try {
+        const body = decodeResponseBody(res, href);
+        // Throwing out of this loop destroys the response, so an oversized or
+        // timed out download stops instead of running to completion.
+        for await (const chunk of body){
+            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
+                });
+            }
+            chunks.push(chunk);
+        }
+    } catch (err) {
+        res.destroy();
+        if (signal.aborted) {
+            throw upstreamTimedOut(href);
+        }
+        throw err;
+    }
+    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",
@@ -991,25 +1232,10 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
             configurable: true
         });
     }
-    const chunks = [];
-    let totalSize = 0;
-    for await (const c of res.body){
-        const chunk = Buffer.from(c);
-        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
-            });
-        }
-        chunks.push(chunk);
-    }
     const buffer = Buffer.concat(chunks);
-    const contentType = res.headers.get('Content-Type');
-    const cacheControl = res.headers.get('Cache-Control');
-    const etag = extractEtag(res.headers.get('ETag'), buffer);
+    const contentType = res.headers['content-type'];
+    const cacheControl = res.headers['cache-control'];
+    const etag = extractEtag(res.headers.etag, buffer);
     return {
         buffer,
         contentType,

package/app/node_modules/next/dist/server/lib/app-info-log.js

@@ -79,7 +79,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 function logStartInfo({ networkUrl, appUrl, envInfo, logBundler }) {
     const versionSuffix = logBundler ? ` (${(0, _bundler.bundlerName)((0, _bundler.getBundlerFromEnv)())})` : '';
-    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.3.4"}`))}${versionSuffix}`);
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.3.8"}`))}${versionSuffix}`);
     if (appUrl) {
         _log.bootstrap(`- Local:         ${appUrl}`);
     }

package/app/node_modules/next/dist/server/lib/disk-lru-cache.external.js

@@ -43,7 +43,13 @@ async function getOrInitDiskLRU(cacheDir, maxDiskSize, readEntries, evictEntry)
             const lru = new _lrucache.LRUCache(maxSize, (size)=>size, (cacheKey)=>evictEntry(cacheDir, cacheKey));
             const entries = await readEntries(cacheDir);
             for (const entry of entries){
-                lru.set(entry.key, entry.size);
+                // Skip entries with a non-positive size: `LRUCache.set()` rejects
+                // sizes <= 0, so a single such entry (e.g. a 0-byte or corrupt cache
+                // file) would otherwise throw here and permanently reject this cached
+                // singleton promise, breaking the disk cache for the whole process.
+                if (entry.size > 0) {
+                    lru.set(entry.key, entry.size);
+                }
             }
             return lru;
         })();