@openuiai/next 16.2.0 → 16.2.1

package/dist/bin/next

@@ -89,7 +89,7 @@ const program = new NextRootCommand();
 program.name('next').description('The Next.js CLI allows you to develop, build, start your application, and more.').configureHelp({
     formatHelp: (cmd, helper)=>(0, _formatclihelpoutput.formatCliHelpOutput)(cmd, helper),
     subcommandTerm: (cmd)=>`${cmd.name()} ${cmd.usage()}`
-}).helpCommand(false).helpOption('-h, --help', 'Displays this message.').version(`Next.js v${"16.2.0"}`, '-v, --version', 'Outputs the Next.js version.');
+}).helpCommand(false).helpOption('-h, --help', 'Displays this message.').version(`Next.js v${"16.2.1"}`, '-v, --version', 'Outputs the Next.js version.');
 program.command('build').description('Creates an optimized production build of your application. The output displays information about each route.').argument('[directory]', `A directory on which to build the application. ${(0, _picocolors.italic)('If no directory is provided, the current directory will be used.')}`).option('-d, --debug', 'Enables a more verbose build output.').option('--debug-prerender', 'Enables debug mode for prerendering. Not for production use!').option('--no-mangling', 'Disables mangling.').option('--profile', 'Enables production profiling for React.').option('--experimental-app-only', 'Builds only App Router routes.').option('--webpack', 'Builds using webpack.').addOption(new _commander.Option('--experimental-build-mode [mode]', 'Uses an experimental build mode.').choices([
     'compile',
     'generate',
@@ -133,7 +133,7 @@ program.command('telemetry').description(`Allows you to enable or disable Next.j
 program.command('typegen').description('Generate TypeScript definitions for routes, pages, and layouts without running a full build.').argument('[directory]', `A directory on which to generate types. ${(0, _picocolors.italic)('If no directory is provided, the current directory will be used.')}`).action((directory, options)=>// ensure process exits after typegen completes so open handles/connections
     // don't cause process to hang
     import('../cli/next-typegen.js').then((mod)=>mod.nextTypegen(options, directory).then(()=>process.exit(0)))).usage('[directory] [options]');
-const nextVersion = "16.2.0" || 'unknown';
+const nextVersion = "16.2.1" || 'unknown';
 program.command('upgrade').description('Upgrade Next.js apps to desired versions with a single command.').argument('[directory]', `A Next.js project directory to upgrade. ${(0, _picocolors.italic)('If no directory is provided, the current directory will be used.')}`).usage('[directory] [options]').option('--revision <revision>', 'Specify the target Next.js version using an NPM dist tag (e.g. "latest", "canary", "rc", "beta") or an exact version number (e.g. "15.0.0").', nextVersion.includes('-canary.') ? 'canary' : nextVersion.includes('-rc.') ? 'rc' : nextVersion.includes('-beta.') ? 'beta' : 'latest').option('--verbose', 'Verbose output', false).action(async (directory, options)=>{
     const mod = await import('../cli/next-upgrade.js');
     mod.spawnNextUpgrade(directory, options);

package/dist/build/index.js

@@ -376,7 +376,7 @@ async function build(dir, reactProductionProfiling = false, debugOutput = false,
     try {
         const nextBuildSpan = (0, _trace.trace)('next-build', undefined, {
             buildMode: experimentalBuildMode,
-            version: "16.2.0"
+            version: "16.2.1"
         });
         _buildcontext.NextBuildContext.nextBuildSpan = nextBuildSpan;
         _buildcontext.NextBuildContext.dir = dir;
@@ -889,7 +889,7 @@ async function build(dir, reactProductionProfiling = false, debugOutput = false,
             // Files outside of the distDir can be "type": "module"
             await writeFileUtf8(_path.default.join(distDir, 'package.json'), '{"type": "commonjs"}');
             // These are written to distDir, so they need to come after creating and cleaning distDr.
-            await (0, _builddiagnostics.recordFrameworkVersion)("16.2.0");
+            await (0, _builddiagnostics.recordFrameworkVersion)("16.2.1");
             await (0, _builddiagnostics.updateBuildDiagnostics)({
                 buildStage: 'start'
             });
@@ -2540,7 +2540,7 @@ async function build(dir, reactProductionProfiling = false, debugOutput = false,
                         configOutDir: _path.default.join(dir, configOutDir),
                         staticPages,
                         serverPropsPages,
-                        nextVersion: "16.2.0",
+                        nextVersion: "16.2.1",
                         tracingRoot: outputFileTracingRoot,
                         hasNodeMiddleware,
                         hasInstrumentationHook,

package/dist/build/webpack-config.js

@@ -1616,7 +1616,7 @@ async function getBaseWebpackConfig(dir, { buildId, encryptionKey, config, compi
             isClient && new _copyfileplugin.CopyFilePlugin({
                 // file path to build output of `@next/polyfill-nomodule`
                 filePath: require.resolve('./polyfills/polyfill-nomodule'),
-                cacheKey: "16.2.0",
+                cacheKey: "16.2.1",
                 name: `static/chunks/polyfills${dev ? '' : '-[hash]'}.js`,
                 minimize: false,
                 info: {
@@ -1788,7 +1788,7 @@ async function getBaseWebpackConfig(dir, { buildId, encryptionKey, config, compi
         //  - Next.js location on disk (some loaders use absolute paths and some resolve options depend on absolute paths)
         //  - Next.js version
         //  - next.config.js keys that affect compilation
-        version: `${__dirname}|${"16.2.0"}|${configVars}`,
+        version: `${__dirname}|${"16.2.1"}|${configVars}`,
         cacheDirectory: _path.default.join(distDir, 'cache', 'webpack'),
         // For production builds, it's more efficient to compress all cache files together instead of compression each one individually.
         // So we disable compression here and allow the build runner to take care of compressing the cache as a whole.

package/dist/cache/cache-control.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getCacheControlHeader", {
+    enumerable: true,
+    get: function() {
+        return getCacheControlHeader;
+    }
+});
+const _constants = require("../lib/constants");
+function getCacheControlHeader({ revalidate, expire }) {
+    const swrHeader = typeof revalidate === 'number' && expire !== undefined && revalidate < expire ? `, stale-while-revalidate=${expire - revalidate}` : '';
+    if (revalidate === 0) {
+        return 'private, no-cache, no-store, max-age=0, must-revalidate';
+    } else if (typeof revalidate === 'number') {
+        return `s-maxage=${revalidate}${swrHeader}`;
+    }
+    return `s-maxage=${_constants.CACHE_ONE_YEAR}${swrHeader}`;
+}
+
+//# sourceMappingURL=cache-control.js.map

package/dist/cache/cache-control.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../cache/cache-control.ts"],"sourcesContent":["import { CACHE_ONE_YEAR } from '../lib/constants'\n\n/**\n * The revalidate option used internally for pages. A value of `false` means\n * that the page should not be revalidated. A number means that the page\n * should be revalidated after the given number of seconds (this also includes\n * `1` which means to revalidate after 1 second). A value of `0` is not a valid\n * value for this option.\n */\nexport type Revalidate = number | false\n\nexport interface CacheControl {\n  revalidate: Revalidate\n  expire: number | undefined\n}\n\nexport function getCacheControlHeader({\n  revalidate,\n  expire,\n}: CacheControl): string {\n  const swrHeader =\n    typeof revalidate === 'number' &&\n    expire !== undefined &&\n    revalidate < expire\n      ? `, stale-while-revalidate=${expire - revalidate}`\n      : ''\n\n  if (revalidate === 0) {\n    return 'private, no-cache, no-store, max-age=0, must-revalidate'\n  } else if (typeof revalidate === 'number') {\n    return `s-maxage=${revalidate}${swrHeader}`\n  }\n\n  return `s-maxage=${CACHE_ONE_YEAR}${swrHeader}`\n}\n"],"names":["getCacheControlHeader","revalidate","expire","swrHeader","undefined","CACHE_ONE_YEAR"],"mappings":";;;;+BAgBgBA;;;eAAAA;;;2BAhBe;AAgBxB,SAASA,sBAAsB,EACpCC,UAAU,EACVC,MAAM,EACO;IACb,MAAMC,YACJ,OAAOF,eAAe,YACtBC,WAAWE,aACXH,aAAaC,SACT,CAAC,yBAAyB,EAAEA,SAASD,YAAY,GACjD;IAEN,IAAIA,eAAe,GAAG;QACpB,OAAO;IACT,OAAO,IAAI,OAAOA,eAAe,UAAU;QACzC,OAAO,CAAC,SAAS,EAAEA,aAAaE,WAAW;IAC7C;IAEA,OAAO,CAAC,SAAS,EAAEE,yBAAc,GAAGF,WAAW;AACjD","ignoreList":[0]}

package/dist/cache/clone-response.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cloneResponse", {
+    enumerable: true,
+    get: function() {
+        return cloneResponse;
+    }
+});
+const noop = ()=>{};
+let registry;
+if (globalThis.FinalizationRegistry) {
+    registry = new FinalizationRegistry((weakRef)=>{
+        const stream = weakRef.deref();
+        if (stream && !stream.locked) {
+            stream.cancel('Response object has been garbage collected').then(noop);
+        }
+    });
+}
+function cloneResponse(original) {
+    // If the response has no body, then we can just return the original response
+    // twice because it's immutable.
+    if (!original.body) {
+        return [
+            original,
+            original
+        ];
+    }
+    const [body1, body2] = original.body.tee();
+    const cloned1 = new Response(body1, {
+        status: original.status,
+        statusText: original.statusText,
+        headers: original.headers
+    });
+    Object.defineProperty(cloned1, 'url', {
+        value: original.url,
+        // How the original response.url behaves
+        configurable: true,
+        enumerable: true,
+        writable: false
+    });
+    // The Fetch Standard allows users to skip consuming the response body by
+    // relying on garbage collection to release connection resources.
+    // https://github.com/nodejs/undici?tab=readme-ov-file#garbage-collection
+    //
+    // To cancel the stream you then need to cancel both resulting branches.
+    // Teeing a stream will generally lock it for the duration, preventing other
+    // readers from locking it.
+    // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/tee
+    // cloned2 is stored in a react cache and cloned for subsequent requests.
+    // It is the original request, and is is garbage collected by a
+    // FinalizationRegistry in Undici, but since we're tee-ing the stream
+    // ourselves, we need to cancel clone1's stream (the response returned from
+    // our dedupe fetch) when clone1 is reclaimed, otherwise we leak memory.
+    if (registry && cloned1.body) {
+        registry.register(cloned1, new WeakRef(cloned1.body));
+    }
+    const cloned2 = new Response(body2, {
+        status: original.status,
+        statusText: original.statusText,
+        headers: original.headers
+    });
+    Object.defineProperty(cloned2, 'url', {
+        value: original.url,
+        // How the original response.url behaves
+        configurable: true,
+        enumerable: true,
+        writable: false
+    });
+    return [
+        cloned1,
+        cloned2
+    ];
+}
+
+//# sourceMappingURL=clone-response.js.map

package/dist/cache/clone-response.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../cache/clone-response.ts"],"sourcesContent":["const noop = () => {}\n\nlet registry: FinalizationRegistry<WeakRef<ReadableStream>> | undefined\n\nif (globalThis.FinalizationRegistry) {\n  registry = new FinalizationRegistry((weakRef: WeakRef<ReadableStream>) => {\n    const stream = weakRef.deref()\n    if (stream && !stream.locked) {\n      stream.cancel('Response object has been garbage collected').then(noop)\n    }\n  })\n}\n\n/**\n * Clones a response by teeing the body so we can return two independent\n * ReadableStreams from it. This avoids the bug in the undici library around\n * response cloning.\n *\n * After cloning, the original response's body will be consumed and closed.\n *\n * @see https://github.com/vercel/next.js/pull/73274\n *\n * @param original - The original response to clone.\n * @returns A tuple containing two independent clones of the original response.\n */\nexport function cloneResponse(original: Response): [Response, Response] {\n  // If the response has no body, then we can just return the original response\n  // twice because it's immutable.\n  if (!original.body) {\n    return [original, original]\n  }\n\n  const [body1, body2] = original.body.tee()\n\n  const cloned1 = new Response(body1, {\n    status: original.status,\n    statusText: original.statusText,\n    headers: original.headers,\n  })\n\n  Object.defineProperty(cloned1, 'url', {\n    value: original.url,\n    // How the original response.url behaves\n    configurable: true,\n    enumerable: true,\n    writable: false,\n  })\n\n  // The Fetch Standard allows users to skip consuming the response body by\n  // relying on garbage collection to release connection resources.\n  // https://github.com/nodejs/undici?tab=readme-ov-file#garbage-collection\n  //\n  // To cancel the stream you then need to cancel both resulting branches.\n  // Teeing a stream will generally lock it for the duration, preventing other\n  // readers from locking it.\n  // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/tee\n\n  // cloned2 is stored in a react cache and cloned for subsequent requests.\n  // It is the original request, and is is garbage collected by a\n  // FinalizationRegistry in Undici, but since we're tee-ing the stream\n  // ourselves, we need to cancel clone1's stream (the response returned from\n  // our dedupe fetch) when clone1 is reclaimed, otherwise we leak memory.\n  if (registry && cloned1.body) {\n    registry.register(cloned1, new WeakRef(cloned1.body))\n  }\n\n  const cloned2 = new Response(body2, {\n    status: original.status,\n    statusText: original.statusText,\n    headers: original.headers,\n  })\n\n  Object.defineProperty(cloned2, 'url', {\n    value: original.url,\n    // How the original response.url behaves\n    configurable: true,\n    enumerable: true,\n    writable: false,\n  })\n\n  return [cloned1, cloned2]\n}\n"],"names":["cloneResponse","noop","registry","globalThis","FinalizationRegistry","weakRef","stream","deref","locked","cancel","then","original","body","body1","body2","tee","cloned1","Response","status","statusText","headers","Object","defineProperty","value","url","configurable","enumerable","writable","register","WeakRef","cloned2"],"mappings":";;;;+BAyBgBA;;;eAAAA;;;AAzBhB,MAAMC,OAAO,KAAO;AAEpB,IAAIC;AAEJ,IAAIC,WAAWC,oBAAoB,EAAE;IACnCF,WAAW,IAAIE,qBAAqB,CAACC;QACnC,MAAMC,SAASD,QAAQE,KAAK;QAC5B,IAAID,UAAU,CAACA,OAAOE,MAAM,EAAE;YAC5BF,OAAOG,MAAM,CAAC,8CAA8CC,IAAI,CAACT;QACnE;IACF;AACF;AAcO,SAASD,cAAcW,QAAkB;IAC9C,6EAA6E;IAC7E,gCAAgC;IAChC,IAAI,CAACA,SAASC,IAAI,EAAE;QAClB,OAAO;YAACD;YAAUA;SAAS;IAC7B;IAEA,MAAM,CAACE,OAAOC,MAAM,GAAGH,SAASC,IAAI,CAACG,GAAG;IAExC,MAAMC,UAAU,IAAIC,SAASJ,OAAO;QAClCK,QAAQP,SAASO,MAAM;QACvBC,YAAYR,SAASQ,UAAU;QAC/BC,SAAST,SAASS,OAAO;IAC3B;IAEAC,OAAOC,cAAc,CAACN,SAAS,OAAO;QACpCO,OAAOZ,SAASa,GAAG;QACnB,wCAAwC;QACxCC,cAAc;QACdC,YAAY;QACZC,UAAU;IACZ;IAEA,yEAAyE;IACzE,iEAAiE;IACjE,yEAAyE;IACzE,EAAE;IACF,wEAAwE;IACxE,4EAA4E;IAC5E,2BAA2B;IAC3B,sEAAsE;IAEtE,yEAAyE;IACzE,+DAA+D;IAC/D,qEAAqE;IACrE,2EAA2E;IAC3E,wEAAwE;IACxE,IAAIzB,YAAYc,QAAQJ,IAAI,EAAE;QAC5BV,SAAS0B,QAAQ,CAACZ,SAAS,IAAIa,QAAQb,QAAQJ,IAAI;IACrD;IAEA,MAAMkB,UAAU,IAAIb,SAASH,OAAO;QAClCI,QAAQP,SAASO,MAAM;QACvBC,YAAYR,SAASQ,UAAU;QAC/BC,SAAST,SAASS,OAAO;IAC3B;IAEAC,OAAOC,cAAc,CAACQ,SAAS,OAAO;QACpCP,OAAOZ,SAASa,GAAG;QACnB,wCAAwC;QACxCC,cAAc;QACdC,YAAY;QACZC,UAAU;IACZ;IAEA,OAAO;QAACX;QAASc;KAAQ;AAC3B","ignoreList":[0]}

package/dist/cache/dedupe-fetch.js

@@ -0,0 +1,123 @@
+/**
+ * Based on https://github.com/facebook/react/blob/d4e78c42a94be027b4dc7ed2659a5fddfbf9bd4e/packages/react/src/ReactFetch.js
+ */ // Use bare 'react' import so webpack can alias it to the vendored RSC React
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createDedupeFetch", {
+    enumerable: true,
+    get: function() {
+        return createDedupeFetch;
+    }
+});
+const _cloneresponse = require("./clone-response");
+const _invarianterror = require("../shared/lib/invariant-error");
+const React = require('react');
+const simpleCacheKey = '["GET",[],null,"follow",null,null,null,null]' // generateCacheKey(new Request('https://blank'));
+;
+// Headers that should not affect deduplication
+// traceparent and tracestate are used for distributed tracing and should not affect cache keys
+const headersToExcludeInCacheKey = new Set([
+    'traceparent',
+    'tracestate'
+]);
+function generateCacheKey(request) {
+    // We pick the fields that goes into the key used to dedupe requests.
+    // We don't include the `cache` field, because we end up using whatever
+    // caching resulted from the first request.
+    // Notably we currently don't consider non-standard (or future) options.
+    // This might not be safe. TODO: warn for non-standard extensions differing.
+    // IF YOU CHANGE THIS UPDATE THE simpleCacheKey ABOVE.
+    const filteredHeaders = Array.from(request.headers.entries()).filter(([key])=>!headersToExcludeInCacheKey.has(key.toLowerCase()));
+    return JSON.stringify([
+        request.method,
+        filteredHeaders,
+        request.mode,
+        request.redirect,
+        request.credentials,
+        request.referrer,
+        request.referrerPolicy,
+        request.integrity
+    ]);
+}
+function createDedupeFetch(originalFetch) {
+    const getCacheEntries = React.cache(// eslint-disable-next-line @typescript-eslint/no-unused-vars -- url is the cache key
+    (url)=>[]);
+    return function dedupeFetch(resource, options) {
+        if (options && options.signal) {
+            // If we're passed a signal, then we assume that
+            // someone else controls the lifetime of this object and opts out of
+            // caching. It's effectively the opt-out mechanism.
+            // Ideally we should be able to check this on the Request but
+            // it always gets initialized with its own signal so we don't
+            // know if it's supposed to override - unless we also override the
+            // Request constructor.
+            return originalFetch(resource, options);
+        }
+        // Normalize the Request
+        let url;
+        let cacheKey;
+        if (typeof resource === 'string' && !options) {
+            // Fast path.
+            cacheKey = simpleCacheKey;
+            url = resource;
+        } else {
+            // Normalize the request.
+            // if resource is not a string or a URL (its an instance of Request)
+            // then do not instantiate a new Request but instead
+            // reuse the request as to not disturb the body in the event it's a ReadableStream.
+            const request = typeof resource === 'string' || resource instanceof URL ? new Request(resource, options) : resource;
+            if (request.method !== 'GET' && request.method !== 'HEAD' || request.keepalive) {
+                // We currently don't dedupe requests that might have side-effects. Those
+                // have to be explicitly cached. We assume that the request doesn't have a
+                // body if it's GET or HEAD.
+                // keepalive gets treated the same as if you passed a custom cache signal.
+                return originalFetch(resource, options);
+            }
+            cacheKey = generateCacheKey(request);
+            url = request.url;
+        }
+        const cacheEntries = getCacheEntries(url);
+        for(let i = 0, j = cacheEntries.length; i < j; i += 1){
+            const [key, promise] = cacheEntries[i];
+            if (key === cacheKey) {
+                return promise.then(()=>{
+                    const response = cacheEntries[i][2];
+                    if (!response) throw Object.defineProperty(new _invarianterror.InvariantError('No cached response'), "__NEXT_ERROR_CODE", {
+                        value: "E579",
+                        enumerable: false,
+                        configurable: true
+                    });
+                    // We're cloning the response using this utility because there exists
+                    // a bug in the undici library around response cloning. See the
+                    // following pull request for more details:
+                    // https://github.com/vercel/next.js/pull/73274
+                    const [cloned1, cloned2] = (0, _cloneresponse.cloneResponse)(response);
+                    cacheEntries[i][2] = cloned2;
+                    return cloned1;
+                });
+            }
+        }
+        // We pass the original arguments here in case normalizing the Request
+        // doesn't include all the options in this environment.
+        const promise = originalFetch(resource, options);
+        const entry = [
+            cacheKey,
+            promise,
+            null
+        ];
+        cacheEntries.push(entry);
+        return promise.then((response)=>{
+            // We're cloning the response using this utility because there exists
+            // a bug in the undici library around response cloning. See the
+            // following pull request for more details:
+            // https://github.com/vercel/next.js/pull/73274
+            const [cloned1, cloned2] = (0, _cloneresponse.cloneResponse)(response);
+            entry[2] = cloned2;
+            return cloned1;
+        });
+    };
+}
+
+//# sourceMappingURL=dedupe-fetch.js.map

package/dist/cache/dedupe-fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../cache/dedupe-fetch.ts"],"sourcesContent":["/**\n * Based on https://github.com/facebook/react/blob/d4e78c42a94be027b4dc7ed2659a5fddfbf9bd4e/packages/react/src/ReactFetch.js\n */\n// Use bare 'react' import so webpack can alias it to the vendored RSC React\nconst React: typeof import('react') = require('react') as typeof import('react')\nimport { cloneResponse } from './clone-response'\nimport { InvariantError } from '../shared/lib/invariant-error'\n\nconst simpleCacheKey = '[\"GET\",[],null,\"follow\",null,null,null,null]' // generateCacheKey(new Request('https://blank'));\n\n// Headers that should not affect deduplication\n// traceparent and tracestate are used for distributed tracing and should not affect cache keys\nconst headersToExcludeInCacheKey = new Set(['traceparent', 'tracestate'])\n\nfunction generateCacheKey(request: Request): string {\n  // We pick the fields that goes into the key used to dedupe requests.\n  // We don't include the `cache` field, because we end up using whatever\n  // caching resulted from the first request.\n  // Notably we currently don't consider non-standard (or future) options.\n  // This might not be safe. TODO: warn for non-standard extensions differing.\n  // IF YOU CHANGE THIS UPDATE THE simpleCacheKey ABOVE.\n\n  const filteredHeaders = Array.from(request.headers.entries()).filter(\n    ([key]) => !headersToExcludeInCacheKey.has(key.toLowerCase())\n  )\n\n  return JSON.stringify([\n    request.method,\n    filteredHeaders,\n    request.mode,\n    request.redirect,\n    request.credentials,\n    request.referrer,\n    request.referrerPolicy,\n    request.integrity,\n  ])\n}\n\ntype CacheEntry = [\n  key: string,\n  promise: Promise<Response>,\n  response: Response | null,\n]\n\nexport function createDedupeFetch(originalFetch: typeof fetch) {\n  const getCacheEntries = React.cache(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- url is the cache key\n    (url: string): CacheEntry[] => []\n  )\n\n  return function dedupeFetch(\n    resource: URL | RequestInfo,\n    options?: RequestInit\n  ): Promise<Response> {\n    if (options && options.signal) {\n      // If we're passed a signal, then we assume that\n      // someone else controls the lifetime of this object and opts out of\n      // caching. It's effectively the opt-out mechanism.\n      // Ideally we should be able to check this on the Request but\n      // it always gets initialized with its own signal so we don't\n      // know if it's supposed to override - unless we also override the\n      // Request constructor.\n      return originalFetch(resource, options)\n    }\n    // Normalize the Request\n    let url: string\n    let cacheKey: string\n    if (typeof resource === 'string' && !options) {\n      // Fast path.\n      cacheKey = simpleCacheKey\n      url = resource\n    } else {\n      // Normalize the request.\n      // if resource is not a string or a URL (its an instance of Request)\n      // then do not instantiate a new Request but instead\n      // reuse the request as to not disturb the body in the event it's a ReadableStream.\n      const request =\n        typeof resource === 'string' || resource instanceof URL\n          ? new Request(resource, options)\n          : resource\n      if (\n        (request.method !== 'GET' && request.method !== 'HEAD') ||\n        request.keepalive\n      ) {\n        // We currently don't dedupe requests that might have side-effects. Those\n        // have to be explicitly cached. We assume that the request doesn't have a\n        // body if it's GET or HEAD.\n        // keepalive gets treated the same as if you passed a custom cache signal.\n        return originalFetch(resource, options)\n      }\n      cacheKey = generateCacheKey(request)\n      url = request.url\n    }\n\n    const cacheEntries = getCacheEntries(url)\n    for (let i = 0, j = cacheEntries.length; i < j; i += 1) {\n      const [key, promise] = cacheEntries[i]\n      if (key === cacheKey) {\n        return promise.then(() => {\n          const response = cacheEntries[i][2]\n          if (!response) throw new InvariantError('No cached response')\n\n          // We're cloning the response using this utility because there exists\n          // a bug in the undici library around response cloning. See the\n          // following pull request for more details:\n          // https://github.com/vercel/next.js/pull/73274\n          const [cloned1, cloned2] = cloneResponse(response)\n          cacheEntries[i][2] = cloned2\n          return cloned1\n        })\n      }\n    }\n\n    // We pass the original arguments here in case normalizing the Request\n    // doesn't include all the options in this environment.\n    const promise = originalFetch(resource, options)\n    const entry: CacheEntry = [cacheKey, promise, null]\n    cacheEntries.push(entry)\n\n    return promise.then((response) => {\n      // We're cloning the response using this utility because there exists\n      // a bug in the undici library around response cloning. See the\n      // following pull request for more details:\n      // https://github.com/vercel/next.js/pull/73274\n      const [cloned1, cloned2] = cloneResponse(response)\n      entry[2] = cloned2\n      return cloned1\n    })\n  }\n}\n"],"names":["createDedupeFetch","React","require","simpleCacheKey","headersToExcludeInCacheKey","Set","generateCacheKey","request","filteredHeaders","Array","from","headers","entries","filter","key","has","toLowerCase","JSON","stringify","method","mode","redirect","credentials","referrer","referrerPolicy","integrity","originalFetch","getCacheEntries","cache","url","dedupeFetch","resource","options","signal","cacheKey","URL","Request","keepalive","cacheEntries","i","j","length","promise","then","response","InvariantError","cloned1","cloned2","cloneResponse","entry","push"],"mappings":"AAAA;;CAEC,GACD,4EAA4E;;;;;+BAyC5DA;;;eAAAA;;;+BAvCc;gCACC;AAF/B,MAAMC,QAAgCC,QAAQ;AAI9C,MAAMC,iBAAiB,+CAA+C,kDAAkD;;AAExH,+CAA+C;AAC/C,+FAA+F;AAC/F,MAAMC,6BAA6B,IAAIC,IAAI;IAAC;IAAe;CAAa;AAExE,SAASC,iBAAiBC,OAAgB;IACxC,qEAAqE;IACrE,uEAAuE;IACvE,2CAA2C;IAC3C,wEAAwE;IACxE,4EAA4E;IAC5E,sDAAsD;IAEtD,MAAMC,kBAAkBC,MAAMC,IAAI,CAACH,QAAQI,OAAO,CAACC,OAAO,IAAIC,MAAM,CAClE,CAAC,CAACC,IAAI,GAAK,CAACV,2BAA2BW,GAAG,CAACD,IAAIE,WAAW;IAG5D,OAAOC,KAAKC,SAAS,CAAC;QACpBX,QAAQY,MAAM;QACdX;QACAD,QAAQa,IAAI;QACZb,QAAQc,QAAQ;QAChBd,QAAQe,WAAW;QACnBf,QAAQgB,QAAQ;QAChBhB,QAAQiB,cAAc;QACtBjB,QAAQkB,SAAS;KAClB;AACH;AAQO,SAASzB,kBAAkB0B,aAA2B;IAC3D,MAAMC,kBAAkB1B,MAAM2B,KAAK,CACjC,qFAAqF;IACrF,CAACC,MAA8B,EAAE;IAGnC,OAAO,SAASC,YACdC,QAA2B,EAC3BC,OAAqB;QAErB,IAAIA,WAAWA,QAAQC,MAAM,EAAE;YAC7B,gDAAgD;YAChD,oEAAoE;YACpE,mDAAmD;YACnD,6DAA6D;YAC7D,6DAA6D;YAC7D,kEAAkE;YAClE,uBAAuB;YACvB,OAAOP,cAAcK,UAAUC;QACjC;QACA,wBAAwB;QACxB,IAAIH;QACJ,IAAIK;QACJ,IAAI,OAAOH,aAAa,YAAY,CAACC,SAAS;YAC5C,aAAa;YACbE,WAAW/B;YACX0B,MAAME;QACR,OAAO;YACL,yBAAyB;YACzB,oEAAoE;YACpE,oDAAoD;YACpD,mFAAmF;YACnF,MAAMxB,UACJ,OAAOwB,aAAa,YAAYA,oBAAoBI,MAChD,IAAIC,QAAQL,UAAUC,WACtBD;YACN,IACE,AAACxB,QAAQY,MAAM,KAAK,SAASZ,QAAQY,MAAM,KAAK,UAChDZ,QAAQ8B,SAAS,EACjB;gBACA,yEAAyE;gBACzE,0EAA0E;gBAC1E,4BAA4B;gBAC5B,0EAA0E;gBAC1E,OAAOX,cAAcK,UAAUC;YACjC;YACAE,WAAW5B,iBAAiBC;YAC5BsB,MAAMtB,QAAQsB,GAAG;QACnB;QAEA,MAAMS,eAAeX,gBAAgBE;QACrC,IAAK,IAAIU,IAAI,GAAGC,IAAIF,aAAaG,MAAM,EAAEF,IAAIC,GAAGD,KAAK,EAAG;YACtD,MAAM,CAACzB,KAAK4B,QAAQ,GAAGJ,YAAY,CAACC,EAAE;YACtC,IAAIzB,QAAQoB,UAAU;gBACpB,OAAOQ,QAAQC,IAAI,CAAC;oBAClB,MAAMC,WAAWN,YAAY,CAACC,EAAE,CAAC,EAAE;oBACnC,IAAI,CAACK,UAAU,MAAM,qBAAwC,CAAxC,IAAIC,8BAAc,CAAC,uBAAnB,qBAAA;+BAAA;oCAAA;sCAAA;oBAAuC;oBAE5D,qEAAqE;oBACrE,+DAA+D;oBAC/D,2CAA2C;oBAC3C,+CAA+C;oBAC/C,MAAM,CAACC,SAASC,QAAQ,GAAGC,IAAAA,4BAAa,EAACJ;oBACzCN,YAAY,CAACC,EAAE,CAAC,EAAE,GAAGQ;oBACrB,OAAOD;gBACT;YACF;QACF;QAEA,sEAAsE;QACtE,uDAAuD;QACvD,MAAMJ,UAAUhB,cAAcK,UAAUC;QACxC,MAAMiB,QAAoB;YAACf;YAAUQ;YAAS;SAAK;QACnDJ,aAAaY,IAAI,CAACD;QAElB,OAAOP,QAAQC,IAAI,CAAC,CAACC;YACnB,qEAAqE;YACrE,+DAA+D;YAC/D,2CAA2C;YAC3C,+CAA+C;YAC/C,MAAM,CAACE,SAASC,QAAQ,GAAGC,IAAAA,4BAAa,EAACJ;YACzCK,KAAK,CAAC,EAAE,GAAGF;YACX,OAAOD;QACT;IACF;AACF","ignoreList":[0]}

package/dist/cache/lazy-result.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createLazyResult: null,
+    isResolvedLazyResult: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createLazyResult: function() {
+        return createLazyResult;
+    },
+    isResolvedLazyResult: function() {
+        return isResolvedLazyResult;
+    }
+});
+function createLazyResult(fn) {
+    let pendingResult;
+    const result = {
+        then (onfulfilled, onrejected) {
+            if (!pendingResult) {
+                pendingResult = fn();
+            }
+            pendingResult.then((value)=>{
+                result.value = value;
+            }).catch(()=>{
+            // The externally awaited result will be rejected via `onrejected`. We
+            // don't need to handle it here. But we do want to avoid an unhandled
+            // rejection.
+            });
+            return pendingResult.then(onfulfilled, onrejected);
+        }
+    };
+    return result;
+}
+function isResolvedLazyResult(result) {
+    return result.hasOwnProperty('value');
+}
+
+//# sourceMappingURL=lazy-result.js.map

package/dist/cache/lazy-result.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../cache/lazy-result.ts"],"sourcesContent":["export type LazyResult<TValue> = PromiseLike<TValue> & { value?: TValue }\nexport type ResolvedLazyResult<TValue> = PromiseLike<TValue> & { value: TValue }\n\n/**\n * Calls the given async function only when the returned promise-like object is\n * awaited. Afterwards, it provides the resolved value synchronously as `value`\n * property.\n */\nexport function createLazyResult<TValue>(\n  fn: () => Promise<TValue>\n): LazyResult<TValue> {\n  let pendingResult: Promise<TValue> | undefined\n\n  const result: LazyResult<TValue> = {\n    then(onfulfilled, onrejected) {\n      if (!pendingResult) {\n        pendingResult = fn()\n      }\n\n      pendingResult\n        .then((value) => {\n          result.value = value\n        })\n        .catch(() => {\n          // The externally awaited result will be rejected via `onrejected`. We\n          // don't need to handle it here. But we do want to avoid an unhandled\n          // rejection.\n        })\n\n      return pendingResult.then(onfulfilled, onrejected)\n    },\n  }\n\n  return result\n}\n\nexport function isResolvedLazyResult<TValue>(\n  result: LazyResult<TValue>\n): result is ResolvedLazyResult<TValue> {\n  return result.hasOwnProperty('value')\n}\n"],"names":["createLazyResult","isResolvedLazyResult","fn","pendingResult","result","then","onfulfilled","onrejected","value","catch","hasOwnProperty"],"mappings":";;;;;;;;;;;;;;;IAQgBA,gBAAgB;eAAhBA;;IA4BAC,oBAAoB;eAApBA;;;AA5BT,SAASD,iBACdE,EAAyB;IAEzB,IAAIC;IAEJ,MAAMC,SAA6B;QACjCC,MAAKC,WAAW,EAAEC,UAAU;YAC1B,IAAI,CAACJ,eAAe;gBAClBA,gBAAgBD;YAClB;YAEAC,cACGE,IAAI,CAAC,CAACG;gBACLJ,OAAOI,KAAK,GAAGA;YACjB,GACCC,KAAK,CAAC;YACL,sEAAsE;YACtE,qEAAqE;YACrE,aAAa;YACf;YAEF,OAAON,cAAcE,IAAI,CAACC,aAAaC;QACzC;IACF;IAEA,OAAOH;AACT;AAEO,SAASH,qBACdG,MAA0B;IAE1B,OAAOA,OAAOM,cAAc,CAAC;AAC/B","ignoreList":[0]}

package/dist/cache/lru-cache.js

@@ -0,0 +1,177 @@
+/**
+ * Node in the doubly-linked list used for LRU tracking.
+ * Each node represents a cache entry with bidirectional pointers.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LRUCache", {
+    enumerable: true,
+    get: function() {
+        return LRUCache;
+    }
+});
+class LRUNode {
+    constructor(key, data, size){
+        this.prev = null;
+        this.next = null;
+        this.key = key;
+        this.data = data;
+        this.size = size;
+    }
+}
+/**
+ * Sentinel node used for head/tail boundaries.
+ * These nodes don't contain actual cache data but simplify list operations.
+ */ class SentinelNode {
+    constructor(){
+        this.prev = null;
+        this.next = null;
+    }
+}
+class LRUCache {
+    constructor(maxSize, calculateSize){
+        this.cache = new Map();
+        this.totalSize = 0;
+        this.maxSize = maxSize;
+        this.calculateSize = calculateSize;
+        // Create sentinel nodes to simplify doubly-linked list operations
+        // HEAD <-> TAIL (empty list)
+        this.head = new SentinelNode();
+        this.tail = new SentinelNode();
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+    }
+    /**
+   * Adds a node immediately after the head (marks as most recently used).
+   * Used when inserting new items or when an item is accessed.
+   * PRECONDITION: node must be disconnected (prev/next should be null)
+   */ addToHead(node) {
+        node.prev = this.head;
+        node.next = this.head.next;
+        // head.next is always non-null (points to tail or another node)
+        this.head.next.prev = node;
+        this.head.next = node;
+    }
+    /**
+   * Removes a node from its current position in the doubly-linked list.
+   * Updates the prev/next pointers of adjacent nodes to maintain list integrity.
+   * PRECONDITION: node must be connected (prev/next are non-null)
+   */ removeNode(node) {
+        // Connected nodes always have non-null prev/next
+        node.prev.next = node.next;
+        node.next.prev = node.prev;
+    }
+    /**
+   * Moves an existing node to the head position (marks as most recently used).
+   * This is the core LRU operation - accessed items become most recent.
+   */ moveToHead(node) {
+        this.removeNode(node);
+        this.addToHead(node);
+    }
+    /**
+   * Removes and returns the least recently used node (the one before tail).
+   * This is called during eviction when the cache exceeds capacity.
+   * PRECONDITION: cache is not empty (ensured by caller)
+   */ removeTail() {
+        const lastNode = this.tail.prev;
+        // tail.prev is always non-null and always LRUNode when cache is not empty
+        this.removeNode(lastNode);
+        return lastNode;
+    }
+    /**
+   * Sets a key-value pair in the cache.
+   * If the key exists, updates the value and moves to head.
+   * If new, adds at head and evicts from tail if necessary.
+   *
+   * Time Complexity:
+   * - O(1) for uniform item sizes
+   * - O(k) where k is the number of items evicted (can be O(N) for variable sizes)
+   */ set(key, value) {
+        const size = (this.calculateSize == null ? void 0 : this.calculateSize.call(this, value)) ?? 1;
+        if (size > this.maxSize) {
+            console.warn('Single item size exceeds maxSize');
+            return;
+        }
+        const existing = this.cache.get(key);
+        if (existing) {
+            // Update existing node: adjust size and move to head (most recent)
+            existing.data = value;
+            this.totalSize = this.totalSize - existing.size + size;
+            existing.size = size;
+            this.moveToHead(existing);
+        } else {
+            // Add new node at head (most recent position)
+            const newNode = new LRUNode(key, value, size);
+            this.cache.set(key, newNode);
+            this.addToHead(newNode);
+            this.totalSize += size;
+        }
+        // Evict least recently used items until under capacity
+        while(this.totalSize > this.maxSize && this.cache.size > 0){
+            const tail = this.removeTail();
+            this.cache.delete(tail.key);
+            this.totalSize -= tail.size;
+        }
+    }
+    /**
+   * Checks if a key exists in the cache.
+   * This is a pure query operation - does NOT update LRU order.
+   *
+   * Time Complexity: O(1)
+   */ has(key) {
+        return this.cache.has(key);
+    }
+    /**
+   * Retrieves a value by key and marks it as most recently used.
+   * Moving to head maintains the LRU property for future evictions.
+   *
+   * Time Complexity: O(1)
+   */ get(key) {
+        const node = this.cache.get(key);
+        if (!node) return undefined;
+        // Mark as most recently used by moving to head
+        this.moveToHead(node);
+        return node.data;
+    }
+    /**
+   * Returns an iterator over the cache entries. The order is outputted in the
+   * order of most recently used to least recently used.
+   */ *[Symbol.iterator]() {
+        let current = this.head.next;
+        while(current && current !== this.tail){
+            // Between head and tail, current is always LRUNode
+            const node = current;
+            yield [
+                node.key,
+                node.data
+            ];
+            current = current.next;
+        }
+    }
+    /**
+   * Removes a specific key from the cache.
+   * Updates both the hash map and doubly-linked list.
+   *
+   * Time Complexity: O(1)
+   */ remove(key) {
+        const node = this.cache.get(key);
+        if (!node) return;
+        this.removeNode(node);
+        this.cache.delete(key);
+        this.totalSize -= node.size;
+    }
+    /**
+   * Returns the number of items in the cache.
+   */ get size() {
+        return this.cache.size;
+    }
+    /**
+   * Returns the current total size of all cached items.
+   * This uses the custom size calculation if provided.
+   */ get currentSize() {
+        return this.totalSize;
+    }
+}
+
+//# sourceMappingURL=lru-cache.js.map

package/dist/cache/lru-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../cache/lru-cache.ts"],"sourcesContent":["/**\n * Node in the doubly-linked list used for LRU tracking.\n * Each node represents a cache entry with bidirectional pointers.\n */\nclass LRUNode<T> {\n  public readonly key: string\n  public data: T\n  public size: number\n  public prev: LRUNode<T> | SentinelNode<T> | null = null\n  public next: LRUNode<T> | SentinelNode<T> | null = null\n\n  constructor(key: string, data: T, size: number) {\n    this.key = key\n    this.data = data\n    this.size = size\n  }\n}\n\n/**\n * Sentinel node used for head/tail boundaries.\n * These nodes don't contain actual cache data but simplify list operations.\n */\nclass SentinelNode<T> {\n  public prev: LRUNode<T> | SentinelNode<T> | null = null\n  public next: LRUNode<T> | SentinelNode<T> | null = null\n}\n\n/**\n * LRU (Least Recently Used) Cache implementation using a doubly-linked list\n * and hash map for O(1) operations.\n *\n * Algorithm:\n * - Uses a doubly-linked list to maintain access order (most recent at head)\n * - Hash map provides O(1) key-to-node lookup\n * - Sentinel head/tail nodes simplify edge case handling\n * - Size-based eviction supports custom size calculation functions\n *\n * Data Structure Layout:\n * HEAD <-> [most recent] <-> ... <-> [least recent] <-> TAIL\n *\n * Operations:\n * - get(): Move accessed node to head (mark as most recent)\n * - set(): Add new node at head, evict from tail if over capacity\n * - Eviction: Remove least recent node (tail.prev) when size exceeds limit\n */\nexport class LRUCache<T> {\n  private readonly cache: Map<string, LRUNode<T>> = new Map()\n  private readonly head: SentinelNode<T>\n  private readonly tail: SentinelNode<T>\n  private totalSize: number = 0\n  private readonly maxSize: number\n  private readonly calculateSize: ((value: T) => number) | undefined\n\n  constructor(maxSize: number, calculateSize?: (value: T) => number) {\n    this.maxSize = maxSize\n    this.calculateSize = calculateSize\n\n    // Create sentinel nodes to simplify doubly-linked list operations\n    // HEAD <-> TAIL (empty list)\n    this.head = new SentinelNode<T>()\n    this.tail = new SentinelNode<T>()\n    this.head.next = this.tail\n    this.tail.prev = this.head\n  }\n\n  /**\n   * Adds a node immediately after the head (marks as most recently used).\n   * Used when inserting new items or when an item is accessed.\n   * PRECONDITION: node must be disconnected (prev/next should be null)\n   */\n  private addToHead(node: LRUNode<T>): void {\n    node.prev = this.head\n    node.next = this.head.next\n    // head.next is always non-null (points to tail or another node)\n    this.head.next!.prev = node\n    this.head.next = node\n  }\n\n  /**\n   * Removes a node from its current position in the doubly-linked list.\n   * Updates the prev/next pointers of adjacent nodes to maintain list integrity.\n   * PRECONDITION: node must be connected (prev/next are non-null)\n   */\n  private removeNode(node: LRUNode<T>): void {\n    // Connected nodes always have non-null prev/next\n    node.prev!.next = node.next\n    node.next!.prev = node.prev\n  }\n\n  /**\n   * Moves an existing node to the head position (marks as most recently used).\n   * This is the core LRU operation - accessed items become most recent.\n   */\n  private moveToHead(node: LRUNode<T>): void {\n    this.removeNode(node)\n    this.addToHead(node)\n  }\n\n  /**\n   * Removes and returns the least recently used node (the one before tail).\n   * This is called during eviction when the cache exceeds capacity.\n   * PRECONDITION: cache is not empty (ensured by caller)\n   */\n  private removeTail(): LRUNode<T> {\n    const lastNode = this.tail.prev as LRUNode<T>\n    // tail.prev is always non-null and always LRUNode when cache is not empty\n    this.removeNode(lastNode)\n    return lastNode\n  }\n\n  /**\n   * Sets a key-value pair in the cache.\n   * If the key exists, updates the value and moves to head.\n   * If new, adds at head and evicts from tail if necessary.\n   *\n   * Time Complexity:\n   * - O(1) for uniform item sizes\n   * - O(k) where k is the number of items evicted (can be O(N) for variable sizes)\n   */\n  public set(key: string, value: T): void {\n    const size = this.calculateSize?.(value) ?? 1\n    if (size > this.maxSize) {\n      console.warn('Single item size exceeds maxSize')\n      return\n    }\n\n    const existing = this.cache.get(key)\n    if (existing) {\n      // Update existing node: adjust size and move to head (most recent)\n      existing.data = value\n      this.totalSize = this.totalSize - existing.size + size\n      existing.size = size\n      this.moveToHead(existing)\n    } else {\n      // Add new node at head (most recent position)\n      const newNode = new LRUNode(key, value, size)\n      this.cache.set(key, newNode)\n      this.addToHead(newNode)\n      this.totalSize += size\n    }\n\n    // Evict least recently used items until under capacity\n    while (this.totalSize > this.maxSize && this.cache.size > 0) {\n      const tail = this.removeTail()\n      this.cache.delete(tail.key)\n      this.totalSize -= tail.size\n    }\n  }\n\n  /**\n   * Checks if a key exists in the cache.\n   * This is a pure query operation - does NOT update LRU order.\n   *\n   * Time Complexity: O(1)\n   */\n  public has(key: string): boolean {\n    return this.cache.has(key)\n  }\n\n  /**\n   * Retrieves a value by key and marks it as most recently used.\n   * Moving to head maintains the LRU property for future evictions.\n   *\n   * Time Complexity: O(1)\n   */\n  public get(key: string): T | undefined {\n    const node = this.cache.get(key)\n    if (!node) return undefined\n\n    // Mark as most recently used by moving to head\n    this.moveToHead(node)\n\n    return node.data\n  }\n\n  /**\n   * Returns an iterator over the cache entries. The order is outputted in the\n   * order of most recently used to least recently used.\n   */\n  public *[Symbol.iterator](): IterableIterator<[string, T]> {\n    let current = this.head.next\n    while (current && current !== this.tail) {\n      // Between head and tail, current is always LRUNode\n      const node = current as LRUNode<T>\n      yield [node.key, node.data]\n      current = current.next\n    }\n  }\n\n  /**\n   * Removes a specific key from the cache.\n   * Updates both the hash map and doubly-linked list.\n   *\n   * Time Complexity: O(1)\n   */\n  public remove(key: string): void {\n    const node = this.cache.get(key)\n    if (!node) return\n\n    this.removeNode(node)\n    this.cache.delete(key)\n    this.totalSize -= node.size\n  }\n\n  /**\n   * Returns the number of items in the cache.\n   */\n  public get size(): number {\n    return this.cache.size\n  }\n\n  /**\n   * Returns the current total size of all cached items.\n   * This uses the custom size calculation if provided.\n   */\n  public get currentSize(): number {\n    return this.totalSize\n  }\n}\n"],"names":["LRUCache","LRUNode","constructor","key","data","size","prev","next","SentinelNode","maxSize","calculateSize","cache","Map","totalSize","head","tail","addToHead","node","removeNode","moveToHead","removeTail","lastNode","set","value","console","warn","existing","get","newNode","delete","has","undefined","Symbol","iterator","current","remove","currentSize"],"mappings":"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","ignoreList":[0]}

package/dist/client/app-bootstrap.js

@@ -15,7 +15,7 @@ Object.defineProperty(exports, "appBootstrap", {
 });
 const _assetprefix = require("./asset-prefix");
 const _setattributesfromprops = require("./set-attributes-from-props");
-const version = "16.2.0";
+const version = "16.2.1";
 window.next = {
     version,
     appDir: true

package/dist/client/index.js

@@ -60,7 +60,7 @@ const _hooksclientcontextsharedruntime = require("../shared/lib/hooks-client-con
 const _onrecoverableerror = require("./react-client-callbacks/on-recoverable-error");
 const _tracer = /*#__PURE__*/ _interop_require_default._(require("./tracing/tracer"));
 const _isnextroutererror = require("./components/is-next-router-error");
-const version = "16.2.0";
+const version = "16.2.1";
 let router;
 const emitter = (0, _mitt.default)();
 const looseToArray = (input)=>[].slice.call(input);