@obsfx/trekker 0.1.7 → 0.1.9

package/webapp-dist/vendor/next/dist/server/lib/fix-mojibake.js

@@ -0,0 +1,25 @@
+// x-matched-path header can be decoded incorrectly
+// and should only be utf8 characters so this fixes
+// incorrectly encoded values
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "fixMojibake", {
+    enumerable: true,
+    get: function() {
+        return fixMojibake;
+    }
+});
+function fixMojibake(input) {
+    // Convert each character's char code to a byte
+    const bytes = new Uint8Array(input.length);
+    for(let i = 0; i < input.length; i++){
+        bytes[i] = input.charCodeAt(i);
+    }
+    // Decode the bytes as proper UTF-8
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(bytes);
+}
+
+//# sourceMappingURL=fix-mojibake.js.map

package/webapp-dist/vendor/next/dist/server/lib/format-hostname.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatHostname", {
+    enumerable: true,
+    get: function() {
+        return formatHostname;
+    }
+});
+const _isipv6 = require("./is-ipv6");
+function formatHostname(hostname) {
+    return (0, _isipv6.isIPv6)(hostname) ? `[${hostname}]` : hostname;
+}
+
+//# sourceMappingURL=format-hostname.js.map

package/webapp-dist/vendor/next/dist/server/lib/i18n-provider.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "I18NProvider", {
+    enumerable: true,
+    get: function() {
+        return I18NProvider;
+    }
+});
+const _requestmeta = require("../request-meta");
+class I18NProvider {
+    constructor(config){
+        var _config_domains;
+        this.config = config;
+        if (!config.locales.length) {
+            throw Object.defineProperty(new Error('Invariant: No locales provided'), "__NEXT_ERROR_CODE", {
+                value: "E510",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        this.lowerCaseLocales = config.locales.map((locale)=>locale.toLowerCase());
+        this.lowerCaseDomains = (_config_domains = config.domains) == null ? void 0 : _config_domains.map((domainLocale)=>{
+            var _domainLocale_locales;
+            const domain = domainLocale.domain.toLowerCase();
+            return {
+                defaultLocale: domainLocale.defaultLocale.toLowerCase(),
+                hostname: domain.split(':', 1)[0],
+                domain,
+                locales: (_domainLocale_locales = domainLocale.locales) == null ? void 0 : _domainLocale_locales.map((locale)=>locale.toLowerCase()),
+                http: domainLocale.http
+            };
+        });
+    }
+    /**
+   * Detects the domain locale from the hostname and the detected locale if
+   * provided.
+   *
+   * @param hostname The hostname to detect the domain locale from, this must be lowercased.
+   * @param detectedLocale The detected locale to use if the hostname does not match.
+   * @returns The domain locale if found, `undefined` otherwise.
+   */ detectDomainLocale(hostname, detectedLocale) {
+        if (!hostname || !this.lowerCaseDomains || !this.config.domains) return;
+        if (detectedLocale) detectedLocale = detectedLocale.toLowerCase();
+        for(let i = 0; i < this.lowerCaseDomains.length; i++){
+            var // Configuration validation ensures that the locale is not repeated in
+            // other domains locales.
+            _domainLocale_locales;
+            const domainLocale = this.lowerCaseDomains[i];
+            if (// We assume that the hostname is already lowercased.
+            domainLocale.hostname === hostname || ((_domainLocale_locales = domainLocale.locales) == null ? void 0 : _domainLocale_locales.some((locale)=>locale === detectedLocale))) {
+                return this.config.domains[i];
+            }
+        }
+        return;
+    }
+    /**
+   * Pulls the pre-computed locale and inference results from the query
+   * object.
+   *
+   * @param req the request object
+   * @param pathname the pathname that could contain a locale prefix
+   * @returns the locale analysis result
+   */ fromRequest(req, pathname) {
+        const detectedLocale = (0, _requestmeta.getRequestMeta)(req, 'locale');
+        // If a locale was detected on the query, analyze the pathname to ensure
+        // that the locale matches.
+        if (detectedLocale) {
+            const analysis = this.analyze(pathname);
+            // If the analysis contained a locale we should validate it against the
+            // query and strip it from the pathname.
+            if (analysis.detectedLocale) {
+                if (analysis.detectedLocale !== detectedLocale) {
+                    console.warn(`The detected locale does not match the locale in the query. Expected to find '${detectedLocale}' in '${pathname}' but found '${analysis.detectedLocale}'}`);
+                }
+                pathname = analysis.pathname;
+            }
+        }
+        return {
+            pathname,
+            detectedLocale,
+            inferredFromDefault: (0, _requestmeta.getRequestMeta)(req, 'localeInferredFromDefault') ?? false
+        };
+    }
+    /**
+   * Analyzes the pathname for a locale and returns the pathname without it.
+   *
+   * @param pathname The pathname that could contain a locale prefix.
+   * @param options The options to use when matching the locale.
+   * @returns The matched locale and the pathname without the locale prefix
+   *          (if any).
+   */ analyze(pathname, options = {}) {
+        let detectedLocale = options.defaultLocale;
+        // By default, we assume that the default locale was inferred if there was
+        // no detected locale.
+        let inferredFromDefault = typeof detectedLocale === 'string';
+        // The first segment will be empty, because it has a leading `/`. If
+        // there is no further segment, there is no locale (or it's the default).
+        const segments = pathname.split('/', 2);
+        if (!segments[1]) return {
+            detectedLocale,
+            pathname,
+            inferredFromDefault
+        };
+        // The second segment will contain the locale part if any.
+        const segment = segments[1].toLowerCase();
+        // See if the segment matches one of the locales. If it doesn't, there is
+        // no locale (or it's the default).
+        const index = this.lowerCaseLocales.indexOf(segment);
+        if (index < 0) return {
+            detectedLocale,
+            pathname,
+            inferredFromDefault
+        };
+        // Return the case-sensitive locale.
+        detectedLocale = this.config.locales[index];
+        inferredFromDefault = false;
+        // Remove the `/${locale}` part of the pathname.
+        pathname = pathname.slice(detectedLocale.length + 1) || '/';
+        return {
+            detectedLocale,
+            pathname,
+            inferredFromDefault
+        };
+    }
+}
+
+//# sourceMappingURL=i18n-provider.js.map

package/webapp-dist/vendor/next/dist/server/lib/implicit-tags.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getImplicitTags", {
+    enumerable: true,
+    get: function() {
+        return getImplicitTags;
+    }
+});
+const _constants = require("../../lib/constants");
+const _handlers = require("../use-cache/handlers");
+const _lazyresult = require("./lazy-result");
+const getDerivedTags = (pathname)=>{
+    const derivedTags = [
+        `/layout`
+    ];
+    // we automatically add the current path segments as tags
+    // for revalidatePath handling
+    if (pathname.startsWith('/')) {
+        const pathnameParts = pathname.split('/');
+        for(let i = 1; i < pathnameParts.length + 1; i++){
+            let curPathname = pathnameParts.slice(0, i).join('/');
+            if (curPathname) {
+                // all derived tags other than the page are layout tags
+                if (!curPathname.endsWith('/page') && !curPathname.endsWith('/route')) {
+                    curPathname = `${curPathname}${!curPathname.endsWith('/') ? '/' : ''}layout`;
+                }
+                derivedTags.push(curPathname);
+            }
+        }
+    }
+    return derivedTags;
+};
+/**
+ * Creates a map with lazy results that fetch the expiration value for the given
+ * tags and respective cache kind when they're awaited for the first time.
+ */ function createTagsExpirationsByCacheKind(tags) {
+    const expirationsByCacheKind = new Map();
+    const cacheHandlers = (0, _handlers.getCacheHandlerEntries)();
+    if (cacheHandlers) {
+        for (const [kind, cacheHandler] of cacheHandlers){
+            if ('getExpiration' in cacheHandler) {
+                expirationsByCacheKind.set(kind, (0, _lazyresult.createLazyResult)(async ()=>cacheHandler.getExpiration(tags)));
+            }
+        }
+    }
+    return expirationsByCacheKind;
+}
+async function getImplicitTags(page, url, fallbackRouteParams) {
+    const tags = new Set();
+    // Add the derived tags from the page.
+    const derivedTags = getDerivedTags(page);
+    for (let tag of derivedTags){
+        tag = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${tag}`;
+        tags.add(tag);
+    }
+    // Add the tags from the pathname. If the route has unknown params, we don't
+    // want to add the pathname as a tag, as it will be invalid.
+    if (url.pathname && (!fallbackRouteParams || fallbackRouteParams.size === 0)) {
+        const tag = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${url.pathname}`;
+        tags.add(tag);
+    }
+    if (tags.has(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`)) {
+        tags.add(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/index`);
+    }
+    if (tags.has(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/index`)) {
+        tags.add(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`);
+    }
+    const tagsArray = Array.from(tags);
+    return {
+        tags: tagsArray,
+        expirationsByCacheKind: createTagsExpirationsByCacheKind(tagsArray)
+    };
+}
+
+//# sourceMappingURL=implicit-tags.js.map

package/webapp-dist/vendor/next/dist/server/lib/incremental-cache/file-system-cache.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return FileSystemCache;
+    }
+});
+const _responsecache = require("../../response-cache");
+const _path = /*#__PURE__*/ _interop_require_default(require("../../../shared/lib/isomorphic/path"));
+const _constants = require("../../../lib/constants");
+const _tagsmanifestexternal = require("./tags-manifest.external");
+const _multifilewriter = require("../../../lib/multi-file-writer");
+const _memorycacheexternal = require("./memory-cache.external");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class FileSystemCache {
+    static #_ = this.debug = !!process.env.NEXT_PRIVATE_DEBUG_CACHE;
+    constructor(ctx){
+        this.fs = ctx.fs;
+        this.flushToDisk = ctx.flushToDisk;
+        this.serverDistDir = ctx.serverDistDir;
+        this.revalidatedTags = ctx.revalidatedTags;
+        if (ctx.maxMemoryCacheSize) {
+            if (!FileSystemCache.memoryCache) {
+                if (FileSystemCache.debug) {
+                    console.log('FileSystemCache: using memory store for fetch cache');
+                }
+                FileSystemCache.memoryCache = (0, _memorycacheexternal.getMemoryCache)(ctx.maxMemoryCacheSize);
+            } else if (FileSystemCache.debug) {
+                console.log('FileSystemCache: memory store already initialized');
+            }
+        } else if (FileSystemCache.debug) {
+            console.log('FileSystemCache: not using memory store for fetch cache');
+        }
+    }
+    resetRequestCache() {}
+    async revalidateTag(tags, durations) {
+        tags = typeof tags === 'string' ? [
+            tags
+        ] : tags;
+        if (FileSystemCache.debug) {
+            console.log('FileSystemCache: revalidateTag', tags, durations);
+        }
+        if (tags.length === 0) {
+            return;
+        }
+        const now = Date.now();
+        for (const tag of tags){
+            const existingEntry = _tagsmanifestexternal.tagsManifest.get(tag) || {};
+            if (durations) {
+                // Use provided durations directly
+                const updates = {
+                    ...existingEntry
+                };
+                // mark as stale immediately
+                updates.stale = now;
+                if (durations.expire !== undefined) {
+                    updates.expired = now + durations.expire * 1000 // Convert seconds to ms
+                    ;
+                }
+                _tagsmanifestexternal.tagsManifest.set(tag, updates);
+            } else {
+                // Update expired field for immediate expiration (default behavior when no durations provided)
+                _tagsmanifestexternal.tagsManifest.set(tag, {
+                    ...existingEntry,
+                    expired: now
+                });
+            }
+        }
+    }
+    async get(...args) {
+        var _FileSystemCache_memoryCache, _data_value, _data_value1, _data_value2, _data_value3;
+        const [key, ctx] = args;
+        const { kind } = ctx;
+        let data = (_FileSystemCache_memoryCache = FileSystemCache.memoryCache) == null ? void 0 : _FileSystemCache_memoryCache.get(key);
+        if (FileSystemCache.debug) {
+            if (kind === _responsecache.IncrementalCacheKind.FETCH) {
+                console.log('FileSystemCache: get', key, ctx.tags, kind, !!data);
+            } else {
+                console.log('FileSystemCache: get', key, kind, !!data);
+            }
+        }
+        // let's check the disk for seed data
+        if (!data && process.env.NEXT_RUNTIME !== 'edge') {
+            try {
+                if (kind === _responsecache.IncrementalCacheKind.APP_ROUTE) {
+                    const filePath = this.getFilePath(`${key}.body`, _responsecache.IncrementalCacheKind.APP_ROUTE);
+                    const fileData = await this.fs.readFile(filePath);
+                    const { mtime } = await this.fs.stat(filePath);
+                    const meta = JSON.parse(await this.fs.readFile(filePath.replace(/\.body$/, _constants.NEXT_META_SUFFIX), 'utf8'));
+                    data = {
+                        lastModified: mtime.getTime(),
+                        value: {
+                            kind: _responsecache.CachedRouteKind.APP_ROUTE,
+                            body: fileData,
+                            headers: meta.headers,
+                            status: meta.status
+                        }
+                    };
+                } else {
+                    const filePath = this.getFilePath(kind === _responsecache.IncrementalCacheKind.FETCH ? key : `${key}.html`, kind);
+                    const fileData = await this.fs.readFile(filePath, 'utf8');
+                    const { mtime } = await this.fs.stat(filePath);
+                    if (kind === _responsecache.IncrementalCacheKind.FETCH) {
+                        var _data_value4;
+                        const { tags, fetchIdx, fetchUrl } = ctx;
+                        if (!this.flushToDisk) return null;
+                        const lastModified = mtime.getTime();
+                        const parsedData = JSON.parse(fileData);
+                        data = {
+                            lastModified,
+                            value: parsedData
+                        };
+                        if (((_data_value4 = data.value) == null ? void 0 : _data_value4.kind) === _responsecache.CachedRouteKind.FETCH) {
+                            var _data_value5;
+                            const storedTags = (_data_value5 = data.value) == null ? void 0 : _data_value5.tags;
+                            // update stored tags if a new one is being added
+                            // TODO: remove this when we can send the tags
+                            // via header on GET same as SET
+                            if (!(tags == null ? void 0 : tags.every((tag)=>storedTags == null ? void 0 : storedTags.includes(tag)))) {
+                                if (FileSystemCache.debug) {
+                                    console.log('FileSystemCache: tags vs storedTags mismatch', tags, storedTags);
+                                }
+                                await this.set(key, data.value, {
+                                    fetchCache: true,
+                                    tags,
+                                    fetchIdx,
+                                    fetchUrl
+                                });
+                            }
+                        }
+                    } else if (kind === _responsecache.IncrementalCacheKind.APP_PAGE) {
+                        // We try to load the metadata file, but if it fails, we don't
+                        // error. We also don't load it if this is a fallback.
+                        let meta;
+                        try {
+                            meta = JSON.parse(await this.fs.readFile(filePath.replace(/\.html$/, _constants.NEXT_META_SUFFIX), 'utf8'));
+                        } catch  {}
+                        let maybeSegmentData;
+                        if (meta == null ? void 0 : meta.segmentPaths) {
+                            // Collect all the segment data for this page.
+                            // TODO: To optimize file system reads, we should consider creating
+                            // separate cache entries for each segment, rather than storing them
+                            // all on the page's entry. Though the behavior is
+                            // identical regardless.
+                            const segmentData = new Map();
+                            maybeSegmentData = segmentData;
+                            const segmentsDir = key + _constants.RSC_SEGMENTS_DIR_SUFFIX;
+                            await Promise.all(meta.segmentPaths.map(async (segmentPath)=>{
+                                const segmentDataFilePath = this.getFilePath(segmentsDir + segmentPath + _constants.RSC_SEGMENT_SUFFIX, _responsecache.IncrementalCacheKind.APP_PAGE);
+                                try {
+                                    segmentData.set(segmentPath, await this.fs.readFile(segmentDataFilePath));
+                                } catch  {
+                                // This shouldn't happen, but if for some reason we fail to
+                                // load a segment from the filesystem, treat it the same as if
+                                // the segment is dynamic and does not have a prefetch.
+                                }
+                            }));
+                        }
+                        let rscData;
+                        if (!ctx.isFallback && !ctx.isRoutePPREnabled) {
+                            rscData = await this.fs.readFile(this.getFilePath(`${key}${_constants.RSC_SUFFIX}`, _responsecache.IncrementalCacheKind.APP_PAGE));
+                        }
+                        data = {
+                            lastModified: mtime.getTime(),
+                            value: {
+                                kind: _responsecache.CachedRouteKind.APP_PAGE,
+                                html: fileData,
+                                rscData,
+                                postponed: meta == null ? void 0 : meta.postponed,
+                                headers: meta == null ? void 0 : meta.headers,
+                                status: meta == null ? void 0 : meta.status,
+                                segmentData: maybeSegmentData
+                            }
+                        };
+                    } else if (kind === _responsecache.IncrementalCacheKind.PAGES) {
+                        let meta;
+                        let pageData = {};
+                        if (!ctx.isFallback) {
+                            pageData = JSON.parse(await this.fs.readFile(this.getFilePath(`${key}${_constants.NEXT_DATA_SUFFIX}`, _responsecache.IncrementalCacheKind.PAGES), 'utf8'));
+                        }
+                        data = {
+                            lastModified: mtime.getTime(),
+                            value: {
+                                kind: _responsecache.CachedRouteKind.PAGES,
+                                html: fileData,
+                                pageData,
+                                headers: meta == null ? void 0 : meta.headers,
+                                status: meta == null ? void 0 : meta.status
+                            }
+                        };
+                    } else {
+                        throw Object.defineProperty(new Error(`Invariant: Unexpected route kind ${kind} in file system cache.`), "__NEXT_ERROR_CODE", {
+                            value: "E445",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                }
+                if (data) {
+                    var _FileSystemCache_memoryCache1;
+                    (_FileSystemCache_memoryCache1 = FileSystemCache.memoryCache) == null ? void 0 : _FileSystemCache_memoryCache1.set(key, data);
+                }
+            } catch  {
+                return null;
+            }
+        }
+        if ((data == null ? void 0 : (_data_value = data.value) == null ? void 0 : _data_value.kind) === _responsecache.CachedRouteKind.APP_PAGE || (data == null ? void 0 : (_data_value1 = data.value) == null ? void 0 : _data_value1.kind) === _responsecache.CachedRouteKind.APP_ROUTE || (data == null ? void 0 : (_data_value2 = data.value) == null ? void 0 : _data_value2.kind) === _responsecache.CachedRouteKind.PAGES) {
+            var _data_value_headers;
+            const tagsHeader = (_data_value_headers = data.value.headers) == null ? void 0 : _data_value_headers[_constants.NEXT_CACHE_TAGS_HEADER];
+            if (typeof tagsHeader === 'string') {
+                const cacheTags = tagsHeader.split(',');
+                // we trigger a blocking validation if an ISR page
+                // had a tag revalidated, if we want to be a background
+                // revalidation instead we return data.lastModified = -1
+                if (cacheTags.length > 0 && (0, _tagsmanifestexternal.areTagsExpired)(cacheTags, data.lastModified)) {
+                    if (FileSystemCache.debug) {
+                        console.log('FileSystemCache: expired tags', cacheTags);
+                    }
+                    return null;
+                }
+            }
+        } else if ((data == null ? void 0 : (_data_value3 = data.value) == null ? void 0 : _data_value3.kind) === _responsecache.CachedRouteKind.FETCH) {
+            const combinedTags = ctx.kind === _responsecache.IncrementalCacheKind.FETCH ? [
+                ...ctx.tags || [],
+                ...ctx.softTags || []
+            ] : [];
+            // When revalidate tag is called we don't return stale data so it's
+            // updated right away.
+            if (combinedTags.some((tag)=>this.revalidatedTags.includes(tag))) {
+                if (FileSystemCache.debug) {
+                    console.log('FileSystemCache: was revalidated', combinedTags);
+                }
+                return null;
+            }
+            if ((0, _tagsmanifestexternal.areTagsExpired)(combinedTags, data.lastModified)) {
+                if (FileSystemCache.debug) {
+                    console.log('FileSystemCache: expired tags', combinedTags);
+                }
+                return null;
+            }
+        }
+        return data ?? null;
+    }
+    async set(key, data, ctx) {
+        var _FileSystemCache_memoryCache;
+        (_FileSystemCache_memoryCache = FileSystemCache.memoryCache) == null ? void 0 : _FileSystemCache_memoryCache.set(key, {
+            value: data,
+            lastModified: Date.now()
+        });
+        if (FileSystemCache.debug) {
+            console.log('FileSystemCache: set', key);
+        }
+        if (!this.flushToDisk || !data) return;
+        // Create a new writer that will prepare to write all the files to disk
+        // after their containing directory is created.
+        const writer = new _multifilewriter.MultiFileWriter(this.fs);
+        if (data.kind === _responsecache.CachedRouteKind.APP_ROUTE) {
+            const filePath = this.getFilePath(`${key}.body`, _responsecache.IncrementalCacheKind.APP_ROUTE);
+            writer.append(filePath, data.body);
+            const meta = {
+                headers: data.headers,
+                status: data.status,
+                postponed: undefined,
+                segmentPaths: undefined
+            };
+            writer.append(filePath.replace(/\.body$/, _constants.NEXT_META_SUFFIX), JSON.stringify(meta, null, 2));
+        } else if (data.kind === _responsecache.CachedRouteKind.PAGES || data.kind === _responsecache.CachedRouteKind.APP_PAGE) {
+            const isAppPath = data.kind === _responsecache.CachedRouteKind.APP_PAGE;
+            const htmlPath = this.getFilePath(`${key}.html`, isAppPath ? _responsecache.IncrementalCacheKind.APP_PAGE : _responsecache.IncrementalCacheKind.PAGES);
+            writer.append(htmlPath, data.html);
+            // Fallbacks don't generate a data file.
+            if (!ctx.fetchCache && !ctx.isFallback && !ctx.isRoutePPREnabled) {
+                writer.append(this.getFilePath(`${key}${isAppPath ? _constants.RSC_SUFFIX : _constants.NEXT_DATA_SUFFIX}`, isAppPath ? _responsecache.IncrementalCacheKind.APP_PAGE : _responsecache.IncrementalCacheKind.PAGES), isAppPath ? data.rscData : JSON.stringify(data.pageData));
+            }
+            if ((data == null ? void 0 : data.kind) === _responsecache.CachedRouteKind.APP_PAGE) {
+                let segmentPaths;
+                if (data.segmentData) {
+                    segmentPaths = [];
+                    const segmentsDir = htmlPath.replace(/\.html$/, _constants.RSC_SEGMENTS_DIR_SUFFIX);
+                    for (const [segmentPath, buffer] of data.segmentData){
+                        segmentPaths.push(segmentPath);
+                        const segmentDataFilePath = segmentsDir + segmentPath + _constants.RSC_SEGMENT_SUFFIX;
+                        writer.append(segmentDataFilePath, buffer);
+                    }
+                }
+                const meta = {
+                    headers: data.headers,
+                    status: data.status,
+                    postponed: data.postponed,
+                    segmentPaths
+                };
+                writer.append(htmlPath.replace(/\.html$/, _constants.NEXT_META_SUFFIX), JSON.stringify(meta));
+            }
+        } else if (data.kind === _responsecache.CachedRouteKind.FETCH) {
+            const filePath = this.getFilePath(key, _responsecache.IncrementalCacheKind.FETCH);
+            writer.append(filePath, JSON.stringify({
+                ...data,
+                tags: ctx.fetchCache ? ctx.tags : []
+            }));
+        }
+        // Wait for all FS operations to complete.
+        await writer.wait();
+    }
+    getFilePath(pathname, kind) {
+        switch(kind){
+            case _responsecache.IncrementalCacheKind.FETCH:
+                // we store in .next/cache/fetch-cache so it can be persisted
+                // across deploys
+                return _path.default.join(this.serverDistDir, '..', 'cache', 'fetch-cache', pathname);
+            case _responsecache.IncrementalCacheKind.PAGES:
+                return _path.default.join(this.serverDistDir, 'pages', pathname);
+            case _responsecache.IncrementalCacheKind.IMAGE:
+            case _responsecache.IncrementalCacheKind.APP_PAGE:
+            case _responsecache.IncrementalCacheKind.APP_ROUTE:
+                return _path.default.join(this.serverDistDir, 'app', pathname);
+            default:
+                throw Object.defineProperty(new Error(`Unexpected file path kind: ${kind}`), "__NEXT_ERROR_CODE", {
+                    value: "E479",
+                    enumerable: false,
+                    configurable: true
+                });
+        }
+    }
+}
+
+//# sourceMappingURL=file-system-cache.js.map