qalita 2.5.2__py3-none-any.whl → 2.5.4__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/server/lib/clone-response.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cloneResponse", {
+    enumerable: true,
+    get: function() {
+        return cloneResponse;
+    }
+});
+const noop = ()=>{};
+let registry;
+if (globalThis.FinalizationRegistry) {
+    registry = new FinalizationRegistry((weakRef)=>{
+        const stream = weakRef.deref();
+        if (stream && !stream.locked) {
+            stream.cancel('Response object has been garbage collected').then(noop);
+        }
+    });
+}
+function cloneResponse(original) {
+    // If the response has no body, then we can just return the original response
+    // twice because it's immutable.
+    if (!original.body) {
+        return [
+            original,
+            original
+        ];
+    }
+    const [body1, body2] = original.body.tee();
+    const cloned1 = new Response(body1, {
+        status: original.status,
+        statusText: original.statusText,
+        headers: original.headers
+    });
+    Object.defineProperty(cloned1, 'url', {
+        value: original.url,
+        // How the original response.url behaves
+        configurable: true,
+        enumerable: true,
+        writable: false
+    });
+    // The Fetch Standard allows users to skip consuming the response body by
+    // relying on garbage collection to release connection resources.
+    // https://github.com/nodejs/undici?tab=readme-ov-file#garbage-collection
+    //
+    // To cancel the stream you then need to cancel both resulting branches.
+    // Teeing a stream will generally lock it for the duration, preventing other
+    // readers from locking it.
+    // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/tee
+    // cloned2 is stored in a react cache and cloned for subsequent requests.
+    // It is the original request, and is is garbage collected by a
+    // FinalizationRegistry in Undici, but since we're tee-ing the stream
+    // ourselves, we need to cancel clone1's stream (the response returned from
+    // our dedupe fetch) when clone1 is reclaimed, otherwise we leak memory.
+    if (registry && cloned1.body) {
+        registry.register(cloned1, new WeakRef(cloned1.body));
+    }
+    const cloned2 = new Response(body2, {
+        status: original.status,
+        statusText: original.statusText,
+        headers: original.headers
+    });
+    Object.defineProperty(cloned2, 'url', {
+        value: original.url,
+        // How the original response.url behaves
+        configurable: true,
+        enumerable: true,
+        writable: false
+    });
+    return [
+        cloned1,
+        cloned2
+    ];
+}
+
+//# sourceMappingURL=clone-response.js.map

qalita/_frontend/node_modules/next/dist/server/lib/cpu-profile.js

@@ -0,0 +1,28 @@
+"use strict";
+const privateCpuProfileName = process.env.__NEXT_PRIVATE_CPU_PROFILE;
+const isCpuProfileEnabled = process.env.NEXT_CPU_PROF || privateCpuProfileName;
+if (isCpuProfileEnabled) {
+    const { Session } = require('inspector');
+    const fs = require('fs');
+    const session = new Session();
+    session.connect();
+    session.post('Profiler.enable');
+    session.post('Profiler.start');
+    function saveProfile() {
+        session.post('Profiler.stop', (error, param)=>{
+            if (error) {
+                console.error('Cannot generate CPU profiling:', error);
+                return;
+            }
+            // Write profile to disk
+            const filename = `${privateCpuProfileName || 'CPU.main'}.${Date.now()}.cpuprofile`;
+            fs.writeFileSync(`./${filename}`, JSON.stringify(param.profile));
+            process.exit(0);
+        });
+    }
+    process.on('SIGINT', saveProfile);
+    process.on('SIGTERM', saveProfile);
+    process.on('exit', saveProfile);
+}
+
+//# sourceMappingURL=cpu-profile.js.map

qalita/_frontend/node_modules/next/dist/server/lib/decode-query-path-parameter.js

@@ -0,0 +1,26 @@
+/**
+ * Decodes a query path parameter.
+ *
+ * @param value - The value to decode.
+ * @returns The decoded value.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "decodeQueryPathParameter", {
+    enumerable: true,
+    get: function() {
+        return decodeQueryPathParameter;
+    }
+});
+function decodeQueryPathParameter(value) {
+    // When deployed to Vercel, the value may be encoded, so this attempts to
+    // decode it and returns the original value if it fails.
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return value;
+    }
+}
+
+//# sourceMappingURL=decode-query-path-parameter.js.map

qalita/_frontend/node_modules/next/dist/server/lib/dedupe-fetch.js

@@ -0,0 +1,163 @@
+/**
+ * Based on https://github.com/facebook/react/blob/d4e78c42a94be027b4dc7ed2659a5fddfbf9bd4e/packages/react/src/ReactFetch.js
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createDedupeFetch", {
+    enumerable: true,
+    get: function() {
+        return createDedupeFetch;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _cloneresponse = require("./clone-response");
+const _invarianterror = require("../../shared/lib/invariant-error");
+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 (!nodeInterop && 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 simpleCacheKey = '["GET",[],null,"follow",null,null,null,null]' // generateCacheKey(new Request('https://blank'));
+;
+// Headers that should not affect deduplication
+// traceparent and tracestate are used for distributed tracing and should not affect cache keys
+const headersToExcludeInCacheKey = new Set([
+    'traceparent',
+    'tracestate'
+]);
+function generateCacheKey(request) {
+    // We pick the fields that goes into the key used to dedupe requests.
+    // We don't include the `cache` field, because we end up using whatever
+    // caching resulted from the first request.
+    // Notably we currently don't consider non-standard (or future) options.
+    // This might not be safe. TODO: warn for non-standard extensions differing.
+    // IF YOU CHANGE THIS UPDATE THE simpleCacheKey ABOVE.
+    const filteredHeaders = Array.from(request.headers.entries()).filter(([key])=>!headersToExcludeInCacheKey.has(key.toLowerCase()));
+    return JSON.stringify([
+        request.method,
+        filteredHeaders,
+        request.mode,
+        request.redirect,
+        request.credentials,
+        request.referrer,
+        request.referrerPolicy,
+        request.integrity
+    ]);
+}
+function createDedupeFetch(originalFetch) {
+    const getCacheEntries = _react.cache(// eslint-disable-next-line @typescript-eslint/no-unused-vars -- url is the cache key
+    (url)=>[]);
+    return function dedupeFetch(resource, options) {
+        if (options && options.signal) {
+            // If we're passed a signal, then we assume that
+            // someone else controls the lifetime of this object and opts out of
+            // caching. It's effectively the opt-out mechanism.
+            // Ideally we should be able to check this on the Request but
+            // it always gets initialized with its own signal so we don't
+            // know if it's supposed to override - unless we also override the
+            // Request constructor.
+            return originalFetch(resource, options);
+        }
+        // Normalize the Request
+        let url;
+        let cacheKey;
+        if (typeof resource === 'string' && !options) {
+            // Fast path.
+            cacheKey = simpleCacheKey;
+            url = resource;
+        } else {
+            // Normalize the request.
+            // if resource is not a string or a URL (its an instance of Request)
+            // then do not instantiate a new Request but instead
+            // reuse the request as to not disturb the body in the event it's a ReadableStream.
+            const request = typeof resource === 'string' || resource instanceof URL ? new Request(resource, options) : resource;
+            if (request.method !== 'GET' && request.method !== 'HEAD' || request.keepalive) {
+                // We currently don't dedupe requests that might have side-effects. Those
+                // have to be explicitly cached. We assume that the request doesn't have a
+                // body if it's GET or HEAD.
+                // keepalive gets treated the same as if you passed a custom cache signal.
+                return originalFetch(resource, options);
+            }
+            cacheKey = generateCacheKey(request);
+            url = request.url;
+        }
+        const cacheEntries = getCacheEntries(url);
+        for(let i = 0, j = cacheEntries.length; i < j; i += 1){
+            const [key, promise] = cacheEntries[i];
+            if (key === cacheKey) {
+                return promise.then(()=>{
+                    const response = cacheEntries[i][2];
+                    if (!response) throw Object.defineProperty(new _invarianterror.InvariantError('No cached response'), "__NEXT_ERROR_CODE", {
+                        value: "E579",
+                        enumerable: false,
+                        configurable: true
+                    });
+                    // We're cloning the response using this utility because there exists
+                    // a bug in the undici library around response cloning. See the
+                    // following pull request for more details:
+                    // https://github.com/vercel/next.js/pull/73274
+                    const [cloned1, cloned2] = (0, _cloneresponse.cloneResponse)(response);
+                    cacheEntries[i][2] = cloned2;
+                    return cloned1;
+                });
+            }
+        }
+        // We pass the original arguments here in case normalizing the Request
+        // doesn't include all the options in this environment.
+        const promise = originalFetch(resource, options);
+        const entry = [
+            cacheKey,
+            promise,
+            null
+        ];
+        cacheEntries.push(entry);
+        return promise.then((response)=>{
+            // We're cloning the response using this utility because there exists
+            // a bug in the undici library around response cloning. See the
+            // following pull request for more details:
+            // https://github.com/vercel/next.js/pull/73274
+            const [cloned1, cloned2] = (0, _cloneresponse.cloneResponse)(response);
+            entry[2] = cloned2;
+            return cloned1;
+        });
+    };
+}
+
+//# sourceMappingURL=dedupe-fetch.js.map

qalita/_frontend/node_modules/next/dist/server/lib/dev-bundler-service.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DevBundlerService", {
+    enumerable: true,
+    get: function() {
+        return DevBundlerService;
+    }
+});
+const _lrucache = require("./lru-cache");
+const _mockrequest = require("./mock-request");
+const _hotreloadertypes = require("../dev/hot-reloader-types");
+class DevBundlerService {
+    constructor(bundler, handler){
+        this.bundler = bundler;
+        this.handler = handler;
+        this.ensurePage = async (definition)=>{
+            // TODO: remove after ensure is pulled out of server
+            return await this.bundler.hotReloader.ensurePage(definition);
+        };
+        this.logErrorWithOriginalStack = this.bundler.logErrorWithOriginalStack.bind(this.bundler);
+        this.appIsrManifestInner = new _lrucache.LRUCache(8000, function length() {
+            return 16;
+        });
+    }
+    async getFallbackErrorComponents(url) {
+        await this.bundler.hotReloader.buildFallbackError();
+        // Build the error page to ensure the fallback is built too.
+        // TODO: See if this can be moved into hotReloader or removed.
+        await this.bundler.hotReloader.ensurePage({
+            page: '/_error',
+            clientOnly: false,
+            definition: undefined,
+            url
+        });
+    }
+    async getCompilationError(page) {
+        const errors = await this.bundler.hotReloader.getCompilationErrors(page);
+        if (!errors) return;
+        // Return the very first error we found.
+        return errors[0];
+    }
+    async revalidate({ urlPath, revalidateHeaders, opts: revalidateOpts }) {
+        const mocked = (0, _mockrequest.createRequestResponseMocks)({
+            url: urlPath,
+            headers: revalidateHeaders
+        });
+        await this.handler(mocked.req, mocked.res);
+        await mocked.res.hasStreamed;
+        if (mocked.res.getHeader('x-nextjs-cache') !== 'REVALIDATED' && mocked.res.statusCode !== 200 && !(mocked.res.statusCode === 404 && revalidateOpts.unstable_onlyGenerated)) {
+            throw Object.defineProperty(new Error(`Invalid response ${mocked.res.statusCode}`), "__NEXT_ERROR_CODE", {
+                value: "E175",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        return {};
+    }
+    get appIsrManifest() {
+        const serializableManifest = {};
+        for (const [key, value] of this.appIsrManifestInner){
+            serializableManifest[key] = value;
+        }
+        return serializableManifest;
+    }
+    setCacheStatus(status, htmlRequestId) {
+        this.bundler.hotReloader.setCacheStatus(status, htmlRequestId);
+    }
+    setIsrStatus(key, value) {
+        var // Only send the ISR manifest to legacy clients, i.e. Pages Router clients,
+        // or App Router clients that have Cache Components disabled. The ISR
+        // manifest is only used to inform the static indicator, which currently
+        // does not provide useful information if Cache Components is enabled due to
+        // its binary nature (i.e. it does not support showing info for partially
+        // static pages).
+        _this_bundler_hotReloader, _this_bundler;
+        if (value === undefined) {
+            this.appIsrManifestInner.remove(key);
+        } else {
+            this.appIsrManifestInner.set(key, value);
+        }
+        (_this_bundler = this.bundler) == null ? void 0 : (_this_bundler_hotReloader = _this_bundler.hotReloader) == null ? void 0 : _this_bundler_hotReloader.sendToLegacyClients({
+            type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.ISR_MANIFEST,
+            data: this.appIsrManifest
+        });
+    }
+    setReactDebugChannel(debugChannel, htmlRequestId, requestId) {
+        this.bundler.hotReloader.setReactDebugChannel(debugChannel, htmlRequestId, requestId);
+    }
+    close() {
+        this.bundler.hotReloader.close();
+    }
+    triggerHMR(message) {
+        this.bundler.hotReloader.send(message);
+    }
+}
+
+//# sourceMappingURL=dev-bundler-service.js.map

qalita/_frontend/node_modules/next/dist/server/lib/etag.js

@@ -0,0 +1,56 @@
+/**
+ * FNV-1a Hash implementation
+ * @author Travis Webb (tjwebb) <me@traviswebb.com>
+ *
+ * Ported from https://github.com/tjwebb/fnv-plus/blob/master/index.js
+ *
+ * Simplified, optimized and add modified for 52 bit, which provides a larger hash space
+ * and still making use of Javascript's 53-bit integer space.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    fnv1a52: null,
+    generateETag: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    fnv1a52: function() {
+        return fnv1a52;
+    },
+    generateETag: function() {
+        return generateETag;
+    }
+});
+const fnv1a52 = (str)=>{
+    const len = str.length;
+    let i = 0, t0 = 0, v0 = 0x2325, t1 = 0, v1 = 0x8422, t2 = 0, v2 = 0x9ce4, t3 = 0, v3 = 0xcbf2;
+    while(i < len){
+        v0 ^= str.charCodeAt(i++);
+        t0 = v0 * 435;
+        t1 = v1 * 435;
+        t2 = v2 * 435;
+        t3 = v3 * 435;
+        t2 += v0 << 8;
+        t3 += v1 << 8;
+        t1 += t0 >>> 16;
+        v0 = t0 & 65535;
+        t2 += t1 >>> 16;
+        v1 = t1 & 65535;
+        v3 = t3 + (t2 >>> 16) & 65535;
+        v2 = t2 & 65535;
+    }
+    return (v3 & 15) * 281474976710656 + v2 * 4294967296 + v1 * 65536 + (v0 ^ v3 >> 4);
+};
+const generateETag = (payload, weak = false)=>{
+    const prefix = weak ? 'W/"' : '"';
+    return prefix + fnv1a52(payload).toString(36) + payload.length.toString(36) + '"';
+};
+
+//# sourceMappingURL=etag.js.map

qalita/_frontend/node_modules/next/dist/server/lib/experimental/create-env-definitions.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createEnvDefinitions", {
+    enumerable: true,
+    get: function() {
+        return createEnvDefinitions;
+    }
+});
+const _nodepath = require("node:path");
+const _promises = require("node:fs/promises");
+async function createEnvDefinitions({ distDir, loadedEnvFiles }) {
+    const envLines = [];
+    const seenKeys = new Set();
+    // env files are in order of priority
+    for (const { path, env } of loadedEnvFiles){
+        for(const key in env){
+            if (!seenKeys.has(key)) {
+                envLines.push(`      /** Loaded from \`${path}\` */`);
+                envLines.push(`      ${key}?: string`);
+                seenKeys.add(key);
+            }
+        }
+    }
+    const envStr = envLines.join('\n');
+    const definitionStr = `// Type definitions for Next.js environment variables
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+${envStr}
+    }
+  }
+}
+export {}`;
+    if (process.env.NODE_ENV === 'test') {
+        return definitionStr;
+    }
+    try {
+        // we expect the types directory to already exist
+        const envDtsPath = (0, _nodepath.join)(distDir, 'types', 'env.d.ts');
+        await (0, _promises.writeFile)(envDtsPath, definitionStr, 'utf-8');
+    } catch (e) {
+        console.error('Failed to write env.d.ts:', e);
+    }
+}
+
+//# sourceMappingURL=create-env-definitions.js.map

qalita/_frontend/node_modules/next/dist/server/lib/experimental/ppr.js

@@ -0,0 +1,47 @@
+/**
+ * If set to `incremental`, only those leaf pages that export
+ * `experimental_ppr = true` will have partial prerendering enabled. If any
+ * page exports this value as `false` or does not export it at all will not
+ * have partial prerendering enabled. If set to a boolean, the options for
+ * `experimental_ppr` will be ignored.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    checkIsAppPPREnabled: null,
+    checkIsRoutePPREnabled: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    checkIsAppPPREnabled: function() {
+        return checkIsAppPPREnabled;
+    },
+    checkIsRoutePPREnabled: function() {
+        return checkIsRoutePPREnabled;
+    }
+});
+function checkIsAppPPREnabled(config) {
+    // If the config is undefined, partial prerendering is disabled.
+    if (typeof config === 'undefined') return false;
+    // If the config is a boolean, use it directly.
+    if (typeof config === 'boolean') return config;
+    // If the config is a string, it must be 'incremental' to enable partial
+    // prerendering.
+    if (config === 'incremental') return true;
+    return false;
+}
+function checkIsRoutePPREnabled(config) {
+    // If the config is undefined, partial prerendering is disabled.
+    if (typeof config === 'undefined') return false;
+    // If the config is a boolean, use it directly.
+    if (typeof config === 'boolean') return config;
+    return false;
+}
+
+//# sourceMappingURL=ppr.js.map

qalita/_frontend/node_modules/next/dist/server/lib/find-page-file.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createValidFileMatcher: null,
+    findPageFile: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createValidFileMatcher: function() {
+        return createValidFileMatcher;
+    },
+    findPageFile: function() {
+        return findPageFile;
+    }
+});
+const _fileexists = require("../../lib/file-exists");
+const _getpagepaths = require("../../shared/lib/page-path/get-page-paths");
+const _nonnullable = require("../../lib/non-nullable");
+const _path = require("path");
+const _fs = require("fs");
+const _log = require("../../build/output/log");
+const _picocolors = require("../../lib/picocolors");
+const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
+async function isTrueCasePagePath(pagePath, pagesDir) {
+    const pageSegments = (0, _path.normalize)(pagePath).split(_path.sep).filter(Boolean);
+    const segmentExistsPromises = pageSegments.map(async (segment, i)=>{
+        const segmentParentDir = (0, _path.join)(pagesDir, ...pageSegments.slice(0, i));
+        const parentDirEntries = await _fs.promises.readdir(segmentParentDir);
+        return parentDirEntries.includes(segment);
+    });
+    return (await Promise.all(segmentExistsPromises)).every(Boolean);
+}
+async function findPageFile(pagesDir, normalizedPagePath, pageExtensions, isAppDir) {
+    const pagePaths = (0, _getpagepaths.getPagePaths)(normalizedPagePath, pageExtensions, isAppDir);
+    const [existingPath, ...others] = (await Promise.all(pagePaths.map(async (path)=>{
+        const filePath = (0, _path.join)(pagesDir, path);
+        try {
+            return await (0, _fileexists.fileExists)(filePath) ? path : null;
+        } catch (err) {
+            var _err_code;
+            if (!(err == null ? void 0 : (_err_code = err.code) == null ? void 0 : _err_code.includes('ENOTDIR'))) throw err;
+        }
+        return null;
+    }))).filter(_nonnullable.nonNullable);
+    if (!existingPath) {
+        return null;
+    }
+    if (!await isTrueCasePagePath(existingPath, pagesDir)) {
+        return null;
+    }
+    if (others.length > 0) {
+        (0, _log.warn)(`Duplicate page detected. ${(0, _picocolors.cyan)((0, _path.join)('pages', existingPath))} and ${(0, _picocolors.cyan)((0, _path.join)('pages', others[0]))} both resolve to ${(0, _picocolors.cyan)(normalizedPagePath)}.`);
+    }
+    return existingPath;
+}
+function createValidFileMatcher(pageExtensions, appDirPath) {
+    const getExtensionRegexString = (extensions)=>`(?:${extensions.join('|')})`;
+    const validExtensionFileRegex = new RegExp('\\.' + getExtensionRegexString(pageExtensions) + '$');
+    const leafOnlyPageFileRegex = new RegExp(`(^(page|route)|[\\\\/](page|route))\\.${getExtensionRegexString(pageExtensions)}$`);
+    const leafOnlyRouteFileRegex = new RegExp(`(^route|[\\\\/]route)\\.${getExtensionRegexString(pageExtensions)}$`);
+    const leafOnlyLayoutFileRegex = new RegExp(`(^(layout)|[\\\\/](layout))\\.${getExtensionRegexString(pageExtensions)}$`);
+    const rootNotFoundFileRegex = new RegExp(`^not-found\\.${getExtensionRegexString(pageExtensions)}$`);
+    const leafOnlyDefaultFileRegex = new RegExp(`(^(default)|[\\\\/](default))\\.${getExtensionRegexString(pageExtensions)}$`);
+    /** TODO-METADATA: support other metadata routes
+   *  regex for:
+   *
+   * /robots.txt|<ext>
+   * /sitemap.xml|<ext>
+   * /favicon.ico
+   * /manifest.json|<ext>
+   * <route>/icon.png|jpg|<ext>
+   * <route>/apple-touch-icon.png|jpg|<ext>
+   *
+   */ /**
+   * Match the file if it's a metadata route file, static: if the file is a static metadata file.
+   * It needs to be a file which doesn't match the custom metadata routes e.g. `app/robots.txt/route.js`
+   */ function isMetadataFile(filePath) {
+        const appDirRelativePath = appDirPath ? filePath.replace(appDirPath, '') : filePath;
+        return (0, _ismetadataroute.isMetadataRouteFile)(appDirRelativePath, pageExtensions, true);
+    }
+    // Determine if the file is leaf node page file or route file under layouts,
+    // 'page.<extension>' | 'route.<extension>'
+    function isAppRouterPage(filePath) {
+        return leafOnlyPageFileRegex.test(filePath) || isMetadataFile(filePath);
+    }
+    // Determine if the file is leaf node route file under app directory
+    function isAppRouterRoute(filePath) {
+        return leafOnlyRouteFileRegex.test(filePath);
+    }
+    function isAppLayoutPage(filePath) {
+        return leafOnlyLayoutFileRegex.test(filePath);
+    }
+    function isAppDefaultPage(filePath) {
+        return leafOnlyDefaultFileRegex.test(filePath);
+    }
+    function isPageFile(filePath) {
+        return validExtensionFileRegex.test(filePath) || isMetadataFile(filePath);
+    }
+    function isRootNotFound(filePath) {
+        if (!appDirPath) {
+            return false;
+        }
+        if (!filePath.startsWith(appDirPath + _path.sep)) {
+            return false;
+        }
+        const rest = filePath.slice(appDirPath.length + 1);
+        return rootNotFoundFileRegex.test(rest);
+    }
+    return {
+        isPageFile,
+        isAppRouterPage,
+        isAppRouterRoute,
+        isAppLayoutPage,
+        isAppDefaultPage,
+        isMetadataFile,
+        isRootNotFound
+    };
+}
+
+//# sourceMappingURL=find-page-file.js.map