react-easy-wall 1.0.5 → 1.0.6

package/dist/cjs/node_modules/next/dist/server/app-render/after-task-async-storage-instance.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var afterTaskAsyncStorageInstance = require('../../../../../_virtual/after-task-async-storage-instance.js');
+var asyncLocalStorage = require('./async-local-storage.js');
+
+var hasRequiredAfterTaskAsyncStorageInstance;
+
+function requireAfterTaskAsyncStorageInstance () {
+	if (hasRequiredAfterTaskAsyncStorageInstance) return afterTaskAsyncStorageInstance.__exports;
+	hasRequiredAfterTaskAsyncStorageInstance = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports$1, "afterTaskAsyncStorageInstance", {
+		    enumerable: true,
+		    get: function() {
+		        return afterTaskAsyncStorageInstance;
+		    }
+		});
+		const _asynclocalstorage = asyncLocalStorage.__require();
+		const afterTaskAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+
+		
+	} (afterTaskAsyncStorageInstance.__exports));
+	return afterTaskAsyncStorageInstance.__exports;
+}
+
+exports.__require = requireAfterTaskAsyncStorageInstance;
+//# sourceMappingURL=after-task-async-storage-instance.js.map

package/dist/cjs/node_modules/next/dist/server/app-render/after-task-async-storage-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"after-task-async-storage-instance.js","sources":["../../../../../../../node_modules/next/dist/server/app-render/after-task-async-storage-instance.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nObject.defineProperty(exports, \"afterTaskAsyncStorageInstance\", {\n    enumerable: true,\n    get: function() {\n        return afterTaskAsyncStorageInstance;\n    }\n});\nconst _asynclocalstorage = require(\"./async-local-storage\");\nconst afterTaskAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();\n\n//# sourceMappingURL=after-task-async-storage-instance.js.map"],"names":["exports","require$$0"],"mappings":";;;;;;;;;;;AACA,EAAA,MAAM,CAAC,cAAc,CAAAA,SAAA,EAAU,YAAY,EAAE;AAC7C,MAAI,KAAK,EAAE;AACX,GAAC,CAAC;AACF,EAAA,MAAM,CAAC,cAAc,CAACA,SAAO,EAAE,+BAA+B,EAAE;MAC5D,UAAU,EAAE,IAAI;MAChB,GAAG,EAAE,WAAW;AACpB,UAAQ,OAAO,6BAA6B;AAC5C,MAAA;AACA,GAAC,CAAC;EACF,MAAM,kBAAkB,GAAGC,2BAAA,EAAgC;EAC3D,MAAM,6BAA6B,GAAG,IAAI,kBAAkB,CAAC,uBAAuB,GAAG;;AAEvF;;;;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/next/dist/server/app-render/after-task-async-storage.external.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var afterTaskAsyncStorage_external = require('../../../../../_virtual/after-task-async-storage.external.js');
+var afterTaskAsyncStorageInstance = require('./after-task-async-storage-instance.js');
+
+var hasRequiredAfterTaskAsyncStorage_external;
+
+function requireAfterTaskAsyncStorage_external () {
+	if (hasRequiredAfterTaskAsyncStorage_external) return afterTaskAsyncStorage_external.__exports;
+	hasRequiredAfterTaskAsyncStorage_external = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports$1, "afterTaskAsyncStorage", {
+		    enumerable: true,
+		    get: function() {
+		        return _aftertaskasyncstorageinstance.afterTaskAsyncStorageInstance;
+		    }
+		});
+		const _aftertaskasyncstorageinstance = afterTaskAsyncStorageInstance.__require();
+
+		
+	} (afterTaskAsyncStorage_external.__exports));
+	return afterTaskAsyncStorage_external.__exports;
+}
+
+exports.__require = requireAfterTaskAsyncStorage_external;
+//# sourceMappingURL=after-task-async-storage.external.js.map

package/dist/cjs/node_modules/next/dist/server/app-render/after-task-async-storage.external.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"after-task-async-storage.external.js","sources":["../../../../../../../node_modules/next/dist/server/app-render/after-task-async-storage.external.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nObject.defineProperty(exports, \"afterTaskAsyncStorage\", {\n    enumerable: true,\n    get: function() {\n        return _aftertaskasyncstorageinstance.afterTaskAsyncStorageInstance;\n    }\n});\nconst _aftertaskasyncstorageinstance = require(\"./after-task-async-storage-instance\");\n\n//# sourceMappingURL=after-task-async-storage.external.js.map"],"names":["exports","require$$0"],"mappings":";;;;;;;;;;;AACA,EAAA,MAAM,CAAC,cAAc,CAAAA,SAAA,EAAU,YAAY,EAAE;AAC7C,MAAI,KAAK,EAAE;AACX,GAAC,CAAC;AACF,EAAA,MAAM,CAAC,cAAc,CAACA,SAAO,EAAE,uBAAuB,EAAE;MACpD,UAAU,EAAE,IAAI;MAChB,GAAG,EAAE,WAAW;UACZ,OAAO,8BAA8B,CAAC,6BAA6B;AAC3E,MAAA;AACA,GAAC,CAAC;EACF,MAAM,8BAA8B,GAAGC,uCAAA,EAA8C;;AAErF;;;;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js

@@ -0,0 +1,112 @@
+'use strict';
+
+var createDedupedByCallsiteServerErrorLogger = require('../../../../_virtual/create-deduped-by-callsite-server-error-logger.js');
+var React = require('react');
+
+var hasRequiredCreateDedupedByCallsiteServerErrorLogger;
+
+function requireCreateDedupedByCallsiteServerErrorLogger () {
+	if (hasRequiredCreateDedupedByCallsiteServerErrorLogger) return createDedupedByCallsiteServerErrorLogger.__exports;
+	hasRequiredCreateDedupedByCallsiteServerErrorLogger = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports$1, "createDedupedByCallsiteServerErrorLoggerDev", {
+		    enumerable: true,
+		    get: function() {
+		        return createDedupedByCallsiteServerErrorLoggerDev;
+		    }
+		});
+		const _react = /*#__PURE__*/ _interop_require_wildcard(React);
+		function _getRequireWildcardCache(nodeInterop) {
+		    if (typeof WeakMap !== "function") return null;
+		    var cacheBabelInterop = new WeakMap();
+		    var cacheNodeInterop = new WeakMap();
+		    return (_getRequireWildcardCache = function(nodeInterop) {
+		        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+		    })(nodeInterop);
+		}
+		function _interop_require_wildcard(obj, nodeInterop) {
+		    if (obj && obj.__esModule) {
+		        return obj;
+		    }
+		    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+		        return {
+		            default: obj
+		        };
+		    }
+		    var cache = _getRequireWildcardCache(nodeInterop);
+		    if (cache && cache.has(obj)) {
+		        return cache.get(obj);
+		    }
+		    var newObj = {
+		        __proto__: null
+		    };
+		    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+		    for(var key in obj){
+		        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+		            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+		            if (desc && (desc.get || desc.set)) {
+		                Object.defineProperty(newObj, key, desc);
+		            } else {
+		                newObj[key] = obj[key];
+		            }
+		        }
+		    }
+		    newObj.default = obj;
+		    if (cache) {
+		        cache.set(obj, newObj);
+		    }
+		    return newObj;
+		}
+		const errorRef = {
+		    current: null
+		};
+		// React.cache is currently only available in canary/experimental React channels.
+		const cache = typeof _react.cache === 'function' ? _react.cache : (fn)=>fn;
+		// When Cache Components is enabled, we record these as errors so that they
+		// are captured by the dev overlay as it's more critical to fix these
+		// when enabled.
+		const logErrorOrWarn = process.env.__NEXT_CACHE_COMPONENTS ? console.error : console.warn;
+		// We don't want to dedupe across requests.
+		// The developer might've just attempted to fix the warning so we should warn again if it still happens.
+		const flushCurrentErrorIfNew = cache(// eslint-disable-next-line @typescript-eslint/no-unused-vars -- cache key
+		(key)=>{
+		    try {
+		        logErrorOrWarn(errorRef.current);
+		    } finally{
+		        errorRef.current = null;
+		    }
+		});
+		function createDedupedByCallsiteServerErrorLoggerDev(getMessage) {
+		    return function logDedupedError(...args) {
+		        const message = getMessage(...args);
+		        if (process.env.NODE_ENV !== 'production') {
+		            var _stack;
+		            const callStackFrames = (_stack = new Error().stack) == null ? void 0 : _stack.split('\n');
+		            if (callStackFrames === undefined || callStackFrames.length < 4) {
+		                logErrorOrWarn(message);
+		            } else {
+		                // Error:
+		                //   logDedupedError
+		                //   asyncApiBeingAccessedSynchronously
+		                //   <userland callsite>
+		                // TODO: This breaks if sourcemaps with ignore lists are enabled.
+		                const key = callStackFrames[4];
+		                errorRef.current = message;
+		                flushCurrentErrorIfNew(key);
+		            }
+		        } else {
+		            logErrorOrWarn(message);
+		        }
+		    };
+		}
+
+		
+	} (createDedupedByCallsiteServerErrorLogger.__exports));
+	return createDedupedByCallsiteServerErrorLogger.__exports;
+}
+
+exports.__require = requireCreateDedupedByCallsiteServerErrorLogger;
+//# sourceMappingURL=create-deduped-by-callsite-server-error-logger.js.map

package/dist/cjs/node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-deduped-by-callsite-server-error-logger.js","sources":["../../../../../../node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nObject.defineProperty(exports, \"createDedupedByCallsiteServerErrorLoggerDev\", {\n    enumerable: true,\n    get: function() {\n        return createDedupedByCallsiteServerErrorLoggerDev;\n    }\n});\nconst _react = /*#__PURE__*/ _interop_require_wildcard(require(\"react\"));\nfunction _getRequireWildcardCache(nodeInterop) {\n    if (typeof WeakMap !== \"function\") return null;\n    var cacheBabelInterop = new WeakMap();\n    var cacheNodeInterop = new WeakMap();\n    return (_getRequireWildcardCache = function(nodeInterop) {\n        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;\n    })(nodeInterop);\n}\nfunction _interop_require_wildcard(obj, nodeInterop) {\n    if (!nodeInterop && obj && obj.__esModule) {\n        return obj;\n    }\n    if (obj === null || typeof obj !== \"object\" && typeof obj !== \"function\") {\n        return {\n            default: obj\n        };\n    }\n    var cache = _getRequireWildcardCache(nodeInterop);\n    if (cache && cache.has(obj)) {\n        return cache.get(obj);\n    }\n    var newObj = {\n        __proto__: null\n    };\n    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;\n    for(var key in obj){\n        if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) {\n            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;\n            if (desc && (desc.get || desc.set)) {\n                Object.defineProperty(newObj, key, desc);\n            } else {\n                newObj[key] = obj[key];\n            }\n        }\n    }\n    newObj.default = obj;\n    if (cache) {\n        cache.set(obj, newObj);\n    }\n    return newObj;\n}\nconst errorRef = {\n    current: null\n};\n// React.cache is currently only available in canary/experimental React channels.\nconst cache = typeof _react.cache === 'function' ? _react.cache : (fn)=>fn;\n// When Cache Components is enabled, we record these as errors so that they\n// are captured by the dev overlay as it's more critical to fix these\n// when enabled.\nconst logErrorOrWarn = process.env.__NEXT_CACHE_COMPONENTS ? console.error : console.warn;\n// We don't want to dedupe across requests.\n// The developer might've just attempted to fix the warning so we should warn again if it still happens.\nconst flushCurrentErrorIfNew = cache(// eslint-disable-next-line @typescript-eslint/no-unused-vars -- cache key\n(key)=>{\n    try {\n        logErrorOrWarn(errorRef.current);\n    } finally{\n        errorRef.current = null;\n    }\n});\nfunction createDedupedByCallsiteServerErrorLoggerDev(getMessage) {\n    return function logDedupedError(...args) {\n        const message = getMessage(...args);\n        if (process.env.NODE_ENV !== 'production') {\n            var _stack;\n            const callStackFrames = (_stack = new Error().stack) == null ? void 0 : _stack.split('\\n');\n            if (callStackFrames === undefined || callStackFrames.length < 4) {\n                logErrorOrWarn(message);\n            } else {\n                // Error:\n                //   logDedupedError\n                //   asyncApiBeingAccessedSynchronously\n                //   <userland callsite>\n                // TODO: This breaks if sourcemaps with ignore lists are enabled.\n                const key = callStackFrames[4];\n                errorRef.current = message;\n                flushCurrentErrorIfNew(key);\n            }\n        } else {\n            logErrorOrWarn(message);\n        }\n    };\n}\n\n//# sourceMappingURL=create-deduped-by-callsite-server-error-logger.js.map"],"names":["exports","require$$0"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/next/dist/server/request/cookies.js

@@ -0,0 +1,415 @@
+'use strict';
+
+var cookies = require('../../../../../_virtual/cookies.js');
+var requestCookies = require('../web/spec-extension/adapters/request-cookies.js');
+var cookies$1 = require('../web/spec-extension/cookies.js');
+var workAsyncStorage_external = require('../app-render/work-async-storage.external.js');
+var workUnitAsyncStorage_external = require('../app-render/work-unit-async-storage.external.js');
+var dynamicRendering = require('../app-render/dynamic-rendering.js');
+var staticGenerationBailout = require('../../client/components/static-generation-bailout.js');
+var dynamicRenderingUtils = require('../dynamic-rendering-utils.js');
+var createDedupedByCallsiteServerErrorLogger = require('../create-deduped-by-callsite-server-error-logger.js');
+var utils = require('./utils.js');
+var invariantError = require('../../shared/lib/invariant-error.js');
+var reflect = require('../web/spec-extension/adapters/reflect.js');
+
+var hasRequiredCookies;
+
+function requireCookies () {
+	if (hasRequiredCookies) return cookies.__exports;
+	hasRequiredCookies = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports$1, "cookies", {
+		    enumerable: true,
+		    get: function() {
+		        return cookies;
+		    }
+		});
+		const _requestcookies = requestCookies.__require();
+		const _cookies = cookies$1.__require();
+		const _workasyncstorageexternal = workAsyncStorage_external.__require();
+		const _workunitasyncstorageexternal = workUnitAsyncStorage_external.__require();
+		const _dynamicrendering = dynamicRendering.__require();
+		const _staticgenerationbailout = staticGenerationBailout.__require();
+		const _dynamicrenderingutils = dynamicRenderingUtils.__require();
+		const _creatededupedbycallsiteservererrorlogger = createDedupedByCallsiteServerErrorLogger.__require();
+		const _utils = utils.__require();
+		const _invarianterror = invariantError.__require();
+		const _reflect = reflect.__require();
+		function cookies() {
+		    const callingExpression = 'cookies';
+		    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+		    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+		    if (workStore) {
+		        if (workUnitStore && workUnitStore.phase === 'after' && !(0, _utils.isRequestAPICallableInsideAfter)()) {
+		            throw Object.defineProperty(new Error(// TODO(after): clarify that this only applies to pages?
+		            `Route ${workStore.route} used "cookies" inside "after(...)". This is not supported. If you need this data inside an "after" callback, use "cookies" outside of the callback. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
+		                value: "E88",
+		                enumerable: false,
+		                configurable: true
+		            });
+		        }
+		        if (workStore.forceStatic) {
+		            // When using forceStatic we override all other logic and always just return an empty
+		            // cookies object without tracking
+		            const underlyingCookies = createEmptyCookies();
+		            return makeUntrackedExoticCookies(underlyingCookies);
+		        }
+		        if (workStore.dynamicShouldError) {
+		            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`cookies\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+		                value: "E549",
+		                enumerable: false,
+		                configurable: true
+		            });
+		        }
+		        if (workUnitStore) {
+		            switch(workUnitStore.type){
+		                case 'cache':
+		                    const error = Object.defineProperty(new Error(`Route ${workStore.route} used "cookies" inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "cookies" outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+		                        value: "E398",
+		                        enumerable: false,
+		                        configurable: true
+		                    });
+		                    Error.captureStackTrace(error, cookies);
+		                    workStore.invalidDynamicUsageError ??= error;
+		                    throw error;
+		                case 'unstable-cache':
+		                    throw Object.defineProperty(new Error(`Route ${workStore.route} used "cookies" inside a function cached with "unstable_cache(...)". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "cookies" outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
+		                        value: "E157",
+		                        enumerable: false,
+		                        configurable: true
+		                    });
+		                case 'prerender':
+		                    return makeHangingCookies(workStore, workUnitStore);
+		                case 'prerender-client':
+		                    const exportName = '`cookies`';
+		                    throw Object.defineProperty(new _invarianterror.InvariantError(`${exportName} must not be used within a client component. Next.js should be preventing ${exportName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+		                        value: "E693",
+		                        enumerable: false,
+		                        configurable: true
+		                    });
+		                case 'prerender-ppr':
+		                    // We need track dynamic access here eagerly to keep continuity with
+		                    // how cookies has worked in PPR without cacheComponents.
+		                    return (0, _dynamicrendering.postponeWithTracking)(workStore.route, callingExpression, workUnitStore.dynamicTracking);
+		                case 'prerender-legacy':
+		                    // We track dynamic access here so we don't need to wrap the cookies
+		                    // in individual property access tracking.
+		                    return (0, _dynamicrendering.throwToInterruptStaticGeneration)(callingExpression, workStore, workUnitStore);
+		                case 'prerender-runtime':
+		                    return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedCookies(workUnitStore.cookies));
+		                case 'private-cache':
+		                    if (process.env.__NEXT_CACHE_COMPONENTS) {
+		                        return makeUntrackedCookies(workUnitStore.cookies);
+		                    }
+		                    return makeUntrackedExoticCookies(workUnitStore.cookies);
+		                case 'request':
+		                    (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
+		                    let underlyingCookies;
+		                    if ((0, _requestcookies.areCookiesMutableInCurrentPhase)(workUnitStore)) {
+		                        // We can't conditionally return different types here based on the context.
+		                        // To avoid confusion, we always return the readonly type here.
+		                        underlyingCookies = workUnitStore.userspaceMutableCookies;
+		                    } else {
+		                        underlyingCookies = workUnitStore.cookies;
+		                    }
+		                    if (process.env.NODE_ENV === 'development') {
+		                        // Semantically we only need the dev tracking when running in `next dev`
+		                        // but since you would never use next dev with production NODE_ENV we use this
+		                        // as a proxy so we can statically exclude this code from production builds.
+		                        if (process.env.__NEXT_CACHE_COMPONENTS) {
+		                            return makeUntrackedCookiesWithDevWarnings(underlyingCookies, workStore == null ? void 0 : workStore.route);
+		                        }
+		                        return makeUntrackedExoticCookiesWithDevWarnings(underlyingCookies, workStore == null ? void 0 : workStore.route);
+		                    } else {
+		                        if (process.env.__NEXT_CACHE_COMPONENTS) {
+		                            return makeUntrackedCookies(underlyingCookies);
+		                        }
+		                        return makeUntrackedExoticCookies(underlyingCookies);
+		                    }
+		            }
+		        }
+		    }
+		    // If we end up here, there was no work store or work unit store present.
+		    (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
+		}
+		function createEmptyCookies() {
+		    return _requestcookies.RequestCookiesAdapter.seal(new _cookies.RequestCookies(new Headers({})));
+		}
+		const CachedCookies = new WeakMap();
+		function makeHangingCookies(workStore, prerenderStore) {
+		    const cachedPromise = CachedCookies.get(prerenderStore);
+		    if (cachedPromise) {
+		        return cachedPromise;
+		    }
+		    const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`cookies()`');
+		    CachedCookies.set(prerenderStore, promise);
+		    return promise;
+		}
+		function makeUntrackedCookies(underlyingCookies) {
+		    const cachedCookies = CachedCookies.get(underlyingCookies);
+		    if (cachedCookies) {
+		        return cachedCookies;
+		    }
+		    const promise = Promise.resolve(underlyingCookies);
+		    CachedCookies.set(underlyingCookies, promise);
+		    return promise;
+		}
+		function makeUntrackedExoticCookies(underlyingCookies) {
+		    const cachedCookies = CachedCookies.get(underlyingCookies);
+		    if (cachedCookies) {
+		        return cachedCookies;
+		    }
+		    const promise = Promise.resolve(underlyingCookies);
+		    CachedCookies.set(underlyingCookies, promise);
+		    Object.defineProperties(promise, {
+		        [Symbol.iterator]: {
+		            value: underlyingCookies[Symbol.iterator] ? underlyingCookies[Symbol.iterator].bind(underlyingCookies) : // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+		            // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+		            // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+		            // has extra properties not available on RequestCookie instances.
+		            polyfilledResponseCookiesIterator.bind(underlyingCookies)
+		        },
+		        size: {
+		            get () {
+		                return underlyingCookies.size;
+		            }
+		        },
+		        get: {
+		            value: underlyingCookies.get.bind(underlyingCookies)
+		        },
+		        getAll: {
+		            value: underlyingCookies.getAll.bind(underlyingCookies)
+		        },
+		        has: {
+		            value: underlyingCookies.has.bind(underlyingCookies)
+		        },
+		        set: {
+		            value: underlyingCookies.set.bind(underlyingCookies)
+		        },
+		        delete: {
+		            value: underlyingCookies.delete.bind(underlyingCookies)
+		        },
+		        clear: {
+		            value: // @ts-expect-error clear is defined in RequestCookies implementation but not in the type
+		            typeof underlyingCookies.clear === 'function' ? underlyingCookies.clear.bind(underlyingCookies) : // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+		            // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+		            // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+		            // has extra properties not available on RequestCookie instances.
+		            polyfilledResponseCookiesClear.bind(underlyingCookies, promise)
+		        },
+		        toString: {
+		            value: underlyingCookies.toString.bind(underlyingCookies)
+		        }
+		    });
+		    return promise;
+		}
+		function makeUntrackedExoticCookiesWithDevWarnings(underlyingCookies, route) {
+		    const cachedCookies = CachedCookies.get(underlyingCookies);
+		    if (cachedCookies) {
+		        return cachedCookies;
+		    }
+		    const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingCookies);
+		    CachedCookies.set(underlyingCookies, promise);
+		    Object.defineProperties(promise, {
+		        [Symbol.iterator]: {
+		            value: function() {
+		                const expression = '`...cookies()` or similar iteration';
+		                syncIODev(route, expression);
+		                return underlyingCookies[Symbol.iterator] ? underlyingCookies[Symbol.iterator].apply(underlyingCookies, arguments) : // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+		                // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+		                // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+		                // has extra properties not available on RequestCookie instances.
+		                polyfilledResponseCookiesIterator.call(underlyingCookies);
+		            },
+		            writable: false
+		        },
+		        size: {
+		            get () {
+		                const expression = '`cookies().size`';
+		                syncIODev(route, expression);
+		                return underlyingCookies.size;
+		            }
+		        },
+		        get: {
+		            value: function get() {
+		                let expression;
+		                if (arguments.length === 0) {
+		                    expression = '`cookies().get()`';
+		                } else {
+		                    expression = `\`cookies().get(${describeNameArg(arguments[0])})\``;
+		                }
+		                syncIODev(route, expression);
+		                return underlyingCookies.get.apply(underlyingCookies, arguments);
+		            },
+		            writable: false
+		        },
+		        getAll: {
+		            value: function getAll() {
+		                let expression;
+		                if (arguments.length === 0) {
+		                    expression = '`cookies().getAll()`';
+		                } else {
+		                    expression = `\`cookies().getAll(${describeNameArg(arguments[0])})\``;
+		                }
+		                syncIODev(route, expression);
+		                return underlyingCookies.getAll.apply(underlyingCookies, arguments);
+		            },
+		            writable: false
+		        },
+		        has: {
+		            value: function get() {
+		                let expression;
+		                if (arguments.length === 0) {
+		                    expression = '`cookies().has()`';
+		                } else {
+		                    expression = `\`cookies().has(${describeNameArg(arguments[0])})\``;
+		                }
+		                syncIODev(route, expression);
+		                return underlyingCookies.has.apply(underlyingCookies, arguments);
+		            },
+		            writable: false
+		        },
+		        set: {
+		            value: function set() {
+		                let expression;
+		                if (arguments.length === 0) {
+		                    expression = '`cookies().set()`';
+		                } else {
+		                    const arg = arguments[0];
+		                    if (arg) {
+		                        expression = `\`cookies().set(${describeNameArg(arg)}, ...)\``;
+		                    } else {
+		                        expression = '`cookies().set(...)`';
+		                    }
+		                }
+		                syncIODev(route, expression);
+		                return underlyingCookies.set.apply(underlyingCookies, arguments);
+		            },
+		            writable: false
+		        },
+		        delete: {
+		            value: function() {
+		                let expression;
+		                if (arguments.length === 0) {
+		                    expression = '`cookies().delete()`';
+		                } else if (arguments.length === 1) {
+		                    expression = `\`cookies().delete(${describeNameArg(arguments[0])})\``;
+		                } else {
+		                    expression = `\`cookies().delete(${describeNameArg(arguments[0])}, ...)\``;
+		                }
+		                syncIODev(route, expression);
+		                return underlyingCookies.delete.apply(underlyingCookies, arguments);
+		            },
+		            writable: false
+		        },
+		        clear: {
+		            value: function clear() {
+		                const expression = '`cookies().clear()`';
+		                syncIODev(route, expression);
+		                // @ts-ignore clear is defined in RequestCookies implementation but not in the type
+		                return typeof underlyingCookies.clear === 'function' ? underlyingCookies.clear.apply(underlyingCookies, arguments) : // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+		                // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+		                // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+		                // has extra properties not available on RequestCookie instances.
+		                polyfilledResponseCookiesClear.call(underlyingCookies, promise);
+		            },
+		            writable: false
+		        },
+		        toString: {
+		            value: function toString() {
+		                const expression = '`cookies().toString()` or implicit casting';
+		                syncIODev(route, expression);
+		                return underlyingCookies.toString.apply(underlyingCookies, arguments);
+		            },
+		            writable: false
+		        }
+		    });
+		    return promise;
+		}
+		// Similar to `makeUntrackedExoticCookiesWithDevWarnings`, but just logging the
+		// sync access without actually defining the cookies properties on the promise.
+		function makeUntrackedCookiesWithDevWarnings(underlyingCookies, route) {
+		    const cachedCookies = CachedCookies.get(underlyingCookies);
+		    if (cachedCookies) {
+		        return cachedCookies;
+		    }
+		    const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingCookies);
+		    const proxiedPromise = new Proxy(promise, {
+		        get (target, prop, receiver) {
+		            switch(prop){
+		                case Symbol.iterator:
+		                    {
+		                        warnForSyncAccess(route, '`...cookies()` or similar iteration');
+		                        break;
+		                    }
+		                case 'size':
+		                case 'get':
+		                case 'getAll':
+		                case 'has':
+		                case 'set':
+		                case 'delete':
+		                case 'clear':
+		                case 'toString':
+		                    {
+		                        warnForSyncAccess(route, `\`cookies().${prop}\``);
+		                        break;
+		                    }
+		            }
+		            return _reflect.ReflectAdapter.get(target, prop, receiver);
+		        }
+		    });
+		    CachedCookies.set(underlyingCookies, proxiedPromise);
+		    return proxiedPromise;
+		}
+		function describeNameArg(arg) {
+		    return typeof arg === 'object' && arg !== null && typeof arg.name === 'string' ? `'${arg.name}'` : typeof arg === 'string' ? `'${arg}'` : '...';
+		}
+		function syncIODev(route, expression) {
+		    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+		    if (workUnitStore) {
+		        switch(workUnitStore.type){
+		            case 'request':
+		                if (workUnitStore.prerenderPhase === true) {
+		                    // When we're rendering dynamically in dev, we need to advance out of
+		                    // the Prerender environment when we read Request data synchronously.
+		                    (0, _dynamicrendering.trackSynchronousRequestDataAccessInDev)(workUnitStore);
+		                }
+		                break;
+		        }
+		    }
+		    // In all cases we warn normally
+		    warnForSyncAccess(route, expression);
+		}
+		const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createCookiesAccessError);
+		function createCookiesAccessError(route, expression) {
+		    const prefix = route ? `Route "${route}" ` : 'This route ';
+		    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`cookies()\` should be awaited before using its value. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+		        value: "E223",
+		        enumerable: false,
+		        configurable: true
+		    });
+		}
+		function polyfilledResponseCookiesIterator() {
+		    return this.getAll().map((c)=>[
+		            c.name,
+		            c
+		        ]).values();
+		}
+		function polyfilledResponseCookiesClear(returnable) {
+		    for (const cookie of this.getAll()){
+		        this.delete(cookie.name);
+		    }
+		    return returnable;
+		}
+
+		
+	} (cookies.__exports));
+	return cookies.__exports;
+}
+
+exports.__require = requireCookies;
+//# sourceMappingURL=cookies.js.map