feat: migrate to starlight

node_modules/rehype-expressive-code/dist/hast.d.ts

@@ -0,0 +1 @@
+export * from 'expressive-code/hast';

node_modules/rehype-expressive-code/dist/hast.js

@@ -0,0 +1,3 @@
+// src/hast.ts
+export * from "expressive-code/hast";
+//# sourceMappingURL=hast.js.map

node_modules/rehype-expressive-code/dist/hast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hast.ts"],"sourcesContent":["export * from 'expressive-code/hast'\n"],"mappings":";AAAA,cAAc;","names":[]}

node_modules/rehype-expressive-code/dist/index.d.ts

@@ -0,0 +1,95 @@
+import { VFileWithOutput } from 'unified';
+import { VFile } from 'vfile';
+import { ExpressiveCodeConfig, ExpressiveCodeBlockOptions, ExpressiveCodeBlock, BundledShikiTheme, ExpressiveCodeTheme, ExpressiveCodeThemeInput, ExpressiveCode } from 'expressive-code';
+export * from 'expressive-code';
+import { Root } from 'expressive-code/hast';
+
+type AnyVFile = VFile | VFileWithOutput<null>;
+
+type RehypeExpressiveCodeOptions = Omit<ExpressiveCodeConfig, 'themes'> & {
+    /**
+     * The color themes that should be available for your code blocks.
+     *
+     * CSS variables will be generated for all themes, allowing to select the theme to display
+     * using CSS. If you specify one dark and one light theme, a `prefers-color-scheme` media query
+     * will also be generated by default. You can customize this to match your site's needs
+     * through the `useDarkModeMediaQuery` and `themeCssSelector` options.
+     *
+     * The following item types are supported in this array:
+     * - any theme name bundled with Shiki (e.g. `dracula`)
+     * - any theme object compatible with VS Code or Shiki (e.g. imported from an NPM theme package)
+     * - any ExpressiveCodeTheme instance (e.g. using `ExpressiveCodeTheme.fromJSONString(...)`
+     *   to load a custom JSON/JSONC theme file yourself)
+     *
+     * Defaults to `['github-dark', 'github-light']`, two themes bundled with Shiki.
+     */
+    themes?: ThemeObjectOrShikiThemeName[] | undefined;
+    /**
+     * The number of spaces that should be used to render tabs. Defaults to 2.
+     *
+     * Any tabs found in code blocks in your markdown/MDX documents will be replaced
+     * with the specified number of spaces. This ensures that the code blocks are
+     * rendered consistently across browsers and platforms.
+     *
+     * If you want to preserve tabs in your code blocks, set this option to 0.
+     */
+    tabWidth?: number | undefined;
+    /**
+     * This optional function provides support for multi-language sites by allowing you
+     * to customize the locale used for a given code block.
+     *
+     * If the function returns `undefined`, the default locale provided in the
+     * Expressive Code configuration is used.
+     */
+    getBlockLocale?: (({ input, file }: {
+        input: ExpressiveCodeBlockOptions;
+        file: AnyVFile;
+    }) => string | undefined | Promise<string | undefined>) | undefined;
+    /**
+     * This optional function allows you to customize how `ExpressiveCodeBlock`
+     * instances are created from code blocks found in the Markdown document.
+     *
+     * The function is called with an object containing the following properties:
+     * - `input`: Block data for the `ExpressiveCodeBlock` constructor.
+     * - `file`: A `VFile` instance representing the Markdown document.
+     *
+     * The function is expected to return an `ExpressiveCodeBlock` instance
+     * or a promise resolving to one.
+     */
+    customCreateBlock?: (({ input, file }: {
+        input: ExpressiveCodeBlockOptions;
+        file: AnyVFile;
+    }) => ExpressiveCodeBlock | Promise<ExpressiveCodeBlock>) | undefined;
+    /**
+     * This advanced option allows you to influence the rendering process by creating
+     * your own `ExpressiveCode` instance or processing the base styles and JS modules
+     * added to every page.
+     *
+     * The return value will be cached and used for all code blocks on the site.
+     */
+    customCreateRenderer?: ((options: RehypeExpressiveCodeOptions) => Promise<RehypeExpressiveCodeRenderer> | RehypeExpressiveCodeRenderer) | undefined;
+};
+type ThemeObjectOrShikiThemeName = BundledShikiTheme | ExpressiveCodeTheme | ExpressiveCodeThemeInput;
+type RehypeExpressiveCodeDocument = {
+    /**
+     * The full path to the source file containing the code block.
+     */
+    sourceFilePath?: string | undefined;
+};
+type RehypeExpressiveCodeRenderer = {
+    ec: ExpressiveCode;
+    baseStyles: string;
+    themeStyles: string;
+    jsModules: string[];
+};
+/**
+ * Creates an `ExpressiveCode` instance using the given `options`,
+ * including support to load themes bundled with Shiki by name.
+ *
+ * Returns the created `ExpressiveCode` instance together with the base styles and JS modules
+ * that should be added to every page.
+ */
+declare function createRenderer(options?: RehypeExpressiveCodeOptions): Promise<RehypeExpressiveCodeRenderer>;
+declare function rehypeExpressiveCode(options?: RehypeExpressiveCodeOptions): (tree: Root, file: AnyVFile) => Promise<void>;
+
+export { RehypeExpressiveCodeDocument, RehypeExpressiveCodeOptions, RehypeExpressiveCodeRenderer, ThemeObjectOrShikiThemeName, createRenderer, rehypeExpressiveCode as default };

node_modules/rehype-expressive-code/dist/index.js

@@ -0,0 +1,243 @@
+// src/index.ts
+import {
+  loadShikiTheme,
+  ExpressiveCode,
+  ExpressiveCodeTheme,
+  ExpressiveCodeBlock
+} from "expressive-code";
+import { visit } from "expressive-code/hast";
+
+// src/utils.ts
+import { getClassNames } from "expressive-code/hast";
+function getCodeBlockInfo(pre) {
+  if (pre.tagName !== "pre" || pre.children.length !== 1)
+    return;
+  const code = pre.children[0];
+  if (code.type !== "element" || code.tagName !== "code")
+    return;
+  const text = code.children[0];
+  if (text.type !== "text")
+    return;
+  const langClass = getClassNames(code).find((c) => c.startsWith("language-")) ?? "";
+  const lang = langClass.replace("language-", "");
+  const meta = code.data?.meta ?? code.properties?.metastring ?? "";
+  return {
+    pre,
+    code,
+    lang,
+    text: text.value,
+    meta
+  };
+}
+function createInlineAssetElement({
+  tagName,
+  properties = {},
+  innerHTML,
+  useMdxJsx
+}) {
+  if (useMdxJsx)
+    return createMdxJsxElementWithInnerHTML(tagName, properties, innerHTML);
+  return {
+    type: "element",
+    tagName,
+    properties,
+    children: [{ type: "text", value: innerHTML }]
+  };
+}
+function createMdxJsxElementWithInnerHTML(tagName, properties, innerHTML) {
+  const attrs = Object.entries(properties).map(([name, value]) => ({
+    type: "mdxJsxAttribute",
+    name,
+    value
+  }));
+  return {
+    type: "mdxJsxFlowElement",
+    name: tagName,
+    attributes: [
+      ...attrs,
+      {
+        type: "mdxJsxAttribute",
+        name: "dangerouslySetInnerHTML",
+        value: {
+          type: "mdxJsxAttributeValueExpression",
+          value: `{__html:${JSON.stringify(innerHTML)}}`,
+          data: {
+            estree: {
+              type: "Program",
+              body: [
+                {
+                  type: "ExpressionStatement",
+                  expression: {
+                    type: "ObjectExpression",
+                    properties: [
+                      {
+                        type: "Property",
+                        method: false,
+                        shorthand: false,
+                        computed: false,
+                        key: {
+                          type: "Identifier",
+                          name: "__html"
+                        },
+                        value: {
+                          type: "Literal",
+                          value: innerHTML,
+                          raw: JSON.stringify(innerHTML)
+                        },
+                        kind: "init"
+                      }
+                    ]
+                  }
+                }
+              ],
+              sourceType: "module",
+              comments: []
+            }
+          }
+        }
+      }
+    ],
+    data: {
+      _mdxExplicitJsx: true
+    },
+    children: []
+  };
+}
+
+// src/index.ts
+export * from "expressive-code";
+async function createRenderer(options = {}) {
+  const deprecatedOptions = options;
+  if (deprecatedOptions.theme && !options.themes) {
+    options.themes = Array.isArray(deprecatedOptions.theme) ? deprecatedOptions.theme : [deprecatedOptions.theme];
+    delete deprecatedOptions.theme;
+  }
+  const { themes, ...ecOptions } = options;
+  const loadedThemes = themes && await Promise.all(
+    (Array.isArray(themes) ? themes : [themes]).map(async (theme) => {
+      const mustLoadTheme = theme !== void 0 && !(theme instanceof ExpressiveCodeTheme);
+      const optLoadedTheme = mustLoadTheme ? new ExpressiveCodeTheme(typeof theme === "string" ? await loadShikiTheme(theme) : theme) : theme;
+      return optLoadedTheme;
+    })
+  );
+  const ec = new ExpressiveCode({
+    themes: loadedThemes,
+    ...ecOptions
+  });
+  const baseStyles = await ec.getBaseStyles();
+  const themeStyles = await ec.getThemeStyles();
+  const jsModules = await ec.getJsModules();
+  return {
+    ec,
+    baseStyles,
+    themeStyles,
+    jsModules
+  };
+}
+function rehypeExpressiveCode(options = {}) {
+  const { tabWidth = 2, getBlockLocale, customCreateRenderer, customCreateBlock } = options;
+  let asyncRenderer;
+  const renderBlockToHast = async ({
+    codeBlock,
+    renderer,
+    addedStyles,
+    addedJsModules,
+    useMdxJsx
+  }) => {
+    const { ec, baseStyles, themeStyles, jsModules } = renderer;
+    const { renderedGroupAst, styles } = await ec.render(codeBlock);
+    const extraElements = [];
+    const stylesToPrepend = [];
+    if (baseStyles && !addedStyles.has(baseStyles)) {
+      addedStyles.add(baseStyles);
+      stylesToPrepend.push(baseStyles);
+    }
+    if (themeStyles && !addedStyles.has(themeStyles)) {
+      addedStyles.add(themeStyles);
+      stylesToPrepend.push(themeStyles);
+    }
+    for (const style of styles) {
+      if (addedStyles.has(style))
+        continue;
+      addedStyles.add(style);
+      stylesToPrepend.push(style);
+    }
+    if (stylesToPrepend.length) {
+      extraElements.push(
+        createInlineAssetElement({
+          tagName: "style",
+          innerHTML: stylesToPrepend.join(""),
+          useMdxJsx
+        })
+      );
+    }
+    jsModules.forEach((moduleCode) => {
+      if (addedJsModules.has(moduleCode))
+        return;
+      addedJsModules.add(moduleCode);
+      extraElements.push(
+        createInlineAssetElement({
+          tagName: "script",
+          properties: { type: "module" },
+          innerHTML: moduleCode,
+          useMdxJsx
+        })
+      );
+    });
+    renderedGroupAst.children.unshift(...extraElements);
+    return renderedGroupAst;
+  };
+  const transformer = async (tree, file) => {
+    const nodesToProcess = [];
+    visit(tree, "element", (element, index, parent) => {
+      if (index === null || !parent)
+        return;
+      const codeBlockInfo = getCodeBlockInfo(element);
+      if (codeBlockInfo)
+        nodesToProcess.push([parent, codeBlockInfo]);
+    });
+    if (nodesToProcess.length === 0)
+      return;
+    if (asyncRenderer === void 0) {
+      asyncRenderer = (customCreateRenderer ?? createRenderer)(options);
+    }
+    const renderer = await asyncRenderer;
+    const isAstro = file.data?.astro !== void 0;
+    const isMdx = file.path?.endsWith(".mdx") ?? false;
+    const useMdxJsx = !isAstro && isMdx;
+    const addedStyles = /* @__PURE__ */ new Set();
+    const addedJsModules = /* @__PURE__ */ new Set();
+    for (let groupIndex = 0; groupIndex < nodesToProcess.length; groupIndex++) {
+      const [parent, code] = nodesToProcess[groupIndex];
+      let normalizedCode = code.text;
+      if (tabWidth > 0)
+        normalizedCode = normalizedCode.replace(/\t/g, " ".repeat(tabWidth));
+      const input = {
+        code: normalizedCode,
+        language: code.lang || "",
+        meta: code.meta || "",
+        parentDocument: {
+          sourceFilePath: file.path,
+          documentRoot: tree,
+          positionInDocument: {
+            groupIndex,
+            totalGroups: nodesToProcess.length
+          }
+        }
+      };
+      if (getBlockLocale) {
+        input.locale = await getBlockLocale({ input, file });
+      }
+      const codeBlock = customCreateBlock ? await customCreateBlock({ input, file }) : new ExpressiveCodeBlock(input);
+      const renderedBlock = await renderBlockToHast({ codeBlock, renderer, addedStyles, addedJsModules, useMdxJsx });
+      parent.children.splice(parent.children.indexOf(code.pre), 1, renderedBlock);
+    }
+  };
+  return transformer;
+}
+var src_default = rehypeExpressiveCode;
+export {
+  createRenderer,
+  src_default as default
+};
+//# sourceMappingURL=index.js.map