@astrojs/starlight 0.41.11 → 0.42.0

package/dist/integrations/remark-asides.d.ts

@@ -0,0 +1,32 @@
+import { MarkdownProcessorPluginOptions } from "./markdown-processor.js";
+import { Root } from "mdast";
+import { Plugin } from "unified";
+//#region src/integrations/remark-asides.d.ts
+/**
+ * remark plugin that converts blocks delimited with `:::` into styled
+ * asides (a.k.a. “callouts”, “admonitions”, etc.). Depends on the
+ * `remark-directive` module for the core parsing logic.
+ *
+ * For example, this Markdown
+ *
+ * ```md
+ * :::tip[Did you know?]
+ * Astro helps you build faster websites with “Islands Architecture”.
+ * :::
+ * ```
+ *
+ * will produce this output
+ *
+ * ```astro
+ * <aside class="starlight-aside starlight-aside--tip" aria-label="Did you know?">
+ *   <p class="starlight-aside__title" aria-hidden="true">Did you know?</p>
+ *   <div class="starlight-aside__content">
+ *     <p>Astro helps you build faster websites with “Islands Architecture”.</p>
+ *   </div>
+ * </aside>
+ * ```
+ */
+declare function remarkAsides(options: MarkdownProcessorPluginOptions): Plugin<[], Root>;
+declare function remarkDirectivesRestoration(): (tree: Root) => void;
+//#endregion
+export { remarkAsides, remarkDirectivesRestoration };

package/dist/integrations/remark-asides.js

@@ -0,0 +1,166 @@
+import { parseIconChildren } from "./markdown-icon.js";
+import { getAsideIcon, isAsideVariant } from "./aside-utils.js";
+import { directiveToMarkdown } from "mdast-util-directive";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { visit } from "unist-util-visit";
+import { h, s } from "hastscript";
+import { toString } from "mdast-util-to-string";
+//#region src/integrations/remark-asides.ts
+/** Hacky function that generates an mdast HTML tree ready for conversion to HTML by rehype. */
+function h$1(el, attrs = {}, children = []) {
+	const { tagName, properties } = h(el, attrs);
+	return {
+		type: "paragraph",
+		data: {
+			hName: tagName,
+			hProperties: properties
+		},
+		children
+	};
+}
+/** Hacky function that generates an mdast SVG tree ready for conversion to HTML by rehype. */
+function s$1(el, attrs = {}, children = []) {
+	const { tagName, properties } = s(el, attrs);
+	return {
+		type: "paragraph",
+		data: {
+			hName: tagName,
+			hProperties: properties
+		},
+		children
+	};
+}
+/** Checks if a node is a directive. */
+function isNodeDirective(node) {
+	return node.type === "textDirective" || node.type === "leafDirective" || node.type === "containerDirective";
+}
+/**
+* Transforms back directives not handled by Starlight to avoid breaking user content.
+* For example, a user might write `x:y` in the middle of a sentence, where `:y` would be
+* identified as a text directive, which are not used by Starlight, and we definitely want that
+* text to be rendered verbatim in the output.
+*/
+function transformUnhandledDirective(node, index, parent) {
+	let markdown = toMarkdown(node, { extensions: [directiveToMarkdown()] });
+	/**
+	* `mdast-util-to-markdown` assumes that the tree represents a complete document (as it's an AST
+	* and not a CST) and to follow the POSIX definition of a line (a sequence of zero or more
+	* non- <newline> characters plus a terminating <newline> character), a newline is automatically
+	* added at the end of the output so that the output is a valid file.
+	* In this specific case, we can safely remove the newline character at the end of the output
+	* before replacing the directive with its value.
+	*
+	* @see https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_206
+	* @see https://github.com/syntax-tree/mdast-util-to-markdown/blob/fd6a508cc619b862f75b762dcf876c6b8315d330/lib/index.js#L79-L85
+	*/
+	if (markdown.at(-1) === "\n") markdown = markdown.slice(0, -1);
+	const textNode = {
+		type: "text",
+		value: markdown
+	};
+	if (node.type === "textDirective") parent.children[index] = textNode;
+	else parent.children[index] = {
+		type: "paragraph",
+		children: [textNode]
+	};
+}
+/** Hacky function that generates the children of an mdast SVG tree. */
+function makeSvgChildNodes(children) {
+	const nodes = [];
+	for (const child of children) {
+		if (child.type !== "element") continue;
+		nodes.push({
+			type: "paragraph",
+			data: {
+				hName: child.tagName,
+				hProperties: child.properties
+			},
+			children: makeSvgChildNodes(child.children)
+		});
+	}
+	return nodes;
+}
+/**
+* remark plugin that converts blocks delimited with `:::` into styled
+* asides (a.k.a. “callouts”, “admonitions”, etc.). Depends on the
+* `remark-directive` module for the core parsing logic.
+*
+* For example, this Markdown
+*
+* ```md
+* :::tip[Did you know?]
+* Astro helps you build faster websites with “Islands Architecture”.
+* :::
+* ```
+*
+* will produce this output
+*
+* ```astro
+* <aside class="starlight-aside starlight-aside--tip" aria-label="Did you know?">
+*   <p class="starlight-aside__title" aria-hidden="true">Did you know?</p>
+*   <div class="starlight-aside__content">
+*     <p>Astro helps you build faster websites with “Islands Architecture”.</p>
+*   </div>
+* </aside>
+* ```
+*/
+function remarkAsides(options) {
+	const iconPaths = {
+		note: parseIconChildren(getAsideIcon("note")),
+		tip: parseIconChildren(getAsideIcon("tip")),
+		caution: parseIconChildren(getAsideIcon("caution")),
+		danger: parseIconChildren(getAsideIcon("danger"))
+	};
+	const transformer = (tree, file) => {
+		const lang = options.absolutePathToLang(file.path);
+		const t = options.useTranslations(lang);
+		visit(tree, (node, index, parent) => {
+			if (!parent || index === void 0 || !isNodeDirective(node)) return;
+			if (node.type === "textDirective" || node.type === "leafDirective") return;
+			const variant = node.name;
+			const attributes = node.attributes;
+			if (!isAsideVariant(variant)) return;
+			let title = t(`aside.${variant}`);
+			let titleNode = [{
+				type: "text",
+				value: title
+			}];
+			const firstChild = node.children[0];
+			if (firstChild?.type === "paragraph" && firstChild.data && "directiveLabel" in firstChild.data && firstChild.children.length > 0) {
+				titleNode = firstChild.children;
+				title = toString(firstChild.children);
+				node.children.splice(0, 1);
+			}
+			const iconPath = makeSvgChildNodes(attributes?.["icon"] ? parseIconChildren(getAsideIcon(variant, attributes?.["icon"])) : iconPaths[variant]);
+			const aside = h$1("aside", {
+				"aria-label": title,
+				class: `starlight-aside starlight-aside--${variant}`
+			}, [h$1("p", {
+				class: "starlight-aside__title",
+				"aria-hidden": "true"
+			}, [s$1("svg", {
+				viewBox: "0 0 24 24",
+				width: 16,
+				height: 16,
+				fill: "currentColor",
+				class: "starlight-aside__icon"
+			}, iconPath), ...titleNode]), h$1("div", { class: "starlight-aside__content" }, node.children)]);
+			parent.children[index] = aside;
+		});
+	};
+	return function attacher() {
+		return transformer;
+	};
+}
+function remarkDirectivesRestoration() {
+	return function transformer(tree) {
+		visit(tree, (node, index, parent) => {
+			if (index !== void 0 && parent && (node.type === "textDirective" || node.type === "leafDirective") && node.data === void 0) {
+				transformUnhandledDirective(node, index, parent);
+				return;
+			}
+		});
+	};
+}
+//#endregion
+export { remarkAsides, remarkDirectivesRestoration };

package/dist/integrations/remark-rehype.d.ts

@@ -0,0 +1,17 @@
+import { MarkdownProcessorPluginOptions } from "./markdown-processor.js";
+import { remarkDirectivesRestoration } from "./remark-asides.js";
+import { isUnifiedProcessor } from "@astrojs/markdown-remark";
+import { Root } from "hast";
+import { Root as Root$1 } from "mdast";
+import { Plugin } from "unified";
+declare namespace remark_rehype_d_exports {
+  export { isUnifiedProcessor, remarkDirectivesRestoration, starlightRehypePlugins, starlightRemarkPlugins };
+}
+/** List of remark plugins to apply. */
+declare function starlightRemarkPlugins(options: MarkdownProcessorPluginOptions): RemarkPlugin[];
+/** List of rehype plugins to apply. */
+declare function starlightRehypePlugins(options: MarkdownProcessorPluginOptions): RehypePlugin[];
+type RemarkPlugin = Plugin<[], Root$1>;
+type RehypePlugin = Plugin<[], Root>;
+//#endregion
+export { isUnifiedProcessor, remarkDirectivesRestoration, remark_rehype_d_exports, starlightRehypePlugins, starlightRemarkPlugins };

package/dist/integrations/remark-rehype.js

@@ -0,0 +1,51 @@
+import { getMarkdownProcessorPaths, shouldTransformPath } from "./markdown-processor.js";
+import { rehypeRtlCodeSupport } from "./rehype-code-rtl-support.js";
+import rehypeAutolinkHeadings from "./rehype-heading-links.js";
+import { remarkAsides, remarkDirectivesRestoration } from "./remark-asides.js";
+import { isUnifiedProcessor, rehypeHeadingIds } from "@astrojs/markdown-remark";
+import remarkDirective from "remark-directive";
+//#region src/integrations/remark-rehype.ts
+/** List of remark plugins to apply. */
+function starlightRemarkPlugins(options) {
+	return [remarkDirective, remarkPlugins(options)];
+}
+/** List of rehype plugins to apply. */
+function starlightRehypePlugins(options) {
+	return [...options.starlightConfig.markdown.headingLinks ? [[rehypeHeadingIds]] : [], rehypePlugins(options)];
+}
+/** Remark plugin applying other Starlight remark plugins if necessary. */
+function remarkPlugins(options) {
+	const allowedPaths = getMarkdownProcessorPaths(options);
+	return function attacher() {
+		const remarkAsidesTransformer = remarkAsides(options).call(this);
+		return async function transformer(...args) {
+			const [, file] = args;
+			if (!shouldTransformFile(file, allowedPaths)) return;
+			await remarkAsidesTransformer(...args);
+		};
+	};
+}
+/** Rehype plugin applying other Starlight rehype plugins if necessary. */
+function rehypePlugins(options) {
+	const allowedPaths = getMarkdownProcessorPaths(options);
+	return function attacher() {
+		const rehypeRtlCodeSupportTransformer = rehypeRtlCodeSupport(options).call(this);
+		const rehypeAutolinkHeadingsTransformer = rehypeAutolinkHeadings(options).call(this);
+		return async function transformer(...args) {
+			const [, file] = args;
+			if (!shouldTransformFile(file, allowedPaths)) return;
+			await rehypeRtlCodeSupportTransformer(...args);
+			if (options.starlightConfig.markdown.headingLinks) await rehypeAutolinkHeadingsTransformer(...args);
+		};
+	};
+}
+/**
+* Determines if a file should be transformed by a remark/rehype plugin, e.g. files without a known
+* path or files that are not part of the allowed paths are skipped.
+*/
+function shouldTransformFile(file, allowedPaths) {
+	if (!file?.path) return false;
+	return shouldTransformPath(file.path, allowedPaths);
+}
+//#endregion
+export { isUnifiedProcessor, remarkDirectivesRestoration, starlightRehypePlugins, starlightRemarkPlugins };

package/dist/integrations/satteri.d.ts

@@ -0,0 +1,13 @@
+import { MarkdownProcessorPluginOptions } from "./markdown-processor.js";
+import { HastPluginEntry, MdastPluginDefinition, MdastPluginEntry } from "satteri";
+//#region src/integrations/satteri.d.ts
+declare function starlightSatteriPlugins(options: MarkdownProcessorPluginOptions): {
+  mdastPlugins: MdastPluginEntry[];
+  hastPlugins: HastPluginEntry[];
+};
+/**
+ * Recover directives Starlight didn't claim so user content isn't dropped
+ */
+declare function satteriDirectivesRestoration(): MdastPluginDefinition;
+//#endregion
+export { satteriDirectivesRestoration, starlightSatteriPlugins };

package/dist/integrations/satteri.js

@@ -0,0 +1,209 @@
+import { headingLinkIconChildren } from "./markdown-icon.js";
+import { getAsideIcon, isAsideVariant } from "./aside-utils.js";
+import { getMarkdownProcessorPaths, shouldTransformPath } from "./markdown-processor.js";
+import { satteriHeadingIdsPlugin } from "@astrojs/markdown-satteri";
+import { fileURLToPath } from "node:url";
+import { directiveToMarkdown } from "mdast-util-directive";
+import { toMarkdown } from "mdast-util-to-markdown";
+//#region src/integrations/satteri.ts
+function starlightSatteriPlugins(options) {
+	const allowedPaths = getMarkdownProcessorPaths(options);
+	return {
+		mdastPlugins: [({ fileURL, sourceFormat }) => {
+			if (!shouldTransformPath(fileURL, allowedPaths)) return;
+			const lang = options.absolutePathToLang(fileURLToPath(fileURL));
+			return satteriAsidesPlugin(options.useTranslations(lang), sourceFormat);
+		}],
+		hastPlugins: [({ fileURL }) => {
+			if (!shouldTransformPath(fileURL, allowedPaths)) return;
+			const plugins = [satteriRtlCodeSupportPlugin()];
+			if (options.starlightConfig.markdown.headingLinks) {
+				const lang = options.absolutePathToLang(fileURLToPath(fileURL));
+				const t = options.useTranslations(lang);
+				plugins.push(satteriHeadingIdsPlugin(), satteriAutolinkHeadingsPlugin(t));
+			}
+			return plugins;
+		}]
+	};
+}
+/**
+* Recover directives Starlight didn't claim so user content isn't dropped
+*/
+function satteriDirectivesRestoration() {
+	return {
+		name: "starlight-directives-restoration",
+		textDirective(node) {
+			if (node.data !== void 0) return;
+			return {
+				type: "text",
+				value: serializeDirective(node)
+			};
+		},
+		leafDirective(node) {
+			if (node.data !== void 0) return;
+			return {
+				type: "paragraph",
+				children: [{
+					type: "text",
+					value: serializeDirective(node)
+				}]
+			};
+		},
+		containerDirective(node) {
+			if (node.data !== void 0) return;
+			return paragraphElement("div", {}, [...node.children]);
+		}
+	};
+}
+function paragraphElement(tagName, properties, children = []) {
+	return {
+		type: "paragraph",
+		data: {
+			hName: tagName,
+			hProperties: properties
+		},
+		children
+	};
+}
+/** Convert `:::variant` directive blocks into styled asides. */
+function satteriAsidesPlugin(t, sourceFormat) {
+	return {
+		name: "starlight-asides",
+		containerDirective(node, ctx) {
+			if (!isAsideVariant(node.name)) return;
+			const variant = node.name;
+			let title = t(`aside.${variant}`);
+			let titleNode = [{
+				type: "text",
+				value: title
+			}];
+			const children = [...node.children];
+			const firstChild = children[0];
+			if (firstChild?.type === "paragraph" && firstChild.data?.directiveLabel && firstChild.children.length > 0) {
+				titleNode = firstChild.children;
+				title = ctx.textContent(firstChild);
+				children.shift();
+			}
+			const iconSvg = `<svg viewBox="0 0 24 24" width="16" height="16" fill="currentColor" class="starlight-aside__icon">${getAsideIcon(variant, node.attributes?.["icon"])}</svg>`;
+			const iconNode = sourceFormat === "mdx" ? {
+				type: "mdxJsxTextElement",
+				name: "Fragment",
+				attributes: [{
+					type: "mdxJsxAttribute",
+					name: "set:html",
+					value: iconSvg
+				}]
+			} : {
+				type: "html",
+				value: iconSvg
+			};
+			return paragraphElement("aside", {
+				"aria-label": title,
+				class: `starlight-aside starlight-aside--${variant}`
+			}, [paragraphElement("p", {
+				class: "starlight-aside__title",
+				"aria-hidden": "true"
+			}, [iconNode, ...titleNode]), paragraphElement("div", { class: "starlight-aside__content" }, children)]);
+		}
+	};
+}
+function serializeDirective(node) {
+	const md = toMarkdown(node, { extensions: [directiveToMarkdown()] });
+	return md.at(-1) === "\n" ? md.slice(0, -1) : md;
+}
+function satteriRtlCodeSupportPlugin() {
+	return {
+		name: "starlight-rtl-code-support",
+		element: [{
+			filter: ["pre"],
+			visit(node, ctx) {
+				if (node.properties && "dir" in node.properties) return;
+				ctx.setProperty(node, "dir", "ltr");
+			}
+		}, {
+			filter: ["code"],
+			visit(node, ctx) {
+				if (!(node.properties && "dir" in node.properties) && !hasPreParent(node, ctx)) ctx.setProperty(node, "dir", "auto");
+			}
+		}]
+	};
+}
+/**
+* Check if any parent of `child` is a `<pre>` element by walking up the tree.
+*/
+function hasPreParent(child, ctx) {
+	while (child) {
+		const parent = ctx.parent(child);
+		if (parent?.type === "element" && parent.tagName === "pre") return true;
+		child = parent;
+	}
+	return false;
+}
+function satteriAutolinkHeadingsPlugin(t) {
+	return {
+		name: "starlight-autolink-headings",
+		element: {
+			filter: [
+				"h1",
+				"h2",
+				"h3",
+				"h4",
+				"h5",
+				"h6"
+			],
+			visit(node, ctx) {
+				const id = node.properties?.["id"];
+				if (typeof id !== "string" || !id) return;
+				const accessibleLabel = t("heading.anchorLabel", {
+					title: ctx.textContent(node),
+					interpolation: { escapeValue: false }
+				});
+				return {
+					type: "element",
+					tagName: "div",
+					properties: { class: `sl-heading-wrapper level-${node.tagName}` },
+					children: [node, {
+						type: "element",
+						tagName: "a",
+						properties: {
+							class: "sl-anchor-link",
+							href: "#" + id
+						},
+						children: [{
+							type: "element",
+							tagName: "span",
+							properties: {
+								"aria-hidden": "true",
+								class: "sl-anchor-icon"
+							},
+							children: [{
+								type: "element",
+								tagName: "svg",
+								properties: {
+									width: "16",
+									height: "16",
+									viewBox: "0 0 24 24",
+									fill: "currentColor"
+								},
+								children: headingLinkIconChildren
+							}]
+						}, {
+							type: "element",
+							tagName: "span",
+							properties: {
+								class: "sr-only",
+								"data-pagefind-ignore": true
+							},
+							children: [{
+								type: "text",
+								value: accessibleLabel
+							}]
+						}]
+					}]
+				};
+			}
+		}
+	};
+}
+//#endregion
+export { satteriDirectivesRestoration, starlightSatteriPlugins };

package/dist/integrations/shared/absolutePathToLang.d.ts

@@ -0,0 +1,10 @@
+import { StarlightConfig } from "../../utils/user-config.js";
+import "../../types.js";
+//#region src/integrations/shared/absolutePathToLang.d.ts
+/** Get current language from an absolute file path. */
+declare function absolutePathToLang(path: string, { docsPath, starlightConfig }: {
+  docsPath: string;
+  starlightConfig: Pick<StarlightConfig, 'defaultLocale' | 'locales'>;
+}): string;
+//#endregion
+export { absolutePathToLang };

package/dist/integrations/shared/absolutePathToLang.js

@@ -0,0 +1,13 @@
+import { localeToLang } from "./localeToLang.js";
+import { slugToLocale } from "./slugToLocale.js";
+//#region src/integrations/shared/absolutePathToLang.ts
+/** Get current language from an absolute file path. */
+function absolutePathToLang(path, { docsPath, starlightConfig }) {
+	path = path?.replace(/\\/g, "/");
+	if (path && !path.startsWith("/") && docsPath.startsWith("/")) path = "/" + path;
+	const slug = path?.replace(docsPath, "");
+	const locale = slugToLocale(slug, starlightConfig);
+	return localeToLang(starlightConfig, locale);
+}
+//#endregion
+export { absolutePathToLang };

package/dist/integrations/shared/localeToLang.d.ts

@@ -0,0 +1,10 @@
+import { StarlightConfig } from "../../utils/user-config.js";
+import "../../types.js";
+//#region src/integrations/shared/localeToLang.d.ts
+/**
+ * Get the BCP-47 language tag for the given locale.
+ * @param locale Locale string or `undefined` for the root locale.
+ */
+declare function localeToLang(config: Pick<StarlightConfig, 'defaultLocale' | 'locales'>, locale: string | undefined): string;
+//#endregion
+export { localeToLang };

package/dist/integrations/shared/localeToLang.js

@@ -0,0 +1,13 @@
+import { BuiltInDefaultLocale } from "../../utils/i18n.js";
+//#region src/integrations/shared/localeToLang.ts
+/**
+* Get the BCP-47 language tag for the given locale.
+* @param locale Locale string or `undefined` for the root locale.
+*/
+function localeToLang(config, locale) {
+	const lang = locale ? config.locales?.[locale]?.lang : config.locales?.root?.lang;
+	const defaultLang = config.defaultLocale?.lang || config.defaultLocale?.locale;
+	return lang || defaultLang || BuiltInDefaultLocale.lang;
+}
+//#endregion
+export { localeToLang };

package/dist/integrations/shared/slugToLocale.d.ts

@@ -0,0 +1,12 @@
+import { StarlightConfig } from "../../utils/user-config.js";
+import "../../types.js";
+//#region src/integrations/shared/slugToLocale.d.ts
+/**
+ * Get the “locale” of a slug. This is the base path at which a language is served.
+ * For example, if French docs are in `src/content/docs/french/`, the locale is `french`.
+ * Root locale slugs will return `undefined`.
+ * @param slug A collection entry slug
+ */
+declare function slugToLocale(slug: string | undefined, config: Pick<StarlightConfig, 'defaultLocale' | 'locales'>): string | undefined;
+//#endregion
+export { slugToLocale };

package/dist/integrations/shared/slugToLocale.js

@@ -0,0 +1,15 @@
+//#region src/integrations/shared/slugToLocale.ts
+/**
+* Get the “locale” of a slug. This is the base path at which a language is served.
+* For example, if French docs are in `src/content/docs/french/`, the locale is `french`.
+* Root locale slugs will return `undefined`.
+* @param slug A collection entry slug
+*/
+function slugToLocale(slug, config) {
+	const localesConfig = config.locales ?? {};
+	const baseSegment = slug?.split("/")[0];
+	if (baseSegment && localesConfig[baseSegment]) return baseSegment;
+	if (!localesConfig.root) return config.defaultLocale.locale;
+}
+//#endregion
+export { slugToLocale };

package/dist/integrations/sitemap.d.ts

@@ -0,0 +1,12 @@
+import { StarlightConfig } from "../utils/user-config.js";
+import "../types.js";
+import { SitemapOptions } from "@astrojs/sitemap";
+//#region src/integrations/sitemap.d.ts
+declare function getSitemapConfig(opts: StarlightConfig): SitemapOptions;
+/**
+ * A wrapped version of the `@astrojs/sitemap` integration configured based
+ * on Starlight i18n config.
+ */
+declare function starlightSitemap(opts: StarlightConfig): import("astro").AstroIntegration;
+//#endregion
+export { getSitemapConfig, starlightSitemap };

package/dist/integrations/sitemap.js

@@ -0,0 +1,19 @@
+import sitemap from "@astrojs/sitemap";
+//#region src/integrations/sitemap.ts
+function getSitemapConfig(opts) {
+	const sitemapConfig = {};
+	if (opts.isMultilingual) sitemapConfig.i18n = {
+		defaultLocale: opts.defaultLocale.locale || "root",
+		locales: Object.fromEntries(Object.entries(opts.locales).map(([locale, config]) => [locale, config.lang]))
+	};
+	return sitemapConfig;
+}
+/**
+* A wrapped version of the `@astrojs/sitemap` integration configured based
+* on Starlight i18n config.
+*/
+function starlightSitemap(opts) {
+	return sitemap(getSitemapConfig(opts));
+}
+//#endregion
+export { getSitemapConfig, starlightSitemap };

package/dist/integrations/vite-layer-order.d.ts

@@ -0,0 +1,15 @@
+import { ViteUserConfig } from "astro";
+//#region src/integrations/vite-layer-order.d.ts
+/**
+ * Vite plugin that ensures the StarlightPage component is always imported first when imported in
+ * an Astro file.
+ *
+ * This is necessary to ensure a predictable CSS layer order which is defined by the `<Page />`
+ * imported by the `<StarlightPage />` component. If a user imports any other component using
+ * cascade layers before the `<StarlightPage />` component, it will result in undesired layers
+ * being created before we explicitly set the expected layer order.
+ */
+declare function vitePluginStarlightCssLayerOrder(): VitePlugin;
+type VitePlugin = NonNullable<ViteUserConfig['plugins']>[number];
+//#endregion
+export { vitePluginStarlightCssLayerOrder };