@depup/nextra 4.6.1-depup.0

package/dist/server/index.js

@@ -0,0 +1,203 @@
+import { createRequire } from "module";
+import path from "path";
+import { fileURLToPath } from "url";
+import fg from "fast-glob";
+import { z } from "zod";
+import { CWD, MARKDOWN_EXTENSION_RE } from "./constants.js";
+import { NextraConfigSchema } from "./schemas.js";
+import { logger } from "./utils.js";
+const require2 = createRequire(import.meta.url);
+const MARKDOWN_EXTENSIONS = ["md", "mdx"];
+const DEFAULT_EXTENSIONS = ["js", "jsx", "ts", "tsx"];
+const FILENAME = fileURLToPath(import.meta.url);
+const LOADER_PATH = path.join(FILENAME, "..", "..", "..", "loader.cjs");
+const SEP = path.sep === "/" ? "/" : "\\\\";
+const GET_PAGE_MAP_PATH = "/nextra/dist/server/page-map/get.js";
+const PAGE_MAP_PLACEHOLDER_PATH = "/nextra/dist/server/page-map/placeholder.js";
+const GET_PAGE_MAP_RE = new RegExp(
+  GET_PAGE_MAP_PATH.replaceAll("/", SEP).replaceAll(".", String.raw`\.`)
+);
+const PAGE_MAP_PLACEHOLDER_RE = new RegExp(
+  PAGE_MAP_PLACEHOLDER_PATH.replaceAll("/", SEP).replaceAll(".", String.raw`\.`)
+);
+const CONTENT_DIR = getContentDirectory();
+function getContentDirectory() {
+  const [contentDir = "content"] = fg.sync(["{src/,}content"], {
+    onlyDirectories: true
+  });
+  return contentDir;
+}
+const [nextMajorVersion, nextMinorVersion] = require2("next/package.json").version.split(".", 2).map(Number);
+const shouldUseConfigTurbopack = nextMajorVersion > 15 || nextMajorVersion === 15 && nextMinorVersion > 2;
+const nextra = (nextraConfig) => {
+  const { error, data: loaderOptions } = NextraConfigSchema.safeParse(nextraConfig);
+  if (error) {
+    logger.error("Error validating nextraConfig");
+    throw z.prettifyError(error);
+  }
+  const loader = {
+    loader: LOADER_PATH,
+    options: loaderOptions
+  };
+  const pageImportLoader = {
+    loader: LOADER_PATH,
+    options: { ...loaderOptions, isPageImport: true }
+  };
+  const pageMapPlaceholderLoader = {
+    loader: LOADER_PATH,
+    options: {
+      // Remove forward slash
+      contentDirBasePath: loaderOptions.contentDirBasePath.slice(1),
+      contentDir: CONTENT_DIR,
+      shouldAddLocaleToLinks: loaderOptions.unstable_shouldAddLocaleToLinks
+    }
+  };
+  return function withNextra(nextConfig = {}) {
+    const { locales, defaultLocale } = nextConfig.i18n || {};
+    if (locales) {
+      logger.info(
+        "You have Next.js i18n enabled, read here https://nextjs.org/docs/app/building-your-application/routing/internationalization for the docs."
+      );
+    }
+    const pageMapLoader = {
+      loader: LOADER_PATH,
+      options: {
+        // ts complains about readonly array
+        locales: locales ? [...locales] : [""]
+      }
+    };
+    const turbopackConfig = (shouldUseConfigTurbopack ? nextConfig.turbopack : (
+      // @ts-expect-error -- Backwards compatibility
+      nextConfig.experimental?.turbo
+    )) ?? {};
+    const turbopack = {
+      ...turbopackConfig,
+      rules: {
+        ...turbopackConfig.rules,
+        [`./{src/,}app/**/page.{${MARKDOWN_EXTENSIONS}}`]: {
+          as: "*.tsx",
+          loaders: [pageImportLoader]
+        },
+        // Order matter here, pages match first -> after partial files
+        [`*.{${MARKDOWN_EXTENSIONS}}`]: {
+          as: "*.tsx",
+          loaders: [loader]
+        },
+        [`**${PAGE_MAP_PLACEHOLDER_PATH}`]: {
+          loaders: [pageMapPlaceholderLoader]
+        },
+        [`**${GET_PAGE_MAP_PATH}`]: {
+          loaders: [pageMapLoader]
+        }
+      },
+      resolveAlias: {
+        "next-mdx-import-source-file": "@vercel/turbopack-next/mdx-import-source",
+        // Fixes when Turbopack is enabled: Module not found: Can't resolve '@theguild/remark-mermaid/mermaid'
+        "@theguild/remark-mermaid/mermaid": path.relative(
+          CWD,
+          path.join(
+            require2.resolve("@theguild/remark-mermaid/package.json"),
+            "..",
+            "dist",
+            "mermaid.js"
+          )
+        ),
+        ...turbopackConfig.resolveAlias,
+        "private-next-root-dir/*": "./*",
+        "private-next-content-dir/*": `./${CONTENT_DIR}/*`
+      }
+    };
+    return {
+      ...nextConfig,
+      ...shouldUseConfigTurbopack && { turbopack },
+      transpilePackages: [
+        // To import ESM-only packages with `next dev --turbopack`. Source: https://github.com/vercel/next.js/issues/63318#issuecomment-2079677098
+        ...// Next.js 15
+        process.env.TURBOPACK === "1" || // Next.js 16
+        process.env.TURBOPACK === "auto" ? ["shiki", "ts-morph"] : [],
+        ...nextConfig.transpilePackages || []
+      ],
+      pageExtensions: [
+        ...nextConfig.pageExtensions || DEFAULT_EXTENSIONS,
+        ...MARKDOWN_EXTENSIONS
+      ],
+      // We always unset `nextConfig.i18n` property
+      i18n: void 0,
+      env: {
+        ...nextConfig.env,
+        NEXTRA_LOCALES: JSON.stringify(pageMapLoader.options.locales),
+        NEXTRA_DEFAULT_LOCALE: defaultLocale,
+        NEXTRA_SHOULD_ADD_LOCALE_TO_LINKS: String(
+          loaderOptions.unstable_shouldAddLocaleToLinks
+        )
+      },
+      experimental: {
+        ...nextConfig.experimental,
+        optimizePackageImports: [
+          "nextra/components",
+          "nextra-theme-docs",
+          "nextra-theme-blog",
+          ...nextConfig.experimental?.optimizePackageImports || []
+        ],
+        ...!shouldUseConfigTurbopack && { turbo: turbopack }
+      },
+      webpack(config, options) {
+        if (config.watchOptions.ignored instanceof RegExp) {
+          const ignored = config.watchOptions.ignored.source;
+          config.watchOptions = {
+            ...config.watchOptions,
+            ignored: new RegExp(
+              ignored.replace(
+                String.raw`(\.(git|next)|node_modules)`,
+                String.raw`\.(git|next)`
+              )
+            )
+          };
+        }
+        config.resolve.alias["private-next-content-dir"] = [
+          "private-next-root-dir/content",
+          "private-next-root-dir/src/content"
+        ];
+        config.resolve.alias["next-mdx-import-source-file"] = [
+          "private-next-root-dir/mdx-components",
+          "private-next-root-dir/src/mdx-components"
+        ];
+        const rules = config.module.rules;
+        rules.push(
+          {
+            test: PAGE_MAP_PLACEHOLDER_RE,
+            use: [options.defaultLoaders.babel, pageMapPlaceholderLoader]
+          },
+          {
+            test: GET_PAGE_MAP_RE,
+            use: [options.defaultLoaders.babel, pageMapLoader]
+          },
+          {
+            test: MARKDOWN_EXTENSION_RE,
+            oneOf: [
+              {
+                // Match pages (imports without an issuer request).
+                issuer: (request) => request === "",
+                use: [options.defaultLoaders.babel, pageImportLoader]
+              },
+              {
+                // Match Markdown imports from non-pages. These imports have an
+                // issuer, which can be anything as long as it's not empty string.
+                // When the issuer is `null`, it means that it can be imported via a
+                // runtime import call such as `import('...')`.
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- types are wrong, value can be null
+                issuer: (request) => request === null || !!request,
+                use: [options.defaultLoaders.babel, loader]
+              }
+            ]
+          }
+        );
+        return nextConfig.webpack?.(config, options) || config;
+      }
+    };
+  };
+};
+var server_default = nextra;
+export {
+  server_default as default
+};

package/dist/server/loader.d.ts

@@ -0,0 +1,18 @@
+import { LoaderContext } from 'webpack';
+import { LoaderOptions } from '../types.js';
+import 'mdast';
+import 'next';
+import 'react';
+import 'zod';
+import './schemas.js';
+import './lib/index.js';
+import 'rehype-katex/lib/index.js';
+import 'better-react-mathjax';
+import 'rehype-pretty-code';
+import '../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+
+declare function loader(this: LoaderContext<LoaderOptions>, source: string): Promise<string>;
+
+export { loader };

package/dist/server/loader.js

@@ -0,0 +1,155 @@
+import path from "path";
+import { transformerTwoslash } from "@shikijs/twoslash";
+import { findPagesDir } from "next/dist/lib/find-pages-dir.js";
+import { compileMetadata } from "./compile-metadata.js";
+import { compileMdx } from "./compile.js";
+import { CWD, IS_PRODUCTION, METADATA_ONLY_RQ } from "./constants.js";
+import { findMetaAndPageFilePaths } from "./page-map/find-meta-and-page-file-paths.js";
+import { convertPageMapToJs } from "./page-map/to-js.js";
+import { convertToPageMap } from "./page-map/to-page-map.js";
+import { twoslashRenderer } from "./twoslash.js";
+import { logger } from "./utils.js";
+const NOW = Date.now();
+const APP_DIR = findPagesDir(CWD).appDir;
+if (!APP_DIR) {
+  throw new Error("Unable to find `app` directory");
+}
+const repository = await (async () => {
+  if (process.versions.webcontainer) return;
+  const { Repository } = await import("@napi-rs/simple-git");
+  try {
+    const repository2 = Repository.discover(CWD);
+    if (repository2.isShallow()) {
+      if (process.env.VERCEL) {
+        logger.warn(
+          "The repository is shallow cloned, so the latest modified time will not be presented. Set the VERCEL_DEEP_CLONE=true environment variable to enable deep cloning."
+        );
+      } else if (process.env.GITHUB_ACTION) {
+        logger.warn(
+          "The repository is shallow cloned, so the latest modified time will not be presented. See https://github.com/actions/checkout#fetch-all-history-for-all-tags-and-branches to fetch all the history."
+        );
+      } else {
+        logger.warn(
+          "The repository is shallow cloned, so the latest modified time will not be presented."
+        );
+      }
+    }
+    return repository2;
+  } catch (error) {
+    logger.warn(`Init git repository failed ${error.message}`);
+  }
+})();
+const GIT_ROOT = repository ? path.join(repository.path(), "..") : "";
+const DEFAULT_TRANSFORMERS = transformerTwoslash({
+  renderer: twoslashRenderer(),
+  explicitTrigger: true
+});
+async function loader(source) {
+  const {
+    isPageImport,
+    defaultShowCopyCode,
+    search,
+    staticImage,
+    readingTime: _readingTime,
+    latex,
+    codeHighlight,
+    mdxOptions,
+    contentDirBasePath,
+    contentDir,
+    locales,
+    whiteListTagsStyling,
+    shouldAddLocaleToLinks
+  } = this.getOptions();
+  const { resourcePath, resourceQuery } = this;
+  if (contentDir) {
+    const locale = resourceQuery.replace("?lang=", "");
+    this.addContextDependency(APP_DIR);
+    this.addContextDependency(path.join(CWD, contentDir, locale));
+    const filePaths = await findMetaAndPageFilePaths({
+      dir: APP_DIR,
+      cwd: CWD,
+      locale,
+      contentDir
+    });
+    let { pageMap, mdxPages } = convertToPageMap({
+      filePaths,
+      basePath: shouldAddLocaleToLinks ? [locale, contentDirBasePath].filter(Boolean).join("/") : contentDirBasePath,
+      locale
+    });
+    if (shouldAddLocaleToLinks && "children" in pageMap[0]) {
+      pageMap = pageMap[0].children;
+    }
+    const globalMetaPath = filePaths.find(
+      (filePath) => filePath.includes("/_meta.global.")
+    );
+    return convertPageMapToJs({ pageMap, mdxPages, globalMetaPath });
+  }
+  if (locales) {
+    return replaceDynamicResourceQuery(
+      source,
+      "import(`./placeholder.js?lang=${lang}`)",
+      locales
+    );
+  }
+  const lastCommitTime = IS_PRODUCTION ? await getLastCommitTime(resourcePath) : NOW;
+  if (!IS_PRODUCTION && resourceQuery === METADATA_ONLY_RQ) {
+    return compileMetadata(source, {
+      filePath: resourcePath,
+      lastCommitTime
+    });
+  }
+  return compileMdx(source, {
+    mdxOptions: {
+      ...mdxOptions,
+      jsx: true,
+      outputFormat: "program",
+      rehypePrettyCodeOptions: {
+        ...mdxOptions.rehypePrettyCodeOptions,
+        transformers: [
+          DEFAULT_TRANSFORMERS,
+          ...mdxOptions.rehypePrettyCodeOptions.transformers || []
+        ]
+      }
+    },
+    readingTime: _readingTime,
+    defaultShowCopyCode,
+    staticImage,
+    search,
+    latex,
+    codeHighlight,
+    filePath: resourcePath,
+    useCachedCompiler: true,
+    isPageImport,
+    whiteListTagsStyling,
+    lastCommitTime
+  });
+}
+function replaceDynamicResourceQuery(rawJs, rawImport, locales) {
+  const { importPath } = rawJs.match(/import\(`(?<importPath>.+?)\?lang=\${lang}`\)/)?.groups || {};
+  if (!importPath) {
+    throw new Error(
+      `Can't find \`${rawImport}\` statement. This is a Nextra bug`
+    );
+  }
+  const replaced = `{
+${locales.map((lang) => `"${lang}": () => import("${importPath}?lang=${lang}")`).join(",\n")}
+}[lang]()`;
+  return rawJs.replace(rawImport, replaced);
+}
+async function getLastCommitTime(filePath) {
+  if (!repository) {
+    return;
+  }
+  const relativePath = path.relative(GIT_ROOT, filePath);
+  try {
+    return await repository.getFileLatestModifiedDateAsync(relativePath);
+  } catch {
+    logger.warn(
+      "Failed to get the last modified timestamp from Git for the file",
+      relativePath
+    );
+  }
+}
+export {
+  loader
+};

package/dist/server/locales.d.ts

@@ -0,0 +1,22 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+/**
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * export { proxy } from 'nextra/locales'
+ *
+ * export const config = {
+ *   // Matcher ignoring `/_next/` and `/api/`
+ *   matcher: [
+ *     '/((?!api|_next/static|_next/image|favicon.ico|icon.svg|apple-icon.png|manifest|_pagefind).*)'
+ *   ]
+ * }
+ * ```
+ */
+declare function proxy(request: NextRequest): NextResponse<unknown> | undefined;
+/** @deprecated Use `export { proxy } from 'nextra/locales'` instead. */
+declare const middleware: typeof proxy;
+
+export { middleware, proxy };

package/dist/server/locales.js

@@ -0,0 +1,38 @@
+import { match as matchLocale } from "@formatjs/intl-localematcher";
+import Negotiator from "negotiator";
+import { addBasePath } from "next/dist/client/add-base-path";
+import { NextResponse } from "next/server";
+const locales = JSON.parse(process.env.NEXTRA_LOCALES);
+const defaultLocale = process.env.NEXTRA_DEFAULT_LOCALE;
+const HAS_LOCALE_RE = new RegExp(String.raw`^\/(${locales.join("|")})(\/|$)`);
+const COOKIE_NAME = "NEXT_LOCALE";
+function getHeadersLocale(request) {
+  const headers = Object.fromEntries(
+    // @ts-expect-error -- this works
+    request.headers.entries()
+  );
+  const languages = new Negotiator({ headers }).languages(locales);
+  const locale = matchLocale(languages, locales, defaultLocale);
+  return locale;
+}
+function proxy(request) {
+  const { pathname } = request.nextUrl;
+  const pathnameHasLocale = HAS_LOCALE_RE.test(pathname);
+  const cookieLocale = request.cookies.get(COOKIE_NAME)?.value;
+  if (!pathnameHasLocale) {
+    const locale = cookieLocale || getHeadersLocale(request);
+    const url = addBasePath(`/${locale}${pathname}`);
+    return NextResponse.redirect(new URL(url, request.url));
+  }
+  const [, requestLocale] = pathname.split("/", 2);
+  if (requestLocale !== cookieLocale) {
+    const response = NextResponse.next();
+    response.cookies.set(COOKIE_NAME, requestLocale);
+    return response;
+  }
+}
+const middleware = proxy;
+export {
+  middleware,
+  proxy
+};

package/dist/server/page-map/find-meta-and-page-file-paths.d.ts

@@ -0,0 +1,8 @@
+declare function findMetaAndPageFilePaths({ dir, cwd, locale, contentDir }: {
+    dir: string;
+    cwd: string;
+    locale?: string;
+    contentDir?: string;
+}): Promise<string[]>;
+
+export { findMetaAndPageFilePaths };

package/dist/server/page-map/find-meta-and-page-file-paths.js

@@ -0,0 +1,32 @@
+import path from "path";
+import fg from "fast-glob";
+import slash from "slash";
+async function findMetaAndPageFilePaths({
+  dir,
+  cwd,
+  locale = "",
+  // Can be `src/content` also
+  contentDir = "content"
+}) {
+  const appDir = slash(path.relative(cwd, dir));
+  if (locale) contentDir += `/${locale}`;
+  const pattern = appDir ? [
+    `${contentDir}/**/_meta.{js,jsx,ts,tsx}`,
+    // Include `_meta` files from `content` directory
+    `${contentDir}/**/*.{md,mdx}`,
+    // Include all Markdown/MDX files from `content` directory
+    `${appDir}/**/page.{js,jsx,jsx,tsx,md,mdx}`,
+    `${appDir}/**/_meta.{js,jsx,ts,tsx}`,
+    // Include `_meta` files from `app` directory
+    `${appDir}/_meta.global.{js,jsx,ts,tsx}`,
+    // Include global `_meta` file from `app` directory
+    `!${appDir}/**/{_,[}*/*`
+    // Ignore subdirectories starting with `_` and dynamic routes
+  ] : ["**/_meta.{js,jsx,ts,tsx}", "**/*.{md,mdx}"];
+  const result = await fg(pattern, { cwd });
+  const relativePaths = result.sort((a, b) => a.localeCompare(b));
+  return relativePaths;
+}
+export {
+  findMetaAndPageFilePaths
+};

package/dist/server/page-map/get.d.ts

@@ -0,0 +1,50 @@
+import { PageMapItem } from '../../types.js';
+import 'mdast';
+import 'next';
+import 'react';
+import 'zod';
+import '../schemas.js';
+import './lib/index.js';
+import 'rehype-katex/lib/index.js';
+import 'better-react-mathjax';
+import 'rehype-pretty-code';
+import '../../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+
+/**
+ * Retrieves the page map structure for a given route handling nested routes.
+ *
+ * The page map structure represents the hierarchical organization of your documentation or content,
+ * where each item can be either a page or a folder containing more pages.
+ *
+ * @returns A Promise that resolves to an array of `PageMapItem` objects representing the page structure
+ * such as `MdxFile`, `Folder` and `MetaJsonFile`.
+ *
+ * @example
+ * ```ts
+ * import { getPageMap } from 'nextra/page-map'
+ *
+ * // Get the root page map
+ * const rootPageMap = await getPageMap()
+ *
+ * // Get the page map for a specific route
+ * const blogPageMap = await getPageMap('/blog')
+ *
+ * // Get the page map for a specific language when using i18n
+ * const enPageMap = await getPageMap('/en')
+ * ```
+ *
+ * @throws {Error} when the specified route segment cannot be found in the page map.
+ *
+ * @see [Page Map Structure Documentation](https://nextra.site/docs/file-conventions/meta-file#pagemap-structure).
+ */
+declare function getPageMap(
+/**
+ * The route path to retrieve the page map for.
+ * @default "/"
+ */
+route?: string): Promise<PageMapItem[]>;
+declare function getRouteToFilepath(lang?: string): Promise<Record<string, string>>;
+
+export { getPageMap, getRouteToFilepath };

package/dist/server/page-map/get.js

@@ -0,0 +1,28 @@
+function importPageMap(lang = "") {
+  return import(`./placeholder.js?lang=${lang}`);
+}
+const defaultLocale = process.env.NEXTRA_DEFAULT_LOCALE;
+async function getPageMap(route = "/") {
+  const segments = route.split("/");
+  const lang = segments.splice(0, defaultLocale ? 2 : 1).at(-1);
+  let { pageMap } = await importPageMap(lang);
+  let segment;
+  while (segment = segments.shift()) {
+    const folder = pageMap.find(
+      (item) => "name" in item && item.name === segment
+    );
+    if (!folder) {
+      throw new Error(`Can't find pageMap for "${segment}" in route "${route}"`);
+    }
+    pageMap = folder.children;
+  }
+  return pageMap;
+}
+async function getRouteToFilepath(lang) {
+  const { RouteToFilepath } = await importPageMap(lang);
+  return RouteToFilepath;
+}
+export {
+  getPageMap,
+  getRouteToFilepath
+};

package/dist/server/page-map/index-page.d.ts

@@ -0,0 +1,21 @@
+import * as react from 'react';
+import { PageMapItem, MdxFile } from '../../types.js';
+import 'mdast';
+import 'next';
+import 'zod';
+import '../schemas.js';
+import './lib/index.js';
+import 'rehype-katex/lib/index.js';
+import 'better-react-mathjax';
+import 'rehype-pretty-code';
+import '../../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+
+declare function createIndexPage(pageMap: PageMapItem[]): Promise<string>;
+declare function getIndexPageMap(pageMap: PageMapItem[]): ({
+    type: "separator";
+    title?: string | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | undefined;
+} | MdxFile[])[];
+
+export { createIndexPage, getIndexPageMap };

package/dist/server/page-map/index-page.js

@@ -0,0 +1,57 @@
+import { compileMdx } from "../compile.js";
+function renderCard(item) {
+  const icon = item.frontMatter?.icon;
+  const Icon = icon ? `<${icon}/>` : "null";
+  return `<Cards.Card title="${item.title}" href="${item.route}" icon={${Icon}} />`;
+}
+async function createIndexPage(pageMap) {
+  const result = [];
+  let hasCards = false;
+  for (const item of pageMap) {
+    if ("data" in item) {
+      continue;
+    }
+    if (item.type === "separator") {
+      if (hasCards) {
+        result.push("</Cards>");
+        hasCards = false;
+      }
+      result.push(`## ${item.title}`);
+      continue;
+    }
+    if (!hasCards) {
+      hasCards = true;
+      result.push("<Cards>");
+    }
+    result.push(renderCard(item));
+  }
+  if (hasCards) {
+    result.push("</Cards>");
+  }
+  const rawMdx = result.join("\n");
+  const rawJs = await compileMdx(rawMdx);
+  return rawJs;
+}
+function getIndexPageMap(pageMap) {
+  const result = [];
+  for (const item of pageMap) {
+    if ("data" in item) {
+      continue;
+    }
+    if (item.type === "separator") {
+      result.push(item);
+    } else {
+      const lastResult = result.at(-1);
+      if (Array.isArray(lastResult)) {
+        lastResult.push(item);
+      } else {
+        result.push([item]);
+      }
+    }
+  }
+  return result;
+}
+export {
+  createIndexPage,
+  getIndexPageMap
+};

package/dist/server/page-map/index.d.ts

@@ -0,0 +1,26 @@
+import { Metadata } from 'next';
+export { normalizePageMap } from './normalize.js';
+export { convertToPageMap } from './to-page-map.js';
+export { mergeMetaWithPageMap } from './merge-meta-with-page-map.js';
+export { getPageMap } from './get.js';
+export { createIndexPage, getIndexPageMap } from './index-page.js';
+import '../../types.js';
+import 'mdast';
+import 'react';
+import 'zod';
+import '../schemas.js';
+import './lib/index.js';
+import 'rehype-katex/lib/index.js';
+import 'better-react-mathjax';
+import 'rehype-pretty-code';
+import '../../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+
+declare function getMetadata(page: {
+    metadata: Metadata;
+} | {
+    generateMetadata?: (props: object) => Promise<Metadata>;
+}): Promise<Metadata> | Metadata;
+
+export { getMetadata };