maquinaweb-ui 2.67.0 → 2.69.0

package/dist/node_modules/next/dist/server/lib/patch-fetch.js

@@ -1,703 +0,0 @@
-import { __commonJS } from "../../../../../_virtual/rolldown_runtime.js";
-import { require_constants } from "../../lib/constants.js";
-import { require_constants as require_constants$1 } from "./trace/constants.js";
-import { require_tracer } from "./trace/tracer.js";
-import { require_staged_rendering } from "../app-render/staged-rendering.js";
-import { require_work_unit_async_storage_external } from "../app-render/work-unit-async-storage.external.js";
-import { require_dynamic_rendering_utils } from "../dynamic-rendering-utils.js";
-import { require_dynamic_rendering } from "../app-render/dynamic-rendering.js";
-import { require_clone_response } from "./clone-response.js";
-import { require_dedupe_fetch } from "./dedupe-fetch.js";
-import { require_response_cache } from "../response-cache/index.js";
-
-//#region node_modules/next/dist/server/lib/patch-fetch.js
-var require_patch_fetch = /* @__PURE__ */ __commonJS({ "node_modules/next/dist/server/lib/patch-fetch.js": ((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	function _export(target, all) {
-		for (var name in all) Object.defineProperty(target, name, {
-			enumerable: true,
-			get: all[name]
-		});
-	}
-	_export(exports, {
-		NEXT_PATCH_SYMBOL: function() {
-			return NEXT_PATCH_SYMBOL;
-		},
-		createPatchedFetcher: function() {
-			return createPatchedFetcher;
-		},
-		patchFetch: function() {
-			return patchFetch;
-		},
-		validateRevalidate: function() {
-			return validateRevalidate;
-		},
-		validateTags: function() {
-			return validateTags;
-		}
-	});
-	const _constants = require_constants$1();
-	const _tracer = require_tracer();
-	const _constants1 = require_constants();
-	const _dynamicrendering = require_dynamic_rendering();
-	const _dynamicrenderingutils = require_dynamic_rendering_utils();
-	const _dedupefetch = require_dedupe_fetch();
-	const _workunitasyncstorageexternal = require_work_unit_async_storage_external();
-	const _responsecache = require_response_cache();
-	const _cloneresponse = require_clone_response();
-	const _stagedrendering = require_staged_rendering();
-	const isEdgeRuntime = process.env.NEXT_RUNTIME === "edge";
-	const NEXT_PATCH_SYMBOL = Symbol.for("next-patch");
-	function isFetchPatched() {
-		return globalThis[NEXT_PATCH_SYMBOL] === true;
-	}
-	function validateRevalidate(revalidateVal, route) {
-		try {
-			let normalizedRevalidate = void 0;
-			if (revalidateVal === false) normalizedRevalidate = _constants1.INFINITE_CACHE;
-			else if (typeof revalidateVal === "number" && !isNaN(revalidateVal) && revalidateVal > -1) normalizedRevalidate = revalidateVal;
-			else if (typeof revalidateVal !== "undefined") throw Object.defineProperty(/* @__PURE__ */ new Error(`Invalid revalidate value "${revalidateVal}" on "${route}", must be a non-negative number or false`), "__NEXT_ERROR_CODE", {
-				value: "E179",
-				enumerable: false,
-				configurable: true
-			});
-			return normalizedRevalidate;
-		} catch (err) {
-			if (err instanceof Error && err.message.includes("Invalid revalidate")) throw err;
-			return;
-		}
-	}
-	function validateTags(tags, description) {
-		const validTags = [];
-		const invalidTags = [];
-		for (let i = 0; i < tags.length; i++) {
-			const tag = tags[i];
-			if (typeof tag !== "string") invalidTags.push({
-				tag,
-				reason: "invalid type, must be a string"
-			});
-			else if (tag.length > _constants1.NEXT_CACHE_TAG_MAX_LENGTH) invalidTags.push({
-				tag,
-				reason: `exceeded max length of ${_constants1.NEXT_CACHE_TAG_MAX_LENGTH}`
-			});
-			else validTags.push(tag);
-			if (validTags.length > _constants1.NEXT_CACHE_TAG_MAX_ITEMS) {
-				console.warn(`Warning: exceeded max tag count for ${description}, dropped tags:`, tags.slice(i).join(", "));
-				break;
-			}
-		}
-		if (invalidTags.length > 0) {
-			console.warn(`Warning: invalid tags passed to ${description}: `);
-			for (const { tag, reason } of invalidTags) console.log(`tag: "${tag}" ${reason}`);
-		}
-		return validTags;
-	}
-	function trackFetchMetric(workStore, ctx) {
-		if (!workStore.shouldTrackFetchMetrics) return;
-		workStore.fetchMetrics ??= [];
-		workStore.fetchMetrics.push({
-			...ctx,
-			end: performance.timeOrigin + performance.now(),
-			idx: workStore.nextFetchId || 0
-		});
-	}
-	async function createCachedPrerenderResponse(res, cacheKey, incrementalCacheContext, incrementalCache, revalidate, handleUnlock) {
-		const bodyBuffer = await res.arrayBuffer();
-		const fetchedData = {
-			headers: Object.fromEntries(res.headers.entries()),
-			body: Buffer.from(bodyBuffer).toString("base64"),
-			status: res.status,
-			url: res.url
-		};
-		if (incrementalCacheContext) await incrementalCache.set(cacheKey, {
-			kind: _responsecache.CachedRouteKind.FETCH,
-			data: fetchedData,
-			revalidate
-		}, incrementalCacheContext);
-		await handleUnlock();
-		return new Response(bodyBuffer, {
-			headers: res.headers,
-			status: res.status,
-			statusText: res.statusText
-		});
-	}
-	async function createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheContext, incrementalCache, serverComponentsHmrCache, revalidate, input, handleUnlock, signal) {
-		const [cloned1, cloned2] = (0, _cloneresponse.cloneResponse)(res);
-		const cacheSetPromise = cloned1.arrayBuffer().then(async (arrayBuffer) => {
-			const bodyBuffer = Buffer.from(arrayBuffer);
-			const fetchedData = {
-				headers: Object.fromEntries(cloned1.headers.entries()),
-				body: bodyBuffer.toString("base64"),
-				status: cloned1.status,
-				url: cloned1.url
-			};
-			serverComponentsHmrCache?.set(cacheKey, fetchedData);
-			if (incrementalCacheContext) await incrementalCache.set(cacheKey, {
-				kind: _responsecache.CachedRouteKind.FETCH,
-				data: fetchedData,
-				revalidate
-			}, incrementalCacheContext);
-		}).catch((error) => {
-			if (!(signal == null ? void 0 : signal.aborted)) console.warn(`Failed to set fetch cache`, input, error);
-		}).finally(handleUnlock);
-		const pendingRevalidateKey = `cache-set-${cacheKey}`;
-		const pendingRevalidates = workStore.pendingRevalidates ??= {};
-		let pendingRevalidatePromise = Promise.resolve();
-		if (pendingRevalidateKey in pendingRevalidates) pendingRevalidatePromise = pendingRevalidates[pendingRevalidateKey];
-		pendingRevalidates[pendingRevalidateKey] = pendingRevalidatePromise.then(() => cacheSetPromise).finally(() => {
-			if (!(pendingRevalidates == null ? void 0 : pendingRevalidates[pendingRevalidateKey])) return;
-			delete pendingRevalidates[pendingRevalidateKey];
-		});
-		return cloned2;
-	}
-	function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStorage }) {
-		const patched = async function fetch(input, init) {
-			var _init_method, _init_next;
-			let url;
-			try {
-				url = new URL(input instanceof Request ? input.url : input);
-				url.username = "";
-				url.password = "";
-			} catch {
-				url = void 0;
-			}
-			const fetchUrl = (url == null ? void 0 : url.href) ?? "";
-			const method = (init == null ? void 0 : (_init_method = init.method) == null ? void 0 : _init_method.toUpperCase()) || "GET";
-			const isInternal = (init == null ? void 0 : (_init_next = init.next) == null ? void 0 : _init_next.internal) === true;
-			const hideSpan = process.env.NEXT_OTEL_FETCH_DISABLED === "1";
-			const fetchStart = isInternal ? void 0 : performance.timeOrigin + performance.now();
-			const workStore = workAsyncStorage.getStore();
-			const workUnitStore = workUnitAsyncStorage.getStore();
-			let cacheSignal = workUnitStore ? (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore) : null;
-			if (cacheSignal) cacheSignal.beginRead();
-			const result = (0, _tracer.getTracer)().trace(isInternal ? _constants.NextNodeServerSpan.internalFetch : _constants.AppRenderSpan.fetch, {
-				hideSpan,
-				kind: _tracer.SpanKind.CLIENT,
-				spanName: [
-					"fetch",
-					method,
-					fetchUrl
-				].filter(Boolean).join(" "),
-				attributes: {
-					"http.url": fetchUrl,
-					"http.method": method,
-					"net.peer.name": url == null ? void 0 : url.hostname,
-					"net.peer.port": (url == null ? void 0 : url.port) || void 0
-				}
-			}, async () => {
-				var _getRequestMeta;
-				if (isInternal) return originFetch(input, init);
-				if (!workStore) return originFetch(input, init);
-				if (workStore.isDraftMode) return originFetch(input, init);
-				const isRequestInput = input && typeof input === "object" && typeof input.method === "string";
-				const getRequestMeta = (field) => {
-					return (init == null ? void 0 : init[field]) || (isRequestInput ? input[field] : null);
-				};
-				let finalRevalidate = void 0;
-				const getNextField = (field) => {
-					var _init_next$1, _init_next1, _input_next;
-					return typeof (init == null ? void 0 : (_init_next$1 = init.next) == null ? void 0 : _init_next$1[field]) !== "undefined" ? init == null ? void 0 : (_init_next1 = init.next) == null ? void 0 : _init_next1[field] : isRequestInput ? (_input_next = input.next) == null ? void 0 : _input_next[field] : void 0;
-				};
-				const originalFetchRevalidate = getNextField("revalidate");
-				let currentFetchRevalidate = originalFetchRevalidate;
-				const tags = validateTags(getNextField("tags") || [], `fetch ${input.toString()}`);
-				let revalidateStore;
-				if (workUnitStore) switch (workUnitStore.type) {
-					case "prerender":
-					case "prerender-runtime":
-					case "prerender-client":
-					case "validation-client":
-					case "prerender-ppr":
-					case "prerender-legacy":
-					case "cache":
-					case "private-cache":
-						revalidateStore = workUnitStore;
-						break;
-					case "request":
-					case "unstable-cache":
-					case "generate-static-params": break;
-					default:
-				}
-				if (revalidateStore) {
-					if (Array.isArray(tags)) {
-						const collectedTags = revalidateStore.tags ?? (revalidateStore.tags = []);
-						for (const tag of tags) if (!collectedTags.includes(tag)) collectedTags.push(tag);
-					}
-				}
-				const implicitTags = workUnitStore == null ? void 0 : workUnitStore.implicitTags;
-				let pageFetchCacheMode = workStore.fetchCache;
-				if (workUnitStore) switch (workUnitStore.type) {
-					case "unstable-cache":
-						pageFetchCacheMode = "force-no-store";
-						break;
-					case "prerender":
-					case "prerender-client":
-					case "validation-client":
-					case "prerender-runtime":
-					case "prerender-ppr":
-					case "prerender-legacy":
-					case "request":
-					case "cache":
-					case "private-cache":
-					case "generate-static-params": break;
-					default:
-				}
-				const isUsingNoStore = !!workStore.isUnstableNoStore;
-				let currentFetchCacheConfig = getRequestMeta("cache");
-				let cacheReason = "";
-				let cacheWarning;
-				if (typeof currentFetchCacheConfig === "string" && typeof currentFetchRevalidate !== "undefined") {
-					if (currentFetchCacheConfig === "force-cache" && currentFetchRevalidate === 0 || currentFetchCacheConfig === "no-store" && (currentFetchRevalidate > 0 || currentFetchRevalidate === false)) {
-						cacheWarning = `Specified "cache: ${currentFetchCacheConfig}" and "revalidate: ${currentFetchRevalidate}", only one should be specified.`;
-						currentFetchCacheConfig = void 0;
-						currentFetchRevalidate = void 0;
-					}
-				}
-				const hasExplicitFetchCacheOptOut = currentFetchCacheConfig === "no-cache" || currentFetchCacheConfig === "no-store" || pageFetchCacheMode === "force-no-store" || pageFetchCacheMode === "only-no-store";
-				const noFetchConfigAndForceDynamic = !pageFetchCacheMode && !currentFetchCacheConfig && !currentFetchRevalidate && workStore.forceDynamic;
-				if (currentFetchCacheConfig === "force-cache" && typeof currentFetchRevalidate === "undefined") currentFetchRevalidate = false;
-				else if (hasExplicitFetchCacheOptOut || noFetchConfigAndForceDynamic) currentFetchRevalidate = 0;
-				if (currentFetchCacheConfig === "no-cache" || currentFetchCacheConfig === "no-store") cacheReason = `cache: ${currentFetchCacheConfig}`;
-				finalRevalidate = validateRevalidate(currentFetchRevalidate, workStore.route);
-				const _headers = getRequestMeta("headers");
-				const initHeaders = typeof (_headers == null ? void 0 : _headers.get) === "function" ? _headers : new Headers(_headers || {});
-				const hasUnCacheableHeader = initHeaders.get("authorization") || initHeaders.get("cookie");
-				const isUnCacheableMethod = !["get", "head"].includes(((_getRequestMeta = getRequestMeta("method")) == null ? void 0 : _getRequestMeta.toLowerCase()) || "get");
-				/**
-				* We automatically disable fetch caching under the following conditions:
-				* - Fetch cache configs are not set. Specifically:
-				*    - A page fetch cache mode is not set (export const fetchCache=...)
-				*    - A fetch cache mode is not set in the fetch call (fetch(url, { cache: ... }))
-				*      or the fetch cache mode is set to 'default'
-				*    - A fetch revalidate value is not set in the fetch call (fetch(url, { revalidate: ... }))
-				* - OR the fetch comes after a configuration that triggered dynamic rendering (e.g., reading cookies())
-				*   and the fetch was considered uncacheable (e.g., POST method or has authorization headers)
-				*/ const hasNoExplicitCacheConfig = pageFetchCacheMode == void 0 && (currentFetchCacheConfig == void 0 || currentFetchCacheConfig === "default") && currentFetchRevalidate == void 0;
-				let autoNoCache = Boolean((hasUnCacheableHeader || isUnCacheableMethod) && (revalidateStore == null ? void 0 : revalidateStore.revalidate) === 0);
-				let isImplicitBuildTimeCache = false;
-				if (!autoNoCache && hasNoExplicitCacheConfig) if (workStore.isBuildTimePrerendering) isImplicitBuildTimeCache = true;
-				else autoNoCache = true;
-				if (hasNoExplicitCacheConfig && workUnitStore !== void 0) switch (workUnitStore.type) {
-					case "prerender":
-					case "prerender-runtime":
-					case "prerender-client":
-						if (cacheSignal) {
-							cacheSignal.endRead();
-							cacheSignal = null;
-						}
-						return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, "fetch()");
-					case "validation-client": break;
-					case "request":
-						if (process.env.NODE_ENV === "development" && workUnitStore.stagedRendering) {
-							if (cacheSignal) {
-								cacheSignal.endRead();
-								cacheSignal = null;
-							}
-							await workUnitStore.stagedRendering.waitForStage(_stagedrendering.RenderStage.Dynamic);
-						}
-						break;
-					case "prerender-ppr":
-					case "prerender-legacy":
-					case "cache":
-					case "private-cache":
-					case "unstable-cache":
-					case "generate-static-params": break;
-					default:
-				}
-				switch (pageFetchCacheMode) {
-					case "force-no-store":
-						cacheReason = "fetchCache = force-no-store";
-						break;
-					case "only-no-store":
-						if (currentFetchCacheConfig === "force-cache" || typeof finalRevalidate !== "undefined" && finalRevalidate > 0) throw Object.defineProperty(/* @__PURE__ */ new Error(`cache: 'force-cache' used on fetch for ${fetchUrl} with 'export const fetchCache = 'only-no-store'`), "__NEXT_ERROR_CODE", {
-							value: "E448",
-							enumerable: false,
-							configurable: true
-						});
-						cacheReason = "fetchCache = only-no-store";
-						break;
-					case "only-cache":
-						if (currentFetchCacheConfig === "no-store") throw Object.defineProperty(/* @__PURE__ */ new Error(`cache: 'no-store' used on fetch for ${fetchUrl} with 'export const fetchCache = 'only-cache'`), "__NEXT_ERROR_CODE", {
-							value: "E521",
-							enumerable: false,
-							configurable: true
-						});
-						break;
-					case "force-cache":
-						if (typeof currentFetchRevalidate === "undefined" || currentFetchRevalidate === 0) {
-							cacheReason = "fetchCache = force-cache";
-							finalRevalidate = _constants1.INFINITE_CACHE;
-						}
-						break;
-					case "default-cache":
-					case "default-no-store":
-					case "auto":
-					case void 0: break;
-					default:
-				}
-				if (typeof finalRevalidate === "undefined") if (pageFetchCacheMode === "default-cache" && !isUsingNoStore) {
-					finalRevalidate = _constants1.INFINITE_CACHE;
-					cacheReason = "fetchCache = default-cache";
-				} else if (pageFetchCacheMode === "default-no-store") {
-					finalRevalidate = 0;
-					cacheReason = "fetchCache = default-no-store";
-				} else if (isUsingNoStore) {
-					finalRevalidate = 0;
-					cacheReason = "noStore call";
-				} else if (autoNoCache) {
-					finalRevalidate = 0;
-					cacheReason = "auto no cache";
-				} else {
-					cacheReason = "auto cache";
-					finalRevalidate = revalidateStore ? revalidateStore.revalidate : _constants1.INFINITE_CACHE;
-				}
-				else if (!cacheReason) cacheReason = `revalidate: ${finalRevalidate}`;
-				if (!(workStore.forceStatic && finalRevalidate === 0) && !autoNoCache && revalidateStore && finalRevalidate < revalidateStore.revalidate) {
-					if (finalRevalidate === 0) {
-						if (workUnitStore) switch (workUnitStore.type) {
-							case "prerender":
-							case "prerender-client":
-							case "prerender-runtime":
-							case "validation-client":
-								if (cacheSignal) {
-									cacheSignal.endRead();
-									cacheSignal = null;
-								}
-								return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, "fetch()");
-							case "request":
-								if (process.env.NODE_ENV === "development" && workUnitStore.stagedRendering) {
-									if (cacheSignal) {
-										cacheSignal.endRead();
-										cacheSignal = null;
-									}
-									await workUnitStore.stagedRendering.waitForStage(_stagedrendering.RenderStage.Dynamic);
-								}
-								break;
-							case "prerender-ppr":
-							case "prerender-legacy":
-							case "cache":
-							case "private-cache":
-							case "unstable-cache":
-							case "generate-static-params": break;
-							default:
-						}
-						(0, _dynamicrendering.markCurrentScopeAsDynamic)(workStore, workUnitStore, `revalidate: 0 fetch ${input} ${workStore.route}`);
-					}
-					if (revalidateStore && originalFetchRevalidate === finalRevalidate) revalidateStore.revalidate = finalRevalidate;
-				}
-				const isCacheableRevalidate = typeof finalRevalidate === "number" && finalRevalidate > 0;
-				let cacheKey;
-				const { incrementalCache } = workStore;
-				let isHmrRefresh = false;
-				let serverComponentsHmrCache;
-				if (workUnitStore) switch (workUnitStore.type) {
-					case "request":
-					case "cache":
-					case "private-cache":
-						isHmrRefresh = workUnitStore.isHmrRefresh ?? false;
-						serverComponentsHmrCache = workUnitStore.serverComponentsHmrCache;
-						break;
-					case "prerender":
-					case "prerender-client":
-					case "validation-client":
-					case "prerender-runtime":
-					case "prerender-ppr":
-					case "prerender-legacy":
-					case "unstable-cache":
-					case "generate-static-params": break;
-					default:
-				}
-				if (incrementalCache && (isCacheableRevalidate || serverComponentsHmrCache)) try {
-					cacheKey = await incrementalCache.generateCacheKey(fetchUrl, isRequestInput ? input : init);
-				} catch (err) {
-					console.error(`Failed to generate cache key for`, input);
-				}
-				const fetchIdx = workStore.nextFetchId ?? 1;
-				workStore.nextFetchId = fetchIdx + 1;
-				let handleUnlock = () => {};
-				const doOriginalFetch = async (isStale, cacheReasonOverride$1) => {
-					const requestInputFields = [
-						"cache",
-						"credentials",
-						"headers",
-						"integrity",
-						"keepalive",
-						"method",
-						"mode",
-						"redirect",
-						"referrer",
-						"referrerPolicy",
-						"window",
-						"duplex",
-						...isStale ? [] : ["signal"]
-					];
-					if (isRequestInput) {
-						const reqInput = input;
-						const reqOptions = { body: reqInput._ogBody || reqInput.body };
-						for (const field of requestInputFields) reqOptions[field] = reqInput[field];
-						input = new Request(reqInput.url, reqOptions);
-					} else if (init) {
-						const { _ogBody, body, signal,...otherInput } = init;
-						init = {
-							...otherInput,
-							body: _ogBody || body,
-							signal: isStale ? void 0 : signal
-						};
-					}
-					const clonedInit = {
-						...init,
-						next: {
-							...init == null ? void 0 : init.next,
-							fetchType: "origin",
-							fetchIdx
-						}
-					};
-					return originFetch(input, clonedInit).then(async (res) => {
-						if (!isStale && fetchStart) trackFetchMetric(workStore, {
-							start: fetchStart,
-							url: fetchUrl,
-							cacheReason: cacheReasonOverride$1 || cacheReason,
-							cacheStatus: finalRevalidate === 0 || cacheReasonOverride$1 ? "skip" : "miss",
-							cacheWarning,
-							status: res.status,
-							method: clonedInit.method || "GET"
-						});
-						if (res.status === 200 && incrementalCache && cacheKey && (isCacheableRevalidate || serverComponentsHmrCache)) {
-							const normalizedRevalidate = finalRevalidate >= _constants1.INFINITE_CACHE ? _constants1.CACHE_ONE_YEAR_SECONDS : finalRevalidate;
-							const incrementalCacheConfig = isCacheableRevalidate ? {
-								fetchCache: true,
-								fetchUrl,
-								fetchIdx,
-								tags,
-								isImplicitBuildTimeCache
-							} : void 0;
-							switch (workUnitStore == null ? void 0 : workUnitStore.type) {
-								case "prerender":
-								case "prerender-client":
-								case "validation-client":
-								case "prerender-runtime": return createCachedPrerenderResponse(res, cacheKey, incrementalCacheConfig, incrementalCache, normalizedRevalidate, handleUnlock);
-								case "request": if (process.env.NODE_ENV === "development" && workUnitStore.stagedRendering && workUnitStore.cacheSignal && isCacheableRevalidate) return createCachedPrerenderResponse(res, cacheKey, incrementalCacheConfig, incrementalCache, normalizedRevalidate, handleUnlock);
-								case "prerender-ppr":
-								case "prerender-legacy":
-								case "cache":
-								case "private-cache":
-								case "unstable-cache":
-								case "generate-static-params":
-								case void 0: return createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheConfig, incrementalCache, serverComponentsHmrCache, normalizedRevalidate, input, handleUnlock, getRequestMeta("signal"));
-								default:
-							}
-						}
-						await handleUnlock();
-						return res;
-					}).catch((error) => {
-						handleUnlock();
-						throw error;
-					});
-				};
-				let cacheReasonOverride;
-				let isForegroundRevalidate = false;
-				let isHmrRefreshCache = false;
-				if (cacheKey && incrementalCache) {
-					let cachedFetchData;
-					if (isHmrRefresh && serverComponentsHmrCache) {
-						cachedFetchData = serverComponentsHmrCache.get(cacheKey);
-						isHmrRefreshCache = true;
-					}
-					if (isCacheableRevalidate && !cachedFetchData) {
-						handleUnlock = await incrementalCache.lock(cacheKey);
-						const entry = workStore.isOnDemandRevalidate ? null : await incrementalCache.get(cacheKey, {
-							kind: _responsecache.IncrementalCacheKind.FETCH,
-							revalidate: finalRevalidate,
-							fetchUrl,
-							fetchIdx,
-							tags,
-							softTags: implicitTags == null ? void 0 : implicitTags.tags
-						});
-						if (hasNoExplicitCacheConfig && workUnitStore) switch (workUnitStore.type) {
-							case "prerender":
-							case "prerender-client":
-							case "validation-client":
-							case "prerender-runtime":
-								await getTimeoutBoundary();
-								break;
-							case "request":
-								if (process.env.NODE_ENV === "development" && workUnitStore.stagedRendering) await workUnitStore.stagedRendering.waitForStage(_stagedrendering.RenderStage.Dynamic);
-								break;
-							case "prerender-ppr":
-							case "prerender-legacy":
-							case "cache":
-							case "private-cache":
-							case "unstable-cache":
-							case "generate-static-params": break;
-							default:
-						}
-						if (entry) await handleUnlock();
-						else cacheReasonOverride = "cache-control: no-cache (hard refresh)";
-						if ((entry == null ? void 0 : entry.value) && entry.value.kind === _responsecache.CachedRouteKind.FETCH) if (workStore.isStaticGeneration && entry.isStale) isForegroundRevalidate = true;
-						else {
-							if (entry.isStale) {
-								workStore.pendingRevalidates ??= {};
-								if (!workStore.pendingRevalidates[cacheKey]) {
-									const pendingRevalidate = doOriginalFetch(true).then(async (response) => ({
-										body: await response.arrayBuffer(),
-										headers: response.headers,
-										status: response.status,
-										statusText: response.statusText
-									})).finally(() => {
-										workStore.pendingRevalidates ??= {};
-										delete workStore.pendingRevalidates[cacheKey || ""];
-									});
-									pendingRevalidate.catch(console.error);
-									workStore.pendingRevalidates[cacheKey] = pendingRevalidate;
-								}
-							}
-							cachedFetchData = entry.value.data;
-						}
-					}
-					if (cachedFetchData) {
-						if (fetchStart) trackFetchMetric(workStore, {
-							start: fetchStart,
-							url: fetchUrl,
-							cacheReason,
-							cacheStatus: isHmrRefreshCache ? "hmr" : "hit",
-							cacheWarning,
-							status: cachedFetchData.status || 200,
-							method: (init == null ? void 0 : init.method) || "GET"
-						});
-						const response = new Response(Buffer.from(cachedFetchData.body, "base64"), {
-							headers: cachedFetchData.headers,
-							status: cachedFetchData.status
-						});
-						Object.defineProperty(response, "url", { value: cachedFetchData.url });
-						return response;
-					}
-				}
-				if ((workStore.isStaticGeneration || process.env.NODE_ENV === "development" && process.env.__NEXT_CACHE_COMPONENTS && workUnitStore && workUnitStore.type === "request" && workUnitStore.stagedRendering) && init && typeof init === "object") {
-					const { cache } = init;
-					if (isEdgeRuntime) delete init.cache;
-					if (cache === "no-store") {
-						if (workUnitStore) switch (workUnitStore.type) {
-							case "prerender":
-							case "prerender-client":
-							case "prerender-runtime":
-							case "validation-client":
-								if (cacheSignal) {
-									cacheSignal.endRead();
-									cacheSignal = null;
-								}
-								return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, "fetch()");
-							case "request":
-								if (process.env.NODE_ENV === "development" && workUnitStore.stagedRendering) {
-									if (cacheSignal) {
-										cacheSignal.endRead();
-										cacheSignal = null;
-									}
-									await workUnitStore.stagedRendering.waitForStage(_stagedrendering.RenderStage.Dynamic);
-								}
-								break;
-							case "prerender-ppr":
-							case "prerender-legacy":
-							case "cache":
-							case "private-cache":
-							case "unstable-cache":
-							case "generate-static-params": break;
-							default:
-						}
-						(0, _dynamicrendering.markCurrentScopeAsDynamic)(workStore, workUnitStore, `no-store fetch ${input} ${workStore.route}`);
-					}
-					const hasNextConfig = "next" in init;
-					const { next = {} } = init;
-					if (typeof next.revalidate === "number" && revalidateStore && next.revalidate < revalidateStore.revalidate) {
-						if (next.revalidate === 0) {
-							if (workUnitStore) switch (workUnitStore.type) {
-								case "prerender":
-								case "prerender-client":
-								case "prerender-runtime":
-								case "validation-client": return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, "fetch()");
-								case "request":
-									if (process.env.NODE_ENV === "development" && workUnitStore.stagedRendering) await workUnitStore.stagedRendering.waitForStage(_stagedrendering.RenderStage.Dynamic);
-									break;
-								case "cache":
-								case "private-cache":
-								case "unstable-cache":
-								case "prerender-legacy":
-								case "prerender-ppr":
-								case "generate-static-params": break;
-								default:
-							}
-							(0, _dynamicrendering.markCurrentScopeAsDynamic)(workStore, workUnitStore, `revalidate: 0 fetch ${input} ${workStore.route}`);
-						}
-						if (!workStore.forceStatic || next.revalidate !== 0) revalidateStore.revalidate = next.revalidate;
-					}
-					if (hasNextConfig) delete init.next;
-				}
-				if (cacheKey && isForegroundRevalidate) {
-					const pendingRevalidateKey = cacheKey;
-					workStore.pendingRevalidates ??= {};
-					let pendingRevalidate = workStore.pendingRevalidates[pendingRevalidateKey];
-					if (pendingRevalidate) {
-						const revalidatedResult = await pendingRevalidate;
-						return new Response(revalidatedResult.body, {
-							headers: revalidatedResult.headers,
-							status: revalidatedResult.status,
-							statusText: revalidatedResult.statusText
-						});
-					}
-					const pendingResponse = doOriginalFetch(true, cacheReasonOverride).then(_cloneresponse.cloneResponse);
-					pendingRevalidate = pendingResponse.then(async (responses) => {
-						const response = responses[0];
-						return {
-							body: await response.arrayBuffer(),
-							headers: response.headers,
-							status: response.status,
-							statusText: response.statusText
-						};
-					}).finally(() => {
-						var _workStore_pendingRevalidates;
-						if (!((_workStore_pendingRevalidates = workStore.pendingRevalidates) == null ? void 0 : _workStore_pendingRevalidates[pendingRevalidateKey])) return;
-						delete workStore.pendingRevalidates[pendingRevalidateKey];
-					});
-					pendingRevalidate.catch(() => {});
-					workStore.pendingRevalidates[pendingRevalidateKey] = pendingRevalidate;
-					return pendingResponse.then((responses) => responses[1]);
-				} else return doOriginalFetch(false, cacheReasonOverride);
-			});
-			if (cacheSignal) try {
-				return await result;
-			} finally {
-				if (cacheSignal) cacheSignal.endRead();
-			}
-			return result;
-		};
-		patched.__nextPatched = true;
-		patched.__nextGetStaticStore = () => workAsyncStorage;
-		patched._nextOriginalFetch = originFetch;
-		globalThis[NEXT_PATCH_SYMBOL] = true;
-		Object.defineProperty(patched, "name", {
-			value: "fetch",
-			writable: false
-		});
-		return patched;
-	}
-	function patchFetch(options) {
-		if (isFetchPatched()) return;
-		const original = (0, _dedupefetch.createDedupeFetch)(globalThis.fetch);
-		globalThis.fetch = createPatchedFetcher(original, options);
-	}
-	let currentTimeoutBoundary = null;
-	function getTimeoutBoundary() {
-		if (!currentTimeoutBoundary) currentTimeoutBoundary = new Promise((r) => {
-			setTimeout(() => {
-				currentTimeoutBoundary = null;
-				r();
-			}, 0);
-		});
-		return currentTimeoutBoundary;
-	}
-}) });
-
-//#endregion
-export default require_patch_fetch();
-
-export { require_patch_fetch };
-//# sourceMappingURL=patch-fetch.js.map