shieldcortex 3.4.32 → 3.4.33

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/require.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    getMaybePagePath: null,
-    getPagePath: null,
-    requirePage: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getMaybePagePath: function() {
-        return getMaybePagePath;
-    },
-    getPagePath: function() {
-        return getPagePath;
-    },
-    requirePage: function() {
-        return requirePage;
-    }
-});
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _constants = require("../shared/lib/constants");
-const _normalizelocalepath = require("../shared/lib/i18n/normalize-locale-path");
-const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path");
-const _denormalizepagepath = require("../shared/lib/page-path/denormalize-page-path");
-const _utils = require("../shared/lib/utils");
-const _lrucache = require("../server/lib/lru-cache");
-const _loadmanifestexternal = require("./load-manifest.external");
-const _fs = require("fs");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-const isDev = process.env.NODE_ENV === 'development';
-const pagePathCache = !isDev ? new _lrucache.LRUCache(1000) : null;
-function getMaybePagePath(page, distDir, locales, isAppPath) {
-    const cacheKey = `${page}:${distDir}:${locales}:${isAppPath}`;
-    let pagePath = pagePathCache == null ? void 0 : pagePathCache.get(cacheKey);
-    // If we have a cached path, we can return it directly.
-    if (pagePath) return pagePath;
-    const serverBuildPath = _path.default.join(/* turbopackIgnore: true */ distDir, _constants.SERVER_DIRECTORY);
-    let appPathsManifest;
-    if (isAppPath) {
-        appPathsManifest = (0, _loadmanifestexternal.loadManifest)(_path.default.join(/* turbopackIgnore: true */ serverBuildPath, _constants.APP_PATHS_MANIFEST), !isDev);
-    }
-    const pagesManifest = (0, _loadmanifestexternal.loadManifest)(_path.default.join(/* turbopackIgnore: true */ serverBuildPath, _constants.PAGES_MANIFEST), !isDev);
-    try {
-        page = (0, _denormalizepagepath.denormalizePagePath)((0, _normalizepagepath.normalizePagePath)(page));
-    } catch (err) {
-        console.error(err);
-        throw new _utils.PageNotFoundError(page);
-    }
-    const checkManifest = (manifest)=>{
-        let curPath = manifest[page];
-        if (!manifest[curPath] && locales) {
-            const manifestNoLocales = {};
-            for (const key of Object.keys(manifest)){
-                manifestNoLocales[(0, _normalizelocalepath.normalizeLocalePath)(key, locales).pathname] = pagesManifest[key];
-            }
-            curPath = manifestNoLocales[page];
-        }
-        return curPath;
-    };
-    if (appPathsManifest) {
-        pagePath = checkManifest(appPathsManifest);
-    }
-    if (!pagePath) {
-        pagePath = checkManifest(pagesManifest);
-    }
-    if (!pagePath) {
-        pagePathCache == null ? void 0 : pagePathCache.set(cacheKey, null);
-        return null;
-    }
-    // Handle absolute paths (e.g., built-in components)
-    if (_path.default.isAbsolute(pagePath)) {
-        // Use the absolute path as-is
-        pagePathCache == null ? void 0 : pagePathCache.set(cacheKey, pagePath);
-        return pagePath;
-    }
-    pagePath = _path.default.join(/* turbopackIgnore: true */ serverBuildPath, pagePath);
-    pagePathCache == null ? void 0 : pagePathCache.set(cacheKey, pagePath);
-    return pagePath;
-}
-function getPagePath(page, distDir, locales, isAppPath) {
-    const pagePath = getMaybePagePath(page, distDir, locales, isAppPath);
-    if (!pagePath) {
-        throw new _utils.PageNotFoundError(page);
-    }
-    return pagePath;
-}
-async function requirePage(page, distDir, isAppPath) {
-    const pagePath = getPagePath(page, distDir, undefined, isAppPath);
-    if (pagePath.endsWith('.html')) {
-        return _fs.promises.readFile(/* turbopackIgnore: true */ pagePath, 'utf8').catch((err)=>{
-            throw new _utils.MissingStaticPage(page, err.message);
-        });
-    }
-    const mod = process.env.NEXT_MINIMAL ? __non_webpack_require__(pagePath) : require(/* turbopackIgnore: true */ pagePath);
-    return mod;
-}
-
-//# sourceMappingURL=require.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/response-cache/index.js

@@ -1,211 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return ResponseCache;
-    }
-});
-0 && __export(require("./types"));
-const _batcher = require("../../lib/batcher");
-const _scheduler = require("../../lib/scheduler");
-const _utils = require("./utils");
-_export_star(require("./types"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-class ResponseCache {
-    constructor(minimal_mode){
-        this.getBatcher = _batcher.Batcher.create({
-            // Ensure on-demand revalidate doesn't block normal requests, it should be
-            // safe to run an on-demand revalidate for the same key as a normal request.
-            cacheKeyFn: ({ key, isOnDemandRevalidate })=>`${key}-${isOnDemandRevalidate ? '1' : '0'}`,
-            // We wait to do any async work until after we've added our promise to
-            // `pendingResponses` to ensure that any any other calls will reuse the
-            // same promise until we've fully finished our work.
-            schedulerFn: _scheduler.scheduleOnNextTick
-        });
-        this.revalidateBatcher = _batcher.Batcher.create({
-            // We wait to do any async work until after we've added our promise to
-            // `pendingResponses` to ensure that any any other calls will reuse the
-            // same promise until we've fully finished our work.
-            schedulerFn: _scheduler.scheduleOnNextTick
-        });
-        this.minimal_mode = minimal_mode;
-    }
-    /**
-   * Gets the response cache entry for the given key.
-   *
-   * @param key - The key to get the response cache entry for.
-   * @param responseGenerator - The response generator to use to generate the response cache entry.
-   * @param context - The context for the get request.
-   * @returns The response cache entry.
-   */ async get(key, responseGenerator, context) {
-        var _this_previousCacheItem;
-        // If there is no key for the cache, we can't possibly look this up in the
-        // cache so just return the result of the response generator.
-        if (!key) {
-            return responseGenerator({
-                hasResolved: false,
-                previousCacheEntry: null
-            });
-        }
-        // Check minimal mode cache before doing any other work
-        if (this.minimal_mode && ((_this_previousCacheItem = this.previousCacheItem) == null ? void 0 : _this_previousCacheItem.key) === key && this.previousCacheItem.expiresAt > Date.now()) {
-            return (0, _utils.toResponseCacheEntry)(this.previousCacheItem.entry);
-        }
-        const { incrementalCache, isOnDemandRevalidate = false, isFallback = false, isRoutePPREnabled = false, isPrefetch = false, waitUntil, routeKind } = context;
-        const response = await this.getBatcher.batch({
-            key,
-            isOnDemandRevalidate
-        }, ({ resolve })=>{
-            const promise = this.handleGet(key, responseGenerator, {
-                incrementalCache,
-                isOnDemandRevalidate,
-                isFallback,
-                isRoutePPREnabled,
-                isPrefetch,
-                routeKind
-            }, resolve);
-            // We need to ensure background revalidates are passed to waitUntil.
-            if (waitUntil) waitUntil(promise);
-            return promise;
-        });
-        return (0, _utils.toResponseCacheEntry)(response);
-    }
-    /**
-   * Handles the get request for the response cache.
-   *
-   * @param key - The key to get the response cache entry for.
-   * @param responseGenerator - The response generator to use to generate the response cache entry.
-   * @param context - The context for the get request.
-   * @param resolve - The resolve function to use to resolve the response cache entry.
-   * @returns The response cache entry.
-   */ async handleGet(key, responseGenerator, context, resolve) {
-        let previousIncrementalCacheEntry = null;
-        let resolved = false;
-        try {
-            // Get the previous cache entry if not in minimal mode
-            previousIncrementalCacheEntry = !this.minimal_mode ? await context.incrementalCache.get(key, {
-                kind: (0, _utils.routeKindToIncrementalCacheKind)(context.routeKind),
-                isRoutePPREnabled: context.isRoutePPREnabled,
-                isFallback: context.isFallback
-            }) : null;
-            if (previousIncrementalCacheEntry && !context.isOnDemandRevalidate) {
-                resolve(previousIncrementalCacheEntry);
-                resolved = true;
-                if (!previousIncrementalCacheEntry.isStale || context.isPrefetch) {
-                    // The cached value is still valid, so we don't need to update it yet.
-                    return previousIncrementalCacheEntry;
-                }
-            }
-            // Revalidate the cache entry
-            const incrementalResponseCacheEntry = await this.revalidate(key, context.incrementalCache, context.isRoutePPREnabled, context.isFallback, responseGenerator, previousIncrementalCacheEntry, previousIncrementalCacheEntry !== null && !context.isOnDemandRevalidate);
-            // Handle null response
-            if (!incrementalResponseCacheEntry) {
-                // Unset the previous cache item if it was set so we don't use it again.
-                if (this.minimal_mode) this.previousCacheItem = undefined;
-                return null;
-            }
-            // Resolve for on-demand revalidation or if not already resolved
-            if (context.isOnDemandRevalidate && !resolved) {
-                return incrementalResponseCacheEntry;
-            }
-            return incrementalResponseCacheEntry;
-        } catch (err) {
-            // If we've already resolved the cache entry, we can't reject as we
-            // already resolved the cache entry so log the error here.
-            if (resolved) {
-                console.error(err);
-                return null;
-            }
-            throw err;
-        }
-    }
-    /**
-   * Revalidates the cache entry for the given key.
-   *
-   * @param key - The key to revalidate the cache entry for.
-   * @param incrementalCache - The incremental cache to use to revalidate the cache entry.
-   * @param isRoutePPREnabled - Whether the route is PPR enabled.
-   * @param isFallback - Whether the route is a fallback.
-   * @param responseGenerator - The response generator to use to generate the response cache entry.
-   * @param previousIncrementalCacheEntry - The previous cache entry to use to revalidate the cache entry.
-   * @param hasResolved - Whether the response has been resolved.
-   * @returns The revalidated cache entry.
-   */ async revalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved, waitUntil) {
-        return this.revalidateBatcher.batch(key, ()=>{
-            const promise = this.handleRevalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved);
-            // We need to ensure background revalidates are passed to waitUntil.
-            if (waitUntil) waitUntil(promise);
-            return promise;
-        });
-    }
-    async handleRevalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved) {
-        try {
-            // Generate the response cache entry using the response generator.
-            const responseCacheEntry = await responseGenerator({
-                hasResolved,
-                previousCacheEntry: previousIncrementalCacheEntry,
-                isRevalidating: true
-            });
-            if (!responseCacheEntry) {
-                return null;
-            }
-            // Convert the response cache entry to an incremental response cache entry.
-            const incrementalResponseCacheEntry = await (0, _utils.fromResponseCacheEntry)({
-                ...responseCacheEntry,
-                isMiss: !previousIncrementalCacheEntry
-            });
-            // We want to persist the result only if it has a cache control value
-            // defined.
-            if (incrementalResponseCacheEntry.cacheControl) {
-                if (this.minimal_mode) {
-                    this.previousCacheItem = {
-                        key,
-                        entry: incrementalResponseCacheEntry,
-                        expiresAt: Date.now() + 1000
-                    };
-                } else {
-                    await incrementalCache.set(key, incrementalResponseCacheEntry.value, {
-                        cacheControl: incrementalResponseCacheEntry.cacheControl,
-                        isRoutePPREnabled,
-                        isFallback
-                    });
-                }
-            }
-            return incrementalResponseCacheEntry;
-        } catch (err) {
-            // When a path is erroring we automatically re-set the existing cache
-            // with new revalidate and expire times to prevent non-stop retrying.
-            if (previousIncrementalCacheEntry == null ? void 0 : previousIncrementalCacheEntry.cacheControl) {
-                const revalidate = Math.min(Math.max(previousIncrementalCacheEntry.cacheControl.revalidate || 3, 3), 30);
-                const expire = previousIncrementalCacheEntry.cacheControl.expire === undefined ? undefined : Math.max(revalidate + 3, previousIncrementalCacheEntry.cacheControl.expire);
-                await incrementalCache.set(key, previousIncrementalCacheEntry.value, {
-                    cacheControl: {
-                        revalidate: revalidate,
-                        expire: expire
-                    },
-                    isRoutePPREnabled,
-                    isFallback
-                });
-            }
-            // We haven't resolved yet, so let's throw to indicate an error.
-            throw err;
-        }
-    }
-}
-
-//# sourceMappingURL=index.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/response-cache/types.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    CachedRouteKind: null,
-    IncrementalCacheKind: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    CachedRouteKind: function() {
-        return CachedRouteKind;
-    },
-    IncrementalCacheKind: function() {
-        return IncrementalCacheKind;
-    }
-});
-var CachedRouteKind = /*#__PURE__*/ function(CachedRouteKind) {
-    CachedRouteKind["APP_PAGE"] = "APP_PAGE";
-    CachedRouteKind["APP_ROUTE"] = "APP_ROUTE";
-    CachedRouteKind["PAGES"] = "PAGES";
-    CachedRouteKind["FETCH"] = "FETCH";
-    CachedRouteKind["REDIRECT"] = "REDIRECT";
-    CachedRouteKind["IMAGE"] = "IMAGE";
-    return CachedRouteKind;
-}({});
-var IncrementalCacheKind = /*#__PURE__*/ function(IncrementalCacheKind) {
-    IncrementalCacheKind["APP_PAGE"] = "APP_PAGE";
-    IncrementalCacheKind["APP_ROUTE"] = "APP_ROUTE";
-    IncrementalCacheKind["PAGES"] = "PAGES";
-    IncrementalCacheKind["FETCH"] = "FETCH";
-    IncrementalCacheKind["IMAGE"] = "IMAGE";
-    return IncrementalCacheKind;
-}({});
-
-//# sourceMappingURL=types.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/response-cache/utils.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    fromResponseCacheEntry: null,
-    routeKindToIncrementalCacheKind: null,
-    toResponseCacheEntry: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    fromResponseCacheEntry: function() {
-        return fromResponseCacheEntry;
-    },
-    routeKindToIncrementalCacheKind: function() {
-        return routeKindToIncrementalCacheKind;
-    },
-    toResponseCacheEntry: function() {
-        return toResponseCacheEntry;
-    }
-});
-const _types = require("./types");
-const _renderresult = /*#__PURE__*/ _interop_require_default(require("../render-result"));
-const _routekind = require("../route-kind");
-const _constants = require("../../lib/constants");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-async function fromResponseCacheEntry(cacheEntry) {
-    var _cacheEntry_value, _cacheEntry_value1;
-    return {
-        ...cacheEntry,
-        value: ((_cacheEntry_value = cacheEntry.value) == null ? void 0 : _cacheEntry_value.kind) === _types.CachedRouteKind.PAGES ? {
-            kind: _types.CachedRouteKind.PAGES,
-            html: await cacheEntry.value.html.toUnchunkedString(true),
-            pageData: cacheEntry.value.pageData,
-            headers: cacheEntry.value.headers,
-            status: cacheEntry.value.status
-        } : ((_cacheEntry_value1 = cacheEntry.value) == null ? void 0 : _cacheEntry_value1.kind) === _types.CachedRouteKind.APP_PAGE ? {
-            kind: _types.CachedRouteKind.APP_PAGE,
-            html: await cacheEntry.value.html.toUnchunkedString(true),
-            postponed: cacheEntry.value.postponed,
-            rscData: cacheEntry.value.rscData,
-            headers: cacheEntry.value.headers,
-            status: cacheEntry.value.status,
-            segmentData: cacheEntry.value.segmentData
-        } : cacheEntry.value
-    };
-}
-async function toResponseCacheEntry(response) {
-    var _response_value, _response_value1;
-    if (!response) return null;
-    return {
-        isMiss: response.isMiss,
-        isStale: response.isStale,
-        cacheControl: response.cacheControl,
-        value: ((_response_value = response.value) == null ? void 0 : _response_value.kind) === _types.CachedRouteKind.PAGES ? {
-            kind: _types.CachedRouteKind.PAGES,
-            html: _renderresult.default.fromStatic(response.value.html, _constants.HTML_CONTENT_TYPE_HEADER),
-            pageData: response.value.pageData,
-            headers: response.value.headers,
-            status: response.value.status
-        } : ((_response_value1 = response.value) == null ? void 0 : _response_value1.kind) === _types.CachedRouteKind.APP_PAGE ? {
-            kind: _types.CachedRouteKind.APP_PAGE,
-            html: _renderresult.default.fromStatic(response.value.html, _constants.HTML_CONTENT_TYPE_HEADER),
-            rscData: response.value.rscData,
-            headers: response.value.headers,
-            status: response.value.status,
-            postponed: response.value.postponed,
-            segmentData: response.value.segmentData
-        } : response.value
-    };
-}
-function routeKindToIncrementalCacheKind(routeKind) {
-    switch(routeKind){
-        case _routekind.RouteKind.PAGES:
-            return _types.IncrementalCacheKind.PAGES;
-        case _routekind.RouteKind.APP_PAGE:
-            return _types.IncrementalCacheKind.APP_PAGE;
-        case _routekind.RouteKind.IMAGE:
-            return _types.IncrementalCacheKind.IMAGE;
-        case _routekind.RouteKind.APP_ROUTE:
-            return _types.IncrementalCacheKind.APP_ROUTE;
-        case _routekind.RouteKind.PAGES_API:
-            // Pages Router API routes are not cached in the incremental cache.
-            throw Object.defineProperty(new Error(`Unexpected route kind ${routeKind}`), "__NEXT_ERROR_CODE", {
-                value: "E64",
-                enumerable: false,
-                configurable: true
-            });
-        default:
-            return routeKind;
-    }
-}
-
-//# sourceMappingURL=utils.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/response-cache/web.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, /**
- * In the web server, there is currently no incremental cache provided and we
- * always SSR the page.
- */ "default", {
-    enumerable: true,
-    get: function() {
-        return WebResponseCache;
-    }
-});
-const _detachedpromise = require("../../lib/detached-promise");
-class WebResponseCache {
-    constructor(minimalMode){
-        this.pendingResponses = new Map();
-        // this is a hack to avoid Webpack knowing this is equal to this.minimalMode
-        // because we replace this.minimalMode to true in production bundles.
-        Object.assign(this, {
-            minimalMode
-        });
-    }
-    get(key, responseGenerator, context) {
-        var _this_previousCacheItem;
-        // ensure on-demand revalidate doesn't block normal requests
-        const pendingResponseKey = key ? `${key}-${context.isOnDemandRevalidate ? '1' : '0'}` : null;
-        const pendingResponse = pendingResponseKey ? this.pendingResponses.get(pendingResponseKey) : null;
-        if (pendingResponse) {
-            return pendingResponse;
-        }
-        const { promise, resolve: resolver, reject: rejecter } = new _detachedpromise.DetachedPromise();
-        if (pendingResponseKey) {
-            this.pendingResponses.set(pendingResponseKey, promise);
-        }
-        let hasResolved = false;
-        const resolve = (cacheEntry)=>{
-            if (pendingResponseKey) {
-                // Ensure all reads from the cache get the latest value.
-                this.pendingResponses.set(pendingResponseKey, Promise.resolve(cacheEntry));
-            }
-            if (!hasResolved) {
-                hasResolved = true;
-                resolver(cacheEntry);
-            }
-        };
-        // we keep the previous cache entry around to leverage
-        // when the incremental cache is disabled in minimal mode
-        if (pendingResponseKey && this.minimalMode && ((_this_previousCacheItem = this.previousCacheItem) == null ? void 0 : _this_previousCacheItem.key) === pendingResponseKey && this.previousCacheItem.expiresAt > Date.now()) {
-            resolve(this.previousCacheItem.entry);
-            this.pendingResponses.delete(pendingResponseKey);
-            return promise;
-        }
-        // We wait to do any async work until after we've added our promise to
-        // `pendingResponses` to ensure that any any other calls will reuse the
-        // same promise until we've fully finished our work.
-        ;
-        (async ()=>{
-            try {
-                const cacheEntry = await responseGenerator({
-                    hasResolved
-                });
-                const resolveValue = cacheEntry === null ? null : {
-                    ...cacheEntry,
-                    isMiss: true
-                };
-                // for on-demand revalidate wait to resolve until cache is set
-                if (!context.isOnDemandRevalidate) {
-                    resolve(resolveValue);
-                }
-                if (key && cacheEntry && cacheEntry.cacheControl) {
-                    this.previousCacheItem = {
-                        key: pendingResponseKey || key,
-                        entry: cacheEntry,
-                        expiresAt: Date.now() + 1000
-                    };
-                } else {
-                    this.previousCacheItem = undefined;
-                }
-                if (context.isOnDemandRevalidate) {
-                    resolve(resolveValue);
-                }
-            } catch (err) {
-                // while revalidating in the background we can't reject as
-                // we already resolved the cache entry so log the error here
-                if (hasResolved) {
-                    console.error(err);
-                } else {
-                    rejecter(err);
-                }
-            } finally{
-                if (pendingResponseKey) {
-                    this.pendingResponses.delete(pendingResponseKey);
-                }
-            }
-        })();
-        return promise;
-    }
-}
-
-//# sourceMappingURL=web.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/resume-data-cache/cache-store.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    parseUseCacheCacheStore: null,
-    serializeUseCacheCacheStore: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    parseUseCacheCacheStore: function() {
-        return parseUseCacheCacheStore;
-    },
-    serializeUseCacheCacheStore: function() {
-        return serializeUseCacheCacheStore;
-    }
-});
-const _encryptionutils = require("../app-render/encryption-utils");
-const _constants = require("../use-cache/constants");
-function parseUseCacheCacheStore(entries) {
-    const store = new Map();
-    for (const [key, { value, tags, stale, timestamp, expire, revalidate }] of entries){
-        store.set(key, Promise.resolve({
-            // Create a ReadableStream from the Uint8Array
-            value: new ReadableStream({
-                start (controller) {
-                    // Enqueue the Uint8Array to the stream
-                    controller.enqueue((0, _encryptionutils.stringToUint8Array)(atob(value)));
-                    // Close the stream
-                    controller.close();
-                }
-            }),
-            tags,
-            stale,
-            timestamp,
-            expire,
-            revalidate
-        }));
-    }
-    return store;
-}
-async function serializeUseCacheCacheStore(entries, isCacheComponentsEnabled) {
-    return Promise.all(Array.from(entries).map(([key, value])=>{
-        return value.then(async (entry)=>{
-            if (isCacheComponentsEnabled && (entry.revalidate === 0 || entry.expire < _constants.DYNAMIC_EXPIRE)) {
-                // The entry was omitted from the prerender result, and subsequently
-                // does not need to be included in the serialized RDC.
-                return null;
-            }
-            const [left, right] = entry.value.tee();
-            entry.value = right;
-            let binaryString = '';
-            // We want to encode the value as a string, but we aren't sure if the
-            // value is a a stream of UTF-8 bytes or not, so let's just encode it
-            // as a string using base64.
-            for await (const chunk of left){
-                binaryString += (0, _encryptionutils.arrayBufferToString)(chunk);
-            }
-            return [
-                key,
-                {
-                    // Encode the value as a base64 string.
-                    value: btoa(binaryString),
-                    tags: entry.tags,
-                    stale: entry.stale,
-                    timestamp: entry.timestamp,
-                    expire: entry.expire,
-                    revalidate: entry.revalidate
-                }
-            ];
-        }).catch(()=>{
-            // Any failed cache writes should be ignored as to not discard the
-            // entire cache.
-            return null;
-        });
-    }));
-}
-
-//# sourceMappingURL=cache-store.js.map