@depup/nextra 4.6.1-depup.0

package/dist/server/rehype-plugins/index.d.ts

@@ -0,0 +1,18 @@
+export { DEFAULT_REHYPE_PRETTY_CODE_OPTIONS, rehypeAttachCodeMeta, rehypeParseCodeMeta } from './rehype.js';
+export { rehypeBetterReactMathjax } from './rehype-better-react-mathjax.js';
+export { rehypeExtractTocContent } from './rehype-extract-toc-content.js';
+export { rehypeTwoslashPopup } from './rehype-twoslash-popup.js';
+import 'hast';
+import 'rehype-pretty-code';
+import './lib/index.js';
+import '../../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+import 'better-react-mathjax';
+import '../../types.js';
+import 'mdast';
+import 'next';
+import 'react';
+import 'zod';
+import '../schemas.js';
+import 'rehype-katex/lib/index.js';

package/dist/server/rehype-plugins/index.js

@@ -0,0 +1,16 @@
+import {
+  rehypeParseCodeMeta,
+  rehypeAttachCodeMeta,
+  DEFAULT_REHYPE_PRETTY_CODE_OPTIONS
+} from "./rehype.js";
+import { rehypeBetterReactMathjax } from "./rehype-better-react-mathjax.js";
+import { rehypeExtractTocContent } from "./rehype-extract-toc-content.js";
+import { rehypeTwoslashPopup } from "./rehype-twoslash-popup.js";
+export {
+  DEFAULT_REHYPE_PRETTY_CODE_OPTIONS,
+  rehypeAttachCodeMeta,
+  rehypeBetterReactMathjax,
+  rehypeExtractTocContent,
+  rehypeParseCodeMeta,
+  rehypeTwoslashPopup
+};

package/dist/server/rehype-plugins/rehype-better-react-mathjax.d.ts

@@ -0,0 +1,24 @@
+import { Root } from 'hast';
+import { Plugin } from './lib/index.js';
+import { MathJaxOptions } from '../../types.js';
+import 'mdast';
+import 'next';
+import 'react';
+import 'zod';
+import '../schemas.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';
+
+/**
+ * Wraps math in a `<MathJax>` component so that it can be rendered by `better-react-mathjax`.
+ */
+declare const rehypeBetterReactMathjax: Plugin<[
+    Opts: MathJaxOptions,
+    isRemoteContent: boolean
+], Root>;
+
+export { rehypeBetterReactMathjax };

package/dist/server/rehype-plugins/rehype-better-react-mathjax.js

@@ -0,0 +1,96 @@
+import { valueToEstree } from "estree-util-value-to-estree";
+import { visit } from "unist-util-visit";
+const MATHJAX_IMPORTS = {
+  type: "mdxjsEsm",
+  data: {
+    estree: {
+      body: [
+        {
+          type: "ImportDeclaration",
+          source: { type: "Literal", value: "nextra/components" },
+          specifiers: ["MathJax", "MathJaxContext"].map((name) => ({
+            type: "ImportSpecifier",
+            imported: { type: "Identifier", name },
+            local: { type: "Identifier", name }
+          }))
+        }
+      ]
+    }
+  }
+};
+function wrapInMathJaxContext(children, { config, src }) {
+  const attributes = [];
+  if (src) {
+    attributes.push({ type: "mdxJsxAttribute", name: "src", value: src });
+  }
+  if (config && Object.keys(config).length) {
+    attributes.push({
+      type: "mdxJsxAttribute",
+      name: "config",
+      value: {
+        type: "mdxJsxAttributeValueExpression",
+        value: "",
+        data: {
+          estree: {
+            type: "Program",
+            sourceType: "module",
+            body: [
+              { type: "ExpressionStatement", expression: valueToEstree(config) }
+            ]
+          }
+        }
+      }
+    });
+  }
+  return {
+    type: "mdxJsxFlowElement",
+    name: "MathJaxContext",
+    attributes,
+    children
+  };
+}
+function wrapInBraces(source, mathInline, options) {
+  const { inlineMath, displayMath } = options.config?.tex || {};
+  const inlineBraces = inlineMath?.[0] || [String.raw`\(`, String.raw`\)`];
+  const displayBraces = displayMath?.[0] || [String.raw`\[`, String.raw`\]`];
+  const [before, after] = mathInline ? inlineBraces : displayBraces;
+  return `${before}${source}${after}`;
+}
+const rehypeBetterReactMathjax = (options = {}, isRemoteContent) => (ast) => {
+  let hasMathJax = false;
+  visit(ast, { tagName: "code" }, (node, _index, parent) => {
+    const classes = Array.isArray(node.properties.className) ? node.properties.className : [];
+    const hasMathLanguage = classes.includes("language-math");
+    if (!hasMathLanguage) return;
+    const isInlineMath = classes.includes("math-inline");
+    const [{ value }] = node.children;
+    const bracketedValue = wrapInBraces(value, isInlineMath, options);
+    const mathJaxNode = {
+      type: "element",
+      tagName: "MathJax",
+      children: [{ type: "text", value: bracketedValue }],
+      properties: isInlineMath ? { inline: true } : {}
+    };
+    Object.assign(isInlineMath ? node : parent, mathJaxNode);
+    hasMathJax = true;
+  });
+  if (!hasMathJax) return;
+  const mdxjsEsmNodes = [];
+  const rest = [];
+  for (const child of ast.children) {
+    if (child.type === "mdxjsEsm") {
+      mdxjsEsmNodes.push(child);
+    } else {
+      rest.push(child);
+    }
+  }
+  ast.children = [
+    ...mdxjsEsmNodes,
+    ...isRemoteContent ? [] : [MATHJAX_IMPORTS],
+    // Wrap everything in a `<MathJaxContext>` component.
+    wrapInMathJaxContext(rest, options)
+  ];
+};
+export {
+  rehypeBetterReactMathjax
+};

package/dist/server/rehype-plugins/rehype-extract-toc-content.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'hast';
+import { Plugin } from './lib/index.js';
+
+declare const rehypeExtractTocContent: Plugin<[], Root>;
+
+export { rehypeExtractTocContent };

package/dist/server/rehype-plugins/rehype-extract-toc-content.js

@@ -0,0 +1,119 @@
+import { toEstree } from "hast-util-to-estree";
+import { SKIP, visit } from "unist-util-visit";
+import { createAstExportConst, createAstObject } from "../utils.js";
+const TOC_HEADING_RE = /^h[2-6]$/;
+const transformer = (ast, file) => {
+  const TocMap = {};
+  visit(ast, "element", (node, _index, parent) => {
+    if (!TOC_HEADING_RE.test(node.tagName)) return;
+    if (parent && "properties" in parent && parent.properties.dataFootnotes) {
+      return SKIP;
+    }
+    const { id } = node.properties;
+    TocMap[id] = node;
+  });
+  const hasPartialMDX = file.data.toc.some(
+    (name) => typeof name === "string"
+  );
+  const elements = file.data.toc.map((name, index) => {
+    if (typeof name === "string") {
+      return {
+        type: "SpreadElement",
+        argument: { type: "Identifier", name }
+      };
+    }
+    const node = TocMap[name.id];
+    const isTextOnly = node.children.every((child) => child.type === "text");
+    const result = isTextOnly ? node.children.map((n) => n.value).join("") : (
+      // @ts-expect-error -- fixme
+      Object.assign(toEstree(node).body[0].expression, {
+        type: "JSXFragment",
+        openingFragment: { type: "JSXOpeningFragment" },
+        closingFragment: { type: "JSXClosingFragment" }
+      })
+    );
+    if (!hasPartialMDX) {
+      Object.assign(node, {
+        type: "mdxJsxFlowElement",
+        name: node.tagName,
+        attributes: [
+          {
+            type: "mdxJsxAttribute",
+            name: "id",
+            value: createComputedKey(
+              "mdxJsxAttributeValueExpression",
+              index,
+              "id"
+            )
+          }
+        ],
+        children: [createComputedKey("mdxFlowExpression", index, "value")]
+      });
+    }
+    return createAstObject({
+      value: result,
+      id: node.properties.id,
+      depth: Number(node.tagName[1])
+    });
+  });
+  ast.children.push({
+    type: "mdxjsEsm",
+    data: {
+      estree: {
+        body: [
+          {
+            // TOC links must be inside a function, in our case inside useTOC, so
+            // mdx components will be injected for `<a>` or `<code>` tags inside headings
+            type: "FunctionDeclaration",
+            id: { type: "Identifier", name: "useTOC" },
+            params: [{ type: "Identifier", name: "props" }],
+            body: {
+              type: "BlockStatement",
+              body: [
+                {
+                  type: "ReturnStatement",
+                  argument: { type: "ArrayExpression", elements }
+                }
+              ]
+            }
+          },
+          createAstExportConst("toc", {
+            type: "CallExpression",
+            callee: { type: "Identifier", name: "useTOC" },
+            // https://github.com/shuding/nextra/issues/3979
+            arguments: [{ type: "ObjectExpression", properties: [] }],
+            optional: false
+          })
+        ]
+      }
+    }
+  });
+};
+function createComputedKey(type, index, key) {
+  return {
+    type,
+    data: {
+      estree: {
+        body: [
+          {
+            type: "ExpressionStatement",
+            expression: {
+              type: "MemberExpression",
+              property: { type: "Identifier", name: key },
+              object: {
+                type: "MemberExpression",
+                object: { type: "Identifier", name: "toc" },
+                property: { type: "Literal", value: index },
+                computed: true
+              }
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+const rehypeExtractTocContent = () => transformer;
+export {
+  rehypeExtractTocContent
+};

package/dist/server/rehype-plugins/rehype-twoslash-popup.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'hast';
+import { Plugin } from './lib/index.js';
+
+declare const rehypeTwoslashPopup: Plugin<[], Root>;
+
+export { rehypeTwoslashPopup };

package/dist/server/rehype-plugins/rehype-twoslash-popup.js

@@ -0,0 +1,50 @@
+import { EXIT, visit } from "unist-util-visit";
+const TWOSLASH_POPUP_IMPORT_AST = {
+  type: "mdxjsEsm",
+  data: {
+    estree: {
+      body: [
+        {
+          type: "ImportDeclaration",
+          source: { type: "Literal", value: "nextra/components" },
+          specifiers: [
+            {
+              type: "ImportSpecifier",
+              imported: { type: "Identifier", name: "Popup" },
+              local: { type: "Identifier", name: "Popup" }
+            }
+          ]
+        }
+      ]
+    }
+  }
+};
+const transformer = (ast) => {
+  visit(
+    ast,
+    [
+      { tagName: "popup" },
+      { tagName: "popupbutton" },
+      { tagName: "popuppanel" }
+    ],
+    (node) => {
+      const n = node;
+      const tagName = {
+        popup: "Popup",
+        popupbutton: "Popup.Button",
+        popuppanel: "Popup.Panel"
+      }[n.tagName];
+      n.tagName = tagName;
+    }
+  );
+  visit(ast, { tagName: "code" }, (node) => {
+    if (node.data?.meta === "twoslash") {
+      ast.children.unshift(TWOSLASH_POPUP_IMPORT_AST);
+      return EXIT;
+    }
+  });
+};
+const rehypeTwoslashPopup = () => transformer;
+export {
+  rehypeTwoslashPopup
+};

package/dist/server/rehype-plugins/rehype.d.ts

@@ -0,0 +1,21 @@
+import { Root } from 'hast';
+import { Options } from 'rehype-pretty-code';
+import { Plugin } from './lib/index.js';
+import { NextraConfig } from '../../types.generated.js';
+import '@mdx-js/mdx';
+import 'rehype-katex';
+import 'better-react-mathjax';
+
+declare const DEFAULT_REHYPE_PRETTY_CODE_OPTIONS: Options;
+declare const rehypeParseCodeMeta: Plugin<[
+    {
+        defaultShowCopyCode?: boolean;
+    }
+], Root>;
+declare const rehypeAttachCodeMeta: Plugin<[
+    {
+        search: NextraConfig['search'];
+    }
+], Root>;
+
+export { DEFAULT_REHYPE_PRETTY_CODE_OPTIONS, rehypeAttachCodeMeta, rehypeParseCodeMeta };

package/dist/server/rehype-plugins/rehype.js

@@ -0,0 +1,84 @@
+import { bundledLanguages, createHighlighter } from "shiki";
+import { SKIP, visit } from "unist-util-visit";
+const CODE_BLOCK_FILENAME_RE = /filename="([^"]+)"/;
+const DEFAULT_REHYPE_PRETTY_CODE_OPTIONS = {
+  keepBackground: false,
+  grid: false,
+  onVisitLine(node) {
+    if (node.children.length === 0) {
+      node.children.push({ type: "text", value: " " });
+    }
+    delete node.properties["data-line"];
+  },
+  theme: {
+    light: "github-light",
+    dark: "github-dark"
+  },
+  defaultLang: {
+    block: "plaintext"
+  },
+  filterMetaString: (meta) => meta.replace(CODE_BLOCK_FILENAME_RE, ""),
+  getHighlighter(opts) {
+    const langs = Object.keys(bundledLanguages).filter((l) => l !== "mermaid");
+    return createHighlighter({
+      ...opts,
+      // Without `getHighlighter` option ```mdx lang isn't highlighted
+      langs
+    });
+  }
+};
+const rehypeParseCodeMeta = ({ defaultShowCopyCode }) => (ast) => {
+  visit(ast, { tagName: "pre" }, (node) => {
+    const [codeEl] = node.children;
+    const { meta = "" } = codeEl.data || {};
+    node.__filename = meta.match(CODE_BLOCK_FILENAME_RE)?.[1];
+    node.properties["data-filename"] = node.__filename;
+    node.__hasWordWrap = !meta.includes("word-wrap=false");
+    if (node.__hasWordWrap) {
+      node.properties["data-word-wrap"] = "";
+    }
+    node.__hasCopyCode = meta ? defaultShowCopyCode && !/( |^)copy=false($| )/.test(meta) || /( |^)copy($| )/.test(meta) : defaultShowCopyCode;
+    if (node.__hasCopyCode) {
+      node.properties["data-copy"] = "";
+    }
+  });
+};
+const rehypeAttachCodeMeta = ({ search }) => {
+  const parseCodeblocks = typeof search === "object" ? search.codeblocks : search;
+  return (ast) => {
+    visit(
+      ast,
+      [{ tagName: "figure" }, { tagName: "span" }],
+      (node) => {
+        const isRehypePrettyCode = "data-rehype-pretty-code-figure" in node.properties;
+        if (!isRehypePrettyCode) return;
+        const preEl = Object.assign(node, node.children[0]);
+        delete preEl.properties["data-theme"];
+        if (preEl.tagName === "pre") {
+          const codeEl = preEl.children[0];
+          delete codeEl.properties["data-theme"];
+          delete codeEl.properties["data-language"];
+          if (preEl.__hasWordWrap) {
+            preEl.properties["data-word-wrap"] = "";
+          }
+          if (preEl.__filename) {
+            preEl.properties["data-filename"] = preEl.__filename;
+          }
+          if (preEl.__hasCopyCode) {
+            preEl.properties["data-copy"] = "";
+          }
+          if (!parseCodeblocks) {
+            preEl.properties["data-pagefind-ignore"] = "all";
+          }
+          return SKIP;
+        }
+        delete node.children[0].properties.className;
+      }
+    );
+  };
+};
+export {
+  DEFAULT_REHYPE_PRETTY_CODE_OPTIONS,
+  rehypeAttachCodeMeta,
+  rehypeParseCodeMeta
+};

package/dist/server/remark-plugins/index.d.ts

@@ -0,0 +1,15 @@
+export { remarkCustomHeadingId } from './remark-custom-heading-id.js';
+export { remarkExportOnlyMetadata } from './remark-export-only-metadata.js';
+export { remarkExportSourceCode } from './remark-export-source-code.js';
+export { remarkMdxFrontMatter } from './remark-mdx-frontmatter.js';
+export { remarkMdxTitle } from './remark-mdx-title.js';
+export { remarkHeadings } from './remark-headings.js';
+export { remarkRemoveImports } from './remark-remove-imports.js';
+export { RemarkLinkRewriteOptions, remarkLinkRewrite } from './remark-link-rewrite.js';
+export { remarkMdxDisableExplicitJsx } from './remark-mdx-disable-explicit-jsx.js';
+export { remarkStaticImage } from './remark-static-image.js';
+export { remarkAssignFrontMatter } from './remark-assign-frontmatter.js';
+import 'mdast';
+import './lib/index.js';
+import 'estree';
+import 'mdast-util-mdxjs-esm';

package/dist/server/remark-plugins/index.js

@@ -0,0 +1,26 @@
+import { remarkCustomHeadingId } from "./remark-custom-heading-id.js";
+import { remarkExportOnlyMetadata } from "./remark-export-only-metadata.js";
+import { remarkExportSourceCode } from "./remark-export-source-code.js";
+import { remarkMdxFrontMatter } from "./remark-mdx-frontmatter.js";
+import { remarkMdxTitle } from "./remark-mdx-title.js";
+import { remarkHeadings } from "./remark-headings.js";
+import { remarkRemoveImports } from "./remark-remove-imports.js";
+import {
+  remarkLinkRewrite
+} from "./remark-link-rewrite.js";
+import { remarkMdxDisableExplicitJsx } from "./remark-mdx-disable-explicit-jsx.js";
+import { remarkStaticImage } from "./remark-static-image.js";
+import { remarkAssignFrontMatter } from "./remark-assign-frontmatter.js";
+export {
+  remarkAssignFrontMatter,
+  remarkCustomHeadingId,
+  remarkExportOnlyMetadata,
+  remarkExportSourceCode,
+  remarkHeadings,
+  remarkLinkRewrite,
+  remarkMdxDisableExplicitJsx,
+  remarkMdxFrontMatter,
+  remarkMdxTitle,
+  remarkRemoveImports,
+  remarkStaticImage
+};

package/dist/server/remark-plugins/remark-assign-frontmatter.d.ts

@@ -0,0 +1,10 @@
+import { Root } from 'mdast';
+import { Plugin } from './lib/index.js';
+
+declare const remarkAssignFrontMatter: Plugin<[
+    {
+        lastCommitTime?: number;
+    }
+], Root>;
+
+export { remarkAssignFrontMatter };

package/dist/server/remark-plugins/remark-assign-frontmatter.js

@@ -0,0 +1,24 @@
+import path from "path";
+import { valueToEstree } from "estree-util-value-to-estree";
+import slash from "slash";
+import { CWD } from "../constants.js";
+import { getFrontMatterASTObject, isExportNode } from "./remark-mdx-title.js";
+const remarkAssignFrontMatter = ({ lastCommitTime }) => (ast, file) => {
+  const frontMatterNode = ast.children.find(
+    (node) => isExportNode(node, "metadata")
+  );
+  const frontMatter = getFrontMatterASTObject(frontMatterNode);
+  const [filePath] = file.history;
+  const { readingTime, title } = file.data;
+  const { properties } = valueToEstree({
+    ...title && { title },
+    // File path can be undefined (e.g. dynamic mdx without filePath provided to processor)
+    ...filePath && { filePath: slash(path.relative(CWD, filePath)) },
+    ...readingTime && { readingTime },
+    ...lastCommitTime && { timestamp: lastCommitTime }
+  });
+  frontMatter.push(...properties);
+};
+export {
+  remarkAssignFrontMatter
+};

package/dist/server/remark-plugins/remark-custom-heading-id.d.ts

@@ -0,0 +1,9 @@
+import { Root } from 'mdast';
+import { Plugin } from './lib/index.js';
+
+type HProperties = {
+    id?: string;
+};
+declare const remarkCustomHeadingId: Plugin<[], Root>;
+
+export { type HProperties, remarkCustomHeadingId };

package/dist/server/remark-plugins/remark-custom-heading-id.js

@@ -0,0 +1,18 @@
+import { visit } from "unist-util-visit";
+const transformer = (ast) => {
+  visit(ast, "heading", (node) => {
+    const lastChild = node.children.at(-1);
+    if (lastChild?.type !== "text") return;
+    const heading = lastChild.value;
+    const matched = heading.match(/\s*\[#([^]+?)]\s*$/);
+    if (!matched) return;
+    node.data ||= {};
+    const headingProps = node.data.hProperties ||= {};
+    headingProps.id = matched[1];
+    lastChild.value = heading.slice(0, matched.index);
+  });
+};
+const remarkCustomHeadingId = () => transformer;
+export {
+  remarkCustomHeadingId
+};

package/dist/server/remark-plugins/remark-export-only-metadata.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from './lib/index.js';
+
+declare const remarkExportOnlyMetadata: Plugin<[], Root>;
+
+export { remarkExportOnlyMetadata };

package/dist/server/remark-plugins/remark-export-only-metadata.js

@@ -0,0 +1,18 @@
+import { remove } from "unist-util-remove";
+const transformer = (ast) => {
+  remove(ast, (node) => {
+    const isMdxJs = node.type === "mdxjsEsm";
+    if (!isMdxJs) return true;
+    const [body] = node.data.estree.body;
+    const isExportNamed = body.type === "ExportNamedDeclaration";
+    if (!isExportNamed) return true;
+    const isVariableDeclaration = body.declaration?.type === "VariableDeclaration";
+    if (!isVariableDeclaration) return true;
+    const isMetadata = body.declaration.declarations[0].id.name === "metadata";
+    return !isMetadata;
+  });
+};
+const remarkExportOnlyMetadata = () => transformer;
+export {
+  remarkExportOnlyMetadata
+};

package/dist/server/remark-plugins/remark-export-source-code.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from './lib/index.js';
+
+declare const remarkExportSourceCode: Plugin<[], Root>;
+
+export { remarkExportSourceCode };

package/dist/server/remark-plugins/remark-export-source-code.js

@@ -0,0 +1,35 @@
+const remarkExportSourceCode = () => (ast, file) => {
+  ast.children.push({
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            specifiers: [],
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "const",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: { type: "Identifier", name: "sourceCode" },
+                  init: {
+                    type: "Literal",
+                    value: String(file.value).trim()
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  });
+};
+export {
+  remarkExportSourceCode
+};

package/dist/server/remark-plugins/remark-headings.d.ts

@@ -0,0 +1,12 @@
+import { Root, Parent } from 'mdast';
+import { Plugin } from './lib/index.js';
+
+declare const getFlattenedValue: (node: Parent) => string;
+declare const remarkHeadings: Plugin<[
+    {
+        exportName?: string;
+        isRemoteContent?: boolean;
+    }
+], Root>;
+
+export { getFlattenedValue, remarkHeadings };