@taskmark/ui 0.2.0 → 0.2.2

package/dist/standalone/node_modules/next/dist/server/lib/incremental-cache/index.js

@@ -1,501 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    CacheHandler: null,
-    IncrementalCache: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    CacheHandler: function() {
-        return CacheHandler;
-    },
-    IncrementalCache: function() {
-        return IncrementalCache;
-    }
-});
-const _responsecache = require("../../response-cache");
-const _filesystemcache = /*#__PURE__*/ _interop_require_default(require("./file-system-cache"));
-const _normalizepagepath = require("../../../shared/lib/page-path/normalize-page-path");
-const _constants = require("../../../lib/constants");
-const _toroute = require("../to-route");
-const _sharedcachecontrolsexternal = require("./shared-cache-controls.external");
-const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
-const _invarianterror = require("../../../shared/lib/invariant-error");
-const _serverutils = require("../../server-utils");
-const _workasyncstorageexternal = require("../../app-render/work-async-storage.external");
-const _detachedpromise = require("../../../lib/detached-promise");
-const _tagsmanifestexternal = require("./tags-manifest.external");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-class CacheHandler {
-    // eslint-disable-next-line
-    constructor(_ctx){}
-    async get(_cacheKey, _ctx) {
-        return {};
-    }
-    async set(_cacheKey, _data, _ctx) {}
-    async revalidateTag(_tags, _durations) {}
-    resetRequestCache() {}
-}
-class IncrementalCache {
-    static #_ = this.debug = !!process.env.NEXT_PRIVATE_DEBUG_CACHE;
-    constructor({ fs, dev, flushToDisk, minimalMode, serverDistDir, requestHeaders, maxMemoryCacheSize, getPrerenderManifest, fetchCacheKeyPrefix, CurCacheHandler, allowedRevalidateHeaderKeys }){
-        var _this_prerenderManifest_preview, _this_prerenderManifest;
-        this.locks = new Map();
-        this.hasCustomCacheHandler = Boolean(CurCacheHandler);
-        const cacheHandlersSymbol = Symbol.for('@next/cache-handlers');
-        const _globalThis = globalThis;
-        if (!CurCacheHandler) {
-            // if we have a global cache handler available leverage it
-            const globalCacheHandler = _globalThis[cacheHandlersSymbol];
-            if (globalCacheHandler == null ? void 0 : globalCacheHandler.FetchCache) {
-                CurCacheHandler = globalCacheHandler.FetchCache;
-                if (IncrementalCache.debug) {
-                    console.log('IncrementalCache: using global FetchCache cache handler');
-                }
-            } else {
-                if (fs && serverDistDir) {
-                    if (IncrementalCache.debug) {
-                        console.log('IncrementalCache: using filesystem cache handler');
-                    }
-                    CurCacheHandler = _filesystemcache.default;
-                }
-            }
-        } else if (IncrementalCache.debug) {
-            console.log('IncrementalCache: using custom cache handler', CurCacheHandler.name);
-        }
-        if (process.env.__NEXT_TEST_MAX_ISR_CACHE) {
-            // Allow cache size to be overridden for testing purposes
-            maxMemoryCacheSize = parseInt(process.env.__NEXT_TEST_MAX_ISR_CACHE, 10);
-        }
-        this.dev = dev;
-        this.disableForTestmode = process.env.NEXT_PRIVATE_TEST_PROXY === 'true';
-        // this is a hack to avoid Webpack knowing this is equal to this.minimalMode
-        // because we replace this.minimalMode to true in production bundles.
-        const minimalModeKey = 'minimalMode';
-        this[minimalModeKey] = minimalMode;
-        this.requestHeaders = requestHeaders;
-        this.allowedRevalidateHeaderKeys = allowedRevalidateHeaderKeys;
-        this.prerenderManifest = getPrerenderManifest();
-        this.cacheControls = new _sharedcachecontrolsexternal.SharedCacheControls(this.prerenderManifest);
-        this.fetchCacheKeyPrefix = fetchCacheKeyPrefix;
-        let revalidatedTags = [];
-        if (requestHeaders[_constants.PRERENDER_REVALIDATE_HEADER] === ((_this_prerenderManifest = this.prerenderManifest) == null ? void 0 : (_this_prerenderManifest_preview = _this_prerenderManifest.preview) == null ? void 0 : _this_prerenderManifest_preview.previewModeId)) {
-            this.isOnDemandRevalidate = true;
-        }
-        if (minimalMode) {
-            var _this_prerenderManifest_preview1, _this_prerenderManifest1;
-            revalidatedTags = this.revalidatedTags = (0, _serverutils.getPreviouslyRevalidatedTags)(requestHeaders, (_this_prerenderManifest1 = this.prerenderManifest) == null ? void 0 : (_this_prerenderManifest_preview1 = _this_prerenderManifest1.preview) == null ? void 0 : _this_prerenderManifest_preview1.previewModeId);
-        }
-        if (CurCacheHandler) {
-            this.cacheHandler = new CurCacheHandler({
-                dev,
-                fs,
-                flushToDisk,
-                serverDistDir,
-                revalidatedTags,
-                maxMemoryCacheSize,
-                _requestHeaders: requestHeaders,
-                fetchCacheKeyPrefix
-            });
-        }
-    }
-    calculateRevalidate(pathname, fromTime, dev, isFallback) {
-        // in development we don't have a prerender-manifest
-        // and default to always revalidating to allow easier debugging
-        if (dev) return Math.floor(performance.timeOrigin + performance.now() - 1000);
-        const cacheControl = this.cacheControls.get((0, _toroute.toRoute)(pathname));
-        // if an entry isn't present in routes we fallback to a default
-        // of revalidating after 1 second unless it's a fallback request.
-        const initialRevalidateSeconds = cacheControl ? cacheControl.revalidate : isFallback ? false : 1;
-        const revalidateAfter = typeof initialRevalidateSeconds === 'number' ? initialRevalidateSeconds * 1000 + fromTime : initialRevalidateSeconds;
-        return revalidateAfter;
-    }
-    _getPathname(pathname, fetchCache) {
-        return fetchCache ? pathname : (0, _normalizepagepath.normalizePagePath)(pathname);
-    }
-    resetRequestCache() {
-        var _this_cacheHandler_resetRequestCache, _this_cacheHandler;
-        (_this_cacheHandler = this.cacheHandler) == null ? void 0 : (_this_cacheHandler_resetRequestCache = _this_cacheHandler.resetRequestCache) == null ? void 0 : _this_cacheHandler_resetRequestCache.call(_this_cacheHandler);
-    }
-    async lock(cacheKey) {
-        // Wait for any existing lock on this cache key to be released
-        // This implements a simple queue-based locking mechanism
-        while(true){
-            const lock = this.locks.get(cacheKey);
-            if (IncrementalCache.debug) {
-                console.log('IncrementalCache: lock get', cacheKey, !!lock);
-            }
-            // If no lock exists, we can proceed to acquire it
-            if (!lock) break;
-            // Wait for the existing lock to be released before trying again
-            await lock;
-        }
-        // Create a new detached promise that will represent this lock
-        // The resolve function (unlock) will be returned to the caller
-        const { resolve, promise } = new _detachedpromise.DetachedPromise();
-        if (IncrementalCache.debug) {
-            console.log('IncrementalCache: successfully locked', cacheKey);
-        }
-        // Store the lock promise in the locks map
-        this.locks.set(cacheKey, promise);
-        return ()=>{
-            // Resolve the promise to release the lock.
-            resolve();
-            // Remove the lock from the map once it's released so that future gets
-            // can acquire the lock.
-            this.locks.delete(cacheKey);
-        };
-    }
-    async revalidateTag(tags, durations) {
-        var _this_cacheHandler;
-        return (_this_cacheHandler = this.cacheHandler) == null ? void 0 : _this_cacheHandler.revalidateTag(tags, durations);
-    }
-    // x-ref: https://github.com/facebook/react/blob/2655c9354d8e1c54ba888444220f63e836925caa/packages/react/src/ReactFetch.js#L23
-    async generateCacheKey(url, init = {}) {
-        // this should be bumped anytime a fix is made to cache entries
-        // that should bust the cache
-        const MAIN_KEY_PREFIX = 'v3';
-        const bodyChunks = [];
-        const encoder = new TextEncoder();
-        const decoder = new TextDecoder();
-        if (init.body) {
-            // handle Uint8Array body
-            if (init.body instanceof Uint8Array) {
-                bodyChunks.push(decoder.decode(init.body));
-                init._ogBody = init.body;
-            } else if (typeof init.body.getReader === 'function') {
-                const readableBody = init.body;
-                const chunks = [];
-                try {
-                    await readableBody.pipeTo(new WritableStream({
-                        write (chunk) {
-                            if (typeof chunk === 'string') {
-                                chunks.push(encoder.encode(chunk));
-                                bodyChunks.push(chunk);
-                            } else {
-                                chunks.push(chunk);
-                                bodyChunks.push(decoder.decode(chunk, {
-                                    stream: true
-                                }));
-                            }
-                        }
-                    }));
-                    // Flush the decoder.
-                    bodyChunks.push(decoder.decode());
-                    // Create a new buffer with all the chunks.
-                    const length = chunks.reduce((total, arr)=>total + arr.length, 0);
-                    const arrayBuffer = new Uint8Array(length);
-                    // Push each of the chunks into the new array buffer.
-                    let offset = 0;
-                    for (const chunk of chunks){
-                        arrayBuffer.set(chunk, offset);
-                        offset += chunk.length;
-                    }
-                    ;
-                    init._ogBody = arrayBuffer;
-                } catch (err) {
-                    console.error('Problem reading body', err);
-                }
-            } else if (typeof init.body.keys === 'function') {
-                const formData = init.body;
-                init._ogBody = init.body;
-                for (const key of new Set([
-                    ...formData.keys()
-                ])){
-                    const values = formData.getAll(key);
-                    bodyChunks.push(`${key}=${(await Promise.all(values.map(async (val)=>{
-                        if (typeof val === 'string') {
-                            return val;
-                        } else {
-                            return await val.text();
-                        }
-                    }))).join(',')}`);
-                }
-            // handle blob body
-            } else if (typeof init.body.arrayBuffer === 'function') {
-                const blob = init.body;
-                const arrayBuffer = await blob.arrayBuffer();
-                bodyChunks.push(await blob.text());
-                init._ogBody = new Blob([
-                    arrayBuffer
-                ], {
-                    type: blob.type
-                });
-            } else if (typeof init.body === 'string') {
-                bodyChunks.push(init.body);
-                init._ogBody = init.body;
-            }
-        }
-        const headers = typeof (init.headers || {}).keys === 'function' ? Object.fromEntries(init.headers) : Object.assign({}, init.headers);
-        // w3c trace context headers can break request caching and deduplication
-        // so we remove them from the cache key
-        if ('traceparent' in headers) delete headers['traceparent'];
-        if ('tracestate' in headers) delete headers['tracestate'];
-        const cacheString = JSON.stringify([
-            MAIN_KEY_PREFIX,
-            this.fetchCacheKeyPrefix || '',
-            url,
-            init.method,
-            headers,
-            init.mode,
-            init.redirect,
-            init.credentials,
-            init.referrer,
-            init.referrerPolicy,
-            init.integrity,
-            init.cache,
-            bodyChunks
-        ]);
-        if (process.env.NEXT_RUNTIME === 'edge') {
-            function bufferToHex(buffer) {
-                return Array.prototype.map.call(new Uint8Array(buffer), (b)=>b.toString(16).padStart(2, '0')).join('');
-            }
-            const buffer = encoder.encode(cacheString);
-            return bufferToHex(await crypto.subtle.digest('SHA-256', buffer));
-        } else {
-            const crypto1 = require('crypto');
-            return crypto1.createHash('sha256').update(cacheString).digest('hex');
-        }
-    }
-    async get(cacheKey, ctx) {
-        var _this_cacheHandler, _cacheData_value;
-        // Unlike other caches if we have a resume data cache, we use it even if
-        // testmode would normally disable it or if requestHeaders say 'no-cache'.
-        if (ctx.kind === _responsecache.IncrementalCacheKind.FETCH) {
-            const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-            const resumeDataCache = workUnitStore ? (0, _workunitasyncstorageexternal.getRenderResumeDataCache)(workUnitStore) : null;
-            if (resumeDataCache) {
-                const memoryCacheData = resumeDataCache.fetch.get(cacheKey);
-                if ((memoryCacheData == null ? void 0 : memoryCacheData.kind) === _responsecache.CachedRouteKind.FETCH) {
-                    // Check if any tags were recently revalidated before returning RDC entry.
-                    // When a server action calls updateTag(), the re-render should see fresh
-                    // data instead of stale RDC data.
-                    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-                    const combinedTags = [
-                        ...ctx.tags || [],
-                        ...ctx.softTags || []
-                    ];
-                    const hasRevalidatedTag = combinedTags.some((tag)=>{
-                        var _this_revalidatedTags, _workStore_pendingRevalidatedTags;
-                        return ((_this_revalidatedTags = this.revalidatedTags) == null ? void 0 : _this_revalidatedTags.includes(tag)) || (workStore == null ? void 0 : (_workStore_pendingRevalidatedTags = workStore.pendingRevalidatedTags) == null ? void 0 : _workStore_pendingRevalidatedTags.some((item)=>item.tag === tag));
-                    });
-                    if (hasRevalidatedTag) {
-                        if (IncrementalCache.debug) {
-                            console.log('IncrementalCache: rdc:revalidated-tag', cacheKey);
-                        }
-                    // Fall through to cacheHandler lookup
-                    } else {
-                        if (IncrementalCache.debug) {
-                            console.log('IncrementalCache: rdc:hit', cacheKey);
-                        }
-                        return {
-                            isStale: false,
-                            value: memoryCacheData
-                        };
-                    }
-                } else if (IncrementalCache.debug) {
-                    console.log('IncrementalCache: rdc:miss', cacheKey);
-                }
-            } else {
-                if (IncrementalCache.debug) {
-                    console.log('IncrementalCache: rdc:no-resume-data');
-                }
-            }
-        }
-        // we don't leverage the prerender cache in dev mode
-        // so that getStaticProps is always called for easier debugging
-        if (this.disableForTestmode || this.dev && (ctx.kind !== _responsecache.IncrementalCacheKind.FETCH || this.requestHeaders['cache-control'] === 'no-cache')) {
-            return null;
-        }
-        cacheKey = this._getPathname(cacheKey, ctx.kind === _responsecache.IncrementalCacheKind.FETCH);
-        const cacheData = await ((_this_cacheHandler = this.cacheHandler) == null ? void 0 : _this_cacheHandler.get(cacheKey, ctx));
-        if (ctx.kind === _responsecache.IncrementalCacheKind.FETCH) {
-            var _cacheData_value1;
-            if (!cacheData) {
-                return null;
-            }
-            if (((_cacheData_value1 = cacheData.value) == null ? void 0 : _cacheData_value1.kind) !== _responsecache.CachedRouteKind.FETCH) {
-                var _cacheData_value2;
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Expected cached value for cache key ${JSON.stringify(cacheKey)} to be a "FETCH" kind, got ${JSON.stringify((_cacheData_value2 = cacheData.value) == null ? void 0 : _cacheData_value2.kind)} instead.`), "__NEXT_ERROR_CODE", {
-                    value: "E653",
-                    enumerable: false,
-                    configurable: true
-                });
-            }
-            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-            const combinedTags = [
-                ...ctx.tags || [],
-                ...ctx.softTags || []
-            ];
-            // if a tag was revalidated we don't return stale data
-            if (combinedTags.some((tag)=>{
-                var _this_revalidatedTags, _workStore_pendingRevalidatedTags;
-                return ((_this_revalidatedTags = this.revalidatedTags) == null ? void 0 : _this_revalidatedTags.includes(tag)) || (workStore == null ? void 0 : (_workStore_pendingRevalidatedTags = workStore.pendingRevalidatedTags) == null ? void 0 : _workStore_pendingRevalidatedTags.some((item)=>item.tag === tag));
-            })) {
-                if (IncrementalCache.debug) {
-                    console.log('IncrementalCache: expired tag', cacheKey);
-                }
-                return null;
-            }
-            // As we're able to get the cache entry for this fetch, and the prerender
-            // resume data cache (RDC) is available, it must have been populated by a
-            // previous fetch, but was not yet present in the in-memory cache. This
-            // could be the case when performing multiple renders in parallel during
-            // build time where we de-duplicate the fetch calls.
-            //
-            // We add it to the RDC so that the next fetch call will be able to use it
-            // and it won't have to reach into the fetch cache implementation.
-            const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-            if (workUnitStore) {
-                const prerenderResumeDataCache = (0, _workunitasyncstorageexternal.getPrerenderResumeDataCache)(workUnitStore);
-                if (prerenderResumeDataCache) {
-                    if (IncrementalCache.debug) {
-                        console.log('IncrementalCache: rdc:set', cacheKey);
-                    }
-                    prerenderResumeDataCache.fetch.set(cacheKey, cacheData.value);
-                }
-            }
-            const revalidate = ctx.revalidate || cacheData.value.revalidate;
-            const age = (performance.timeOrigin + performance.now() - (cacheData.lastModified || 0)) / 1000;
-            let isStale = age > revalidate;
-            const data = cacheData.value.data;
-            if ((0, _tagsmanifestexternal.areTagsExpired)(combinedTags, cacheData.lastModified)) {
-                return null;
-            } else if ((0, _tagsmanifestexternal.areTagsStale)(combinedTags, cacheData.lastModified)) {
-                isStale = true;
-            }
-            return {
-                isStale,
-                value: {
-                    kind: _responsecache.CachedRouteKind.FETCH,
-                    data,
-                    revalidate
-                }
-            };
-        } else if ((cacheData == null ? void 0 : (_cacheData_value = cacheData.value) == null ? void 0 : _cacheData_value.kind) === _responsecache.CachedRouteKind.FETCH) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected cached value for cache key ${JSON.stringify(cacheKey)} not to be a ${JSON.stringify(ctx.kind)} kind, got "FETCH" instead.`), "__NEXT_ERROR_CODE", {
-                value: "E652",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        let entry = null;
-        const { isFallback } = ctx;
-        const cacheControl = this.cacheControls.get((0, _toroute.toRoute)(cacheKey));
-        let isStale;
-        let revalidateAfter;
-        if ((cacheData == null ? void 0 : cacheData.lastModified) === -1) {
-            isStale = -1;
-            revalidateAfter = -1 * _constants.CACHE_ONE_YEAR_SECONDS * 1000;
-        } else {
-            var _cacheData_value3, _cacheData_value4;
-            const now = performance.timeOrigin + performance.now();
-            const lastModified = (cacheData == null ? void 0 : cacheData.lastModified) || now;
-            revalidateAfter = this.calculateRevalidate(cacheKey, lastModified, this.dev ?? false, ctx.isFallback);
-            isStale = revalidateAfter !== false && revalidateAfter < now ? true : undefined;
-            // If the stale time couldn't be determined based on the revalidation
-            // time, we check if the tags are expired or stale.
-            if (isStale === undefined && ((cacheData == null ? void 0 : (_cacheData_value3 = cacheData.value) == null ? void 0 : _cacheData_value3.kind) === _responsecache.CachedRouteKind.APP_PAGE || (cacheData == null ? void 0 : (_cacheData_value4 = cacheData.value) == null ? void 0 : _cacheData_value4.kind) === _responsecache.CachedRouteKind.APP_ROUTE)) {
-                var _cacheData_value_headers;
-                const tagsHeader = (_cacheData_value_headers = cacheData.value.headers) == null ? void 0 : _cacheData_value_headers[_constants.NEXT_CACHE_TAGS_HEADER];
-                if (typeof tagsHeader === 'string') {
-                    const cacheTags = tagsHeader.split(',');
-                    if (cacheTags.length > 0) {
-                        if ((0, _tagsmanifestexternal.areTagsExpired)(cacheTags, lastModified)) {
-                            isStale = -1;
-                        } else if ((0, _tagsmanifestexternal.areTagsStale)(cacheTags, lastModified)) {
-                            isStale = true;
-                        }
-                    }
-                }
-            }
-        }
-        if (cacheData) {
-            entry = {
-                isStale,
-                cacheControl,
-                revalidateAfter,
-                value: cacheData.value,
-                isFallback
-            };
-        }
-        if (!cacheData && this.prerenderManifest.notFoundRoutes.includes(cacheKey)) {
-            // for the first hit after starting the server the cache
-            // may not have a way to save notFound: true so if
-            // the prerender-manifest marks this as notFound then we
-            // return that entry and trigger a cache set to give it a
-            // chance to update in-memory entries
-            entry = {
-                isStale,
-                value: null,
-                cacheControl,
-                revalidateAfter,
-                isFallback
-            };
-            this.set(cacheKey, entry.value, {
-                ...ctx,
-                cacheControl
-            });
-        }
-        return entry;
-    }
-    async set(pathname, data, ctx) {
-        // Even if we otherwise disable caching for testMode or if no fetchCache is
-        // configured we still always stash results in the resume data cache if one
-        // exists. This is because this is a transient in memory cache that
-        // populates caches ahead of a dynamic render in dev mode to allow the RSC
-        // debug info to have the right environment associated to it.
-        if ((data == null ? void 0 : data.kind) === _responsecache.CachedRouteKind.FETCH) {
-            const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-            const prerenderResumeDataCache = workUnitStore ? (0, _workunitasyncstorageexternal.getPrerenderResumeDataCache)(workUnitStore) : null;
-            if (prerenderResumeDataCache) {
-                if (IncrementalCache.debug) {
-                    console.log('IncrementalCache: rdc:set', pathname);
-                }
-                prerenderResumeDataCache.fetch.set(pathname, data);
-            }
-        }
-        if (this.disableForTestmode || this.dev && !ctx.fetchCache) return;
-        pathname = this._getPathname(pathname, ctx.fetchCache);
-        // FetchCache has upper limit of 2MB per-entry currently
-        const itemSize = JSON.stringify(data).length;
-        if (ctx.fetchCache && itemSize > 2 * 1024 * 1024 && // We ignore the size limit when custom cache handler is being used, as it
-        // might not have this limit
-        !this.hasCustomCacheHandler && // We also ignore the size limit when it's an implicit build-time-only
-        // caching that the user isn't even aware of.
-        !ctx.isImplicitBuildTimeCache) {
-            const warningText = `Failed to set Next.js data cache for ${ctx.fetchUrl || pathname}, items over 2MB can not be cached (${itemSize} bytes)`;
-            if (this.dev) {
-                throw Object.defineProperty(new Error(warningText), "__NEXT_ERROR_CODE", {
-                    value: "E1003",
-                    enumerable: false,
-                    configurable: true
-                });
-            }
-            console.warn(warningText);
-            return;
-        }
-        try {
-            var _this_cacheHandler;
-            if (!ctx.fetchCache && ctx.cacheControl) {
-                this.cacheControls.set((0, _toroute.toRoute)(pathname), ctx.cacheControl);
-            }
-            await ((_this_cacheHandler = this.cacheHandler) == null ? void 0 : _this_cacheHandler.set(pathname, data, ctx));
-        } catch (error) {
-            console.warn('Failed to update prerender cache for', pathname, error);
-        }
-    }
-}
-
-//# sourceMappingURL=index.js.map

package/dist/standalone/node_modules/next/dist/server/lib/incremental-cache/memory-cache.external.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "getMemoryCache", {
-    enumerable: true,
-    get: function() {
-        return getMemoryCache;
-    }
-});
-const _types = require("../../response-cache/types");
-const _lrucache = require("../lru-cache");
-let memoryCache;
-function getBufferSize(buffer) {
-    return (buffer == null ? void 0 : buffer.length) || 0;
-}
-function getSegmentDataSize(segmentData) {
-    if (!segmentData) {
-        return 0;
-    }
-    let size = 0;
-    for (const [segmentPath, buffer] of segmentData){
-        size += segmentPath.length + getBufferSize(buffer);
-    }
-    return size;
-}
-function getMemoryCache(maxMemoryCacheSize) {
-    if (!memoryCache) {
-        memoryCache = new _lrucache.LRUCache(maxMemoryCacheSize, function length({ value }) {
-            var _JSON_stringify;
-            if (!value) {
-                return 25;
-            } else if (value.kind === _types.CachedRouteKind.REDIRECT) {
-                return JSON.stringify(value.props).length;
-            } else if (value.kind === _types.CachedRouteKind.IMAGE) {
-                throw Object.defineProperty(new Error('invariant image should not be incremental-cache'), "__NEXT_ERROR_CODE", {
-                    value: "E501",
-                    enumerable: false,
-                    configurable: true
-                });
-            } else if (value.kind === _types.CachedRouteKind.FETCH) {
-                return JSON.stringify(value.data || '').length;
-            } else if (value.kind === _types.CachedRouteKind.APP_ROUTE) {
-                return value.body.length;
-            }
-            // rough estimate of size of cache value
-            if (value.kind === _types.CachedRouteKind.APP_PAGE) {
-                var _value_postponed;
-                return Math.max(1, value.html.length + getBufferSize(value.rscData) + (((_value_postponed = value.postponed) == null ? void 0 : _value_postponed.length) || 0) + getSegmentDataSize(value.segmentData));
-            }
-            return value.html.length + (((_JSON_stringify = JSON.stringify(value.pageData)) == null ? void 0 : _JSON_stringify.length) || 0);
-        });
-    }
-    return memoryCache;
-}
-
-//# sourceMappingURL=memory-cache.external.js.map

package/dist/standalone/node_modules/next/dist/server/lib/incremental-cache/shared-cache-controls.external.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SharedCacheControls", {
-    enumerable: true,
-    get: function() {
-        return SharedCacheControls;
-    }
-});
-class SharedCacheControls {
-    static #_ = /**
-   * The in-memory cache of cache lives for routes. This cache is populated when
-   * the cache is updated with new cache lives.
-   */ this.cacheControls = new Map();
-    constructor(/**
-     * The prerender manifest that contains the initial cache controls for
-     * routes.
-     */ prerenderManifest){
-        this.prerenderManifest = prerenderManifest;
-    }
-    /**
-   * Try to get the cache control value for a route. This will first try to get
-   * the value from the in-memory cache. If the value is not present in the
-   * in-memory cache, it will be sourced from the prerender manifest.
-   *
-   * @param route the route to get the cache control for
-   * @returns the cache control for the route, or undefined if the values
-   *          are not present in the in-memory cache or the prerender manifest
-   */ get(route) {
-        // This is a copy on write cache that is updated when the cache is updated.
-        // If the cache is never written to, then the values will be sourced from
-        // the prerender manifest.
-        let cacheControl = SharedCacheControls.cacheControls.get(route);
-        if (cacheControl) return cacheControl;
-        let prerenderData = this.prerenderManifest.routes[route];
-        if (prerenderData) {
-            const { initialRevalidateSeconds, initialExpireSeconds } = prerenderData;
-            if (typeof initialRevalidateSeconds !== 'undefined') {
-                return {
-                    revalidate: initialRevalidateSeconds,
-                    expire: initialExpireSeconds
-                };
-            }
-        }
-        const dynamicPrerenderData = this.prerenderManifest.dynamicRoutes[route];
-        if (dynamicPrerenderData) {
-            const { fallbackRevalidate, fallbackExpire } = dynamicPrerenderData;
-            if (typeof fallbackRevalidate !== 'undefined') {
-                return {
-                    revalidate: fallbackRevalidate,
-                    expire: fallbackExpire
-                };
-            }
-        }
-        return undefined;
-    }
-    /**
-   * Set the cache control for a route.
-   *
-   * @param route the route to set the cache control for
-   * @param cacheControl the cache control for the route
-   */ set(route, cacheControl) {
-        SharedCacheControls.cacheControls.set(route, cacheControl);
-    }
-    /**
-   * Clear the in-memory cache of cache controls for routes.
-   */ clear() {
-        SharedCacheControls.cacheControls.clear();
-    }
-}
-
-//# sourceMappingURL=shared-cache-controls.external.js.map