qalita 2.3.2__py3-none-any.whl → 2.5.3__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/build/webpack/loaders/next-metadata-route-loader.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    getFilenameAndExtension: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    getFilenameAndExtension: function() {
+        return getFilenameAndExtension;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _mimetype = require("../../../lib/mime-type");
+const _utils = require("./utils");
+const _installbindings = require("../../swc/install-bindings");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function errorOnBadHandler(resourcePath) {
+    return `
+  if (typeof handler !== 'function') {
+    throw new Error('Default export is missing in ${JSON.stringify(resourcePath)}')
+  }
+  `;
+}
+/* re-export the userland route configs */ async function createReExportsCode(resourcePath, loaderContext) {
+    const exportNames = await (0, _utils.getLoaderModuleNamedExports)(resourcePath, loaderContext);
+    // Re-export configs but avoid conflicted exports
+    const reExportNames = exportNames.filter((name)=>name !== 'default' && name !== 'generateSitemaps' && name !== 'dynamicParams');
+    return reExportNames.length > 0 ? `export { ${reExportNames.join(', ')} } from ${JSON.stringify(resourcePath)}\n` : '';
+}
+const CACHE_HEADERS = {
+    NO_CACHE: 'no-cache, no-store',
+    REVALIDATE: 'public, max-age=0, must-revalidate'
+};
+function getFilenameAndExtension(resourcePath) {
+    const filename = _path.default.basename(resourcePath);
+    const [name, ext] = filename.split('.', 2);
+    return {
+        name,
+        ext
+    };
+}
+function getContentType(resourcePath) {
+    let { name, ext } = getFilenameAndExtension(resourcePath);
+    if (ext === 'jpg') ext = 'jpeg';
+    if (name === 'favicon' && ext === 'ico') return 'image/x-icon';
+    if (name === 'sitemap') return 'application/xml';
+    if (name === 'robots') return 'text/plain';
+    if (name === 'manifest') return 'application/manifest+json';
+    if (ext === 'png' || ext === 'jpeg' || ext === 'ico' || ext === 'svg') {
+        return _mimetype.imageExtMimeTypeMap[ext];
+    }
+    return 'text/plain';
+}
+async function getStaticAssetRouteCode(resourcePath, fileBaseName) {
+    const cache = process.env.NODE_ENV !== 'production' ? CACHE_HEADERS.NO_CACHE : CACHE_HEADERS.REVALIDATE;
+    const isTwitter = fileBaseName === 'twitter-image';
+    const isOpenGraph = fileBaseName === 'opengraph-image';
+    // Twitter image file size limit is 5MB.
+    // General Open Graph image file size limit is 8MB.
+    // x-ref: https://developer.x.com/en/docs/x-for-websites/cards/overview/summary
+    // x-ref(facebook): https://developers.facebook.com/docs/sharing/webmasters/images
+    const fileSizeLimit = isTwitter ? 5 : 8;
+    const imgName = isTwitter ? 'Twitter' : 'Open Graph';
+    const code = `\
+/* static asset route */
+import { NextResponse } from 'next/server'
+
+const contentType = ${JSON.stringify(getContentType(resourcePath))}
+const buffer = Buffer.from(${JSON.stringify((await _fs.default.promises.readFile(resourcePath)).toString('base64'))}, 'base64'
+  )
+
+if (${isTwitter || isOpenGraph}) {
+  const fileSizeInMB = buffer.byteLength / 1024 / 1024
+  if (fileSizeInMB > ${fileSizeLimit}) {
+    throw new Error('File size for ${imgName} image ${JSON.stringify(resourcePath)} exceeds ${fileSizeLimit}MB. ' +
+    \`(Current: \${fileSizeInMB.toFixed(2)}MB)\n\` +
+    'Read more: https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image#image-files-jpg-png-gif'
+    )
+  }
+}
+
+export function GET() {
+  return new NextResponse(buffer, {
+    headers: {
+      'Content-Type': contentType,
+      'Cache-Control': ${JSON.stringify(cache)},
+    },
+  })
+}
+
+export const dynamic = 'force-static'
+`;
+    return code;
+}
+async function getDynamicTextRouteCode(resourcePath, loaderContext) {
+    return `\
+/* dynamic asset route */
+import { NextResponse } from 'next/server'
+import handler from ${JSON.stringify(resourcePath)}
+import { resolveRouteData } from 'next/dist/build/webpack/loaders/metadata/resolve-route-data'
+
+const contentType = ${JSON.stringify(getContentType(resourcePath))}
+const fileType = ${JSON.stringify(getFilenameAndExtension(resourcePath).name)}
+
+${errorOnBadHandler(resourcePath)}
+${await createReExportsCode(resourcePath, loaderContext)}
+
+export async function GET() {
+  const data = await handler()
+  const content = resolveRouteData(data, fileType)
+
+  return new NextResponse(content, {
+    headers: {
+      'Content-Type': contentType,
+      'Cache-Control': ${JSON.stringify(CACHE_HEADERS.REVALIDATE)},
+    },
+  })
+}
+`;
+}
+async function getDynamicImageRouteCode(resourcePath, loaderContext) {
+    return `\
+/* dynamic image route with generateImageMetadata */
+import { NextResponse } from 'next/server'
+import { default as handler, generateImageMetadata } from ${JSON.stringify(resourcePath)}
+
+${errorOnBadHandler(resourcePath)}
+${await createReExportsCode(resourcePath, loaderContext)}
+
+export async function GET(_, ctx) {
+  const paramsPromise = ctx.params
+  const idPromise = paramsPromise.then(params => params?.__metadata_id__)
+  const restParamsPromise = paramsPromise.then(params => {
+    if (!params) return undefined
+    const { __metadata_id__, ...rest } = params
+    return rest
+  })
+
+  const restParams = await restParamsPromise
+  const __metadata_id__ = await idPromise
+  const imageMetadata = await generateImageMetadata({ params: restParams })
+  const id = imageMetadata.find((item) => {
+    if (item?.id == null) {
+      throw new Error('id property is required for every item returned from generateImageMetadata')
+    }
+
+    return item.id.toString() === __metadata_id__
+  })?.id
+
+  if (id == null) {
+    return new NextResponse('Not Found', {
+      status: 404,
+    })
+  }
+
+  return handler({ params: restParamsPromise, id: idPromise })
+}
+
+export async function generateStaticParams({ params }) {
+  const imageMetadata = await generateImageMetadata({ params })
+  const staticParams = []
+
+  for (const item of imageMetadata) {
+    if (item?.id == null) {
+      throw new Error('id property is required for every item returned from generateImageMetadata')
+    }
+    staticParams.push({ __metadata_id__: item.id.toString() })
+  }
+  return staticParams
+}
+`;
+}
+async function getSingleImageRouteCode(resourcePath, loaderContext) {
+    return `\
+/* dynamic image route without generateImageMetadata */
+import { NextResponse } from 'next/server'
+import { default as handler } from ${JSON.stringify(resourcePath)}
+
+${errorOnBadHandler(resourcePath)}
+${await createReExportsCode(resourcePath, loaderContext)}
+
+export async function GET(_, ctx) {
+  return handler({ params: ctx.params })
+}
+`;
+}
+// <metadata-image>/[id]/route.js
+async function getImageRouteCode(resourcePath, loaderContext) {
+    const exportNames = await (0, _utils.getLoaderModuleNamedExports)(resourcePath, loaderContext);
+    const hasGenerateParamsExport = exportNames.includes('generateImageMetadata');
+    if (hasGenerateParamsExport) {
+        return getDynamicImageRouteCode(resourcePath, loaderContext);
+    } else {
+        return getSingleImageRouteCode(resourcePath, loaderContext);
+    }
+}
+async function getSingleSitemapRouteCode(resourcePath, loaderContext) {
+    return `\
+/* single sitemap route */
+import { NextResponse } from 'next/server'
+import { default as handler } from ${JSON.stringify(resourcePath)}
+import { resolveRouteData } from 'next/dist/build/webpack/loaders/metadata/resolve-route-data'
+
+const contentType = ${JSON.stringify(getContentType(resourcePath))}
+const fileType = ${JSON.stringify(getFilenameAndExtension(resourcePath).name)}
+
+${errorOnBadHandler(resourcePath)}
+${await createReExportsCode(resourcePath, loaderContext)}
+
+export async function GET() {
+  const data = await handler()
+  const content = resolveRouteData(data, fileType)
+
+  return new NextResponse(content, {
+    headers: {
+      'Content-Type': contentType,
+      'Cache-Control': ${JSON.stringify(CACHE_HEADERS.REVALIDATE)},
+    },
+  })
+}
+`;
+}
+async function getDynamicSitemapRouteCode(resourcePath, loaderContext) {
+    const code = `\
+/* dynamic sitemap route with generateSitemaps */
+import { NextResponse } from 'next/server'
+import { default as handler, generateSitemaps } from ${JSON.stringify(resourcePath)}
+import { resolveRouteData } from 'next/dist/build/webpack/loaders/metadata/resolve-route-data'
+
+const contentType = ${JSON.stringify(getContentType(resourcePath))}
+const fileType = ${JSON.stringify(getFilenameAndExtension(resourcePath).name)}
+
+${errorOnBadHandler(resourcePath)}
+${await createReExportsCode(resourcePath, loaderContext)}
+
+export async function GET(_, ctx) {
+  const paramsPromise = ctx.params
+  const idPromise = paramsPromise.then(params => params?.__metadata_id__)
+
+  const id = await idPromise
+  const hasXmlExtension = id ? id.endsWith('.xml') : false
+  const sitemaps = await generateSitemaps()
+  let foundId
+  for (const item of sitemaps) {
+    if (item?.id == null) {
+      throw new Error('id property is required for every item returned from generateSitemaps')
+    }
+
+    const baseId = id && hasXmlExtension ? id.slice(0, -4) : undefined
+    if (item.id.toString() === baseId) {
+      foundId = item.id
+    }
+  }
+  if (foundId == null) {
+    return new NextResponse('Not Found', {
+      status: 404,
+    })
+  }
+
+  const targetIdPromise = idPromise.then(id => {
+    const hasXmlExtension = id ? id.endsWith('.xml') : false
+    return id && hasXmlExtension ? id.slice(0, -4) : undefined
+  })
+  const data = await handler({ id: targetIdPromise })
+  const content = resolveRouteData(data, fileType)
+
+  return new NextResponse(content, {
+    headers: {
+      'Content-Type': contentType,
+      'Cache-Control': ${JSON.stringify(CACHE_HEADERS.REVALIDATE)},
+    },
+  })
+}
+
+export async function generateStaticParams() {
+  const sitemaps = await generateSitemaps()
+  const params = []
+
+  for (const item of sitemaps) {
+    if (item?.id == null) {
+      throw new Error('id property is required for every item returned from generateSitemaps')
+    }
+    params.push({ __metadata_id__: item.id.toString() + '.xml' })
+  }
+  return params
+}
+`;
+    return code;
+}
+// <metadata-sitemap>/[id]/route.js
+async function getSitemapRouteCode(resourcePath, loaderContext) {
+    const exportNames = await (0, _utils.getLoaderModuleNamedExports)(resourcePath, loaderContext);
+    const hasGenerateSitemaps = exportNames.includes('generateSitemaps');
+    if (hasGenerateSitemaps) {
+        return getDynamicSitemapRouteCode(resourcePath, loaderContext);
+    } else {
+        return getSingleSitemapRouteCode(resourcePath, loaderContext);
+    }
+}
+// When it's static route, it could be favicon.ico, sitemap.xml, robots.txt etc.
+// TODO-METADATA: improve the cache control strategy
+const nextMetadataRouterLoader = async function() {
+    // Install bindings early so they are definitely available to the loader.
+    // When run by webpack in next this is already done with correct configuration so this is a no-op.
+    // In turbopack loaders are run in a subprocess so it may or may not be done.
+    await (0, _installbindings.installBindings)();
+    const { isDynamicRouteExtension, filePath } = this.getOptions();
+    const { name: fileBaseName } = getFilenameAndExtension(filePath);
+    this.addDependency(filePath);
+    let code = '';
+    if (isDynamicRouteExtension === '1') {
+        if (fileBaseName === 'robots' || fileBaseName === 'manifest') {
+            code = await getDynamicTextRouteCode(filePath, this);
+        } else if (fileBaseName === 'sitemap') {
+            code = await getSitemapRouteCode(filePath, this);
+        } else {
+            code = await getImageRouteCode(filePath, this);
+        }
+    } else {
+        code = await getStaticAssetRouteCode(filePath, fileBaseName);
+    }
+    return code;
+};
+const _default = nextMetadataRouterLoader;
+
+//# sourceMappingURL=next-metadata-route-loader.js.map

qalita/_frontend/node_modules/next/dist/build/webpack/loaders/next-middleware-asset-loader.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    raw: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return MiddlewareAssetLoader;
+    },
+    raw: function() {
+        return raw;
+    }
+});
+const _loaderutils3 = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/loader-utils3"));
+const _getmodulebuildinfo = require("./get-module-build-info");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function MiddlewareAssetLoader(source) {
+    const name = _loaderutils3.default.interpolateName(this, '[name].[hash].[ext]', {
+        context: this.rootContext,
+        content: source
+    });
+    const filePath = `edge-chunks/asset_${name}`;
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    buildInfo.nextAssetMiddlewareBinding = {
+        filePath: `server/${filePath}`,
+        name
+    };
+    this.emitFile(filePath, source);
+    return `module.exports = ${JSON.stringify(`blob:${name}`)}`;
+}
+const raw = true;
+
+//# sourceMappingURL=next-middleware-asset-loader.js.map

qalita/_frontend/node_modules/next/dist/build/webpack/loaders/next-middleware-loader.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    decodeMatchers: null,
+    default: null,
+    encodeMatchers: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    decodeMatchers: function() {
+        return decodeMatchers;
+    },
+    default: function() {
+        return middlewareLoader;
+    },
+    encodeMatchers: function() {
+        return encodeMatchers;
+    }
+});
+const _getmodulebuildinfo = require("./get-module-build-info");
+const _constants = require("../../../lib/constants");
+const _loadentrypoint = require("../../load-entrypoint");
+function encodeMatchers(matchers) {
+    return Buffer.from(JSON.stringify(matchers)).toString('base64');
+}
+function decodeMatchers(encodedMatchers) {
+    return JSON.parse(Buffer.from(encodedMatchers, 'base64').toString());
+}
+async function middlewareLoader() {
+    const { absolutePagePath, page, rootDir, matchers: encodedMatchers, preferredRegion, middlewareConfig: middlewareConfigBase64 } = this.getOptions();
+    const matchers = encodedMatchers ? decodeMatchers(encodedMatchers) : undefined;
+    const pagePath = this.utils.contextify(this.context || this.rootContext, absolutePagePath);
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, 'base64').toString());
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    buildInfo.nextEdgeMiddleware = {
+        matchers,
+        page: page.replace(new RegExp(`/(${_constants.MIDDLEWARE_LOCATION_REGEXP}|${_constants.PROXY_LOCATION_REGEXP})$`), '') || '/'
+    };
+    buildInfo.rootDir = rootDir;
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    return await (0, _loadentrypoint.loadEntrypoint)('middleware', {
+        VAR_USERLAND: pagePath,
+        VAR_DEFINITION_PAGE: page
+    });
+}
+
+//# sourceMappingURL=next-middleware-loader.js.map

qalita/_frontend/node_modules/next/dist/build/webpack/loaders/next-middleware-wasm-loader.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    raw: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return MiddlewareWasmLoader;
+    },
+    raw: function() {
+        return raw;
+    }
+});
+const _getmodulebuildinfo = require("./get-module-build-info");
+const _crypto = /*#__PURE__*/ _interop_require_default(require("crypto"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function sha1(source) {
+    return _crypto.default.createHash('sha1').update(source).digest('hex');
+}
+function MiddlewareWasmLoader(source) {
+    const name = `wasm_${sha1(source)}`;
+    const filePath = `edge-chunks/${name}.wasm`;
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    buildInfo.nextWasmMiddlewareBinding = {
+        filePath: `server/${filePath}`,
+        name
+    };
+    this.emitFile(`/${filePath}`, source, null);
+    return `module.exports = ${name};`;
+}
+const raw = true;
+
+//# sourceMappingURL=next-middleware-wasm-loader.js.map

qalita/_frontend/node_modules/next/dist/build/webpack/loaders/next-root-params-loader.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _promises = /*#__PURE__*/ _interop_require_wildcard(require("node:fs/promises"));
+const _apppaths = require("../../../shared/lib/router/utils/app-paths");
+const _ensureleadingslash = require("../../../shared/lib/page-path/ensure-leading-slash");
+const _getsegmentparam = require("../../../shared/lib/router/utils/get-segment-param");
+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 rootParamsLoader = async function() {
+    const { appDir, pageExtensions } = this.getOptions();
+    const allRootParams = await collectRootParamsFromFileSystem({
+        appDir,
+        pageExtensions
+    });
+    // invalidate the result whenever a file/directory is added/removed inside the app dir or its subdirectories,
+    // because that might mean that a root layout has been moved.
+    this.addContextDependency(appDir);
+    // If there's no root params, there's nothing to generate.
+    if (allRootParams.size === 0) {
+        return 'export {}';
+    }
+    // Generate a getter for each root param we found.
+    const sortedRootParamNames = Array.from(allRootParams).sort();
+    const content = [
+        `import { getRootParam } from 'next/dist/server/request/root-params';`,
+        ...sortedRootParamNames.map((paramName)=>{
+            return `export function ${paramName}() { return getRootParam('${paramName}'); }`;
+        })
+    ].join('\n');
+    return content;
+};
+const _default = rootParamsLoader;
+async function collectRootParamsFromFileSystem(opts) {
+    return collectRootParams({
+        appDir: opts.appDir,
+        rootLayoutFilePaths: await findRootLayouts(opts)
+    });
+}
+function collectRootParams({ rootLayoutFilePaths, appDir }) {
+    const allRootParams = new Set();
+    for (const rootLayoutFilePath of rootLayoutFilePaths){
+        const params = getParamsFromLayoutFilePath({
+            appDir,
+            layoutFilePath: rootLayoutFilePath
+        });
+        for (const param of params){
+            allRootParams.add(param);
+        }
+    }
+    return allRootParams;
+}
+async function findRootLayouts({ appDir, pageExtensions }) {
+    const layoutFilenameRegex = new RegExp(`^layout\\.(?:${pageExtensions.join('|')})$`);
+    async function visit(directory) {
+        let dir;
+        try {
+            dir = await _promises.readdir(directory, {
+                withFileTypes: true
+            });
+        } catch (err) {
+            // If the directory was removed before we managed to read it, just ignore it.
+            if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+                return [];
+            }
+            throw err;
+        }
+        const subdirectories = [];
+        for (const entry of dir){
+            if (entry.isDirectory()) {
+                // Directories that start with an underscore are excluded from routing, so we shouldn't look for layouts inside.
+                if (entry.name[0] === '_') {
+                    continue;
+                }
+                // Parallel routes cannot occur above a layout, so they can't contain a root layout.
+                if (entry.name[0] === '@') {
+                    continue;
+                }
+                const absolutePathname = _nodepath.join(directory, entry.name);
+                subdirectories.push(absolutePathname);
+            } else if (entry.isFile()) {
+                if (layoutFilenameRegex.test(entry.name)) {
+                    // We found a root layout, so we're not going to recurse into subdirectories,
+                    // meaning that we can skip the rest of the entries.
+                    // Note that we don't need to track any of the subdirectories as dependencies --
+                    // changes in the subdirectories will only become relevant if this root layout is (re)moved,
+                    // in which case the loader will re-run, traverse deeper (because it no longer stops at this root layout)
+                    // and then track those directories as needed.
+                    const rootLayoutPath = _nodepath.join(directory, entry.name);
+                    return [
+                        rootLayoutPath
+                    ];
+                }
+            }
+        }
+        if (subdirectories.length === 0) {
+            return [];
+        }
+        const subdirectoryRootLayouts = await Promise.all(subdirectories.map((subdirectory)=>visit(subdirectory)));
+        return subdirectoryRootLayouts.flat(1);
+    }
+    return visit(appDir);
+}
+function getParamsFromLayoutFilePath({ appDir, layoutFilePath }) {
+    const rootLayoutPath = (0, _apppaths.normalizeAppPath)((0, _ensureleadingslash.ensureLeadingSlash)(_nodepath.dirname(_nodepath.relative(appDir, layoutFilePath))));
+    const segments = rootLayoutPath.split('/');
+    const paramNames = [];
+    for (const segment of segments){
+        const param = (0, _getsegmentparam.getSegmentParam)(segment);
+        if (param !== null) {
+            paramNames.push(param.param);
+        }
+    }
+    return paramNames;
+}
+
+//# sourceMappingURL=next-root-params-loader.js.map