@vezham/docs-core 1.0.1

package/dist/index-DydiXvgS.d.ts

@@ -0,0 +1,90 @@
+//#region src/i18n/index.d.ts
+interface I18nConfig<Languages extends string = string> {
+  /**
+   * Supported locale codes.
+   *
+   * A page tree will be built for each language.
+   */
+  languages: Languages[];
+  /**
+   * Default locale if not specified
+   */
+  defaultLanguage: NoInfer<Languages>;
+  /**
+   * Don't show the locale prefix on URL.
+   *
+   * - `always`: Always hide the prefix
+   * - `default-locale`: Only hide the default locale
+   * - `never`: Never hide the prefix
+   *
+   * This API uses `NextResponse.rewrite`.
+   *
+   * @defaultValue 'never'
+   */
+  hideLocale?: 'always' | 'default-locale' | 'never';
+  /**
+   * Used by `loader()`, specify the way to parse i18n file structure.
+   *
+   * @defaultValue 'dot'
+   */
+  parser?: 'dot' | 'dir' | 'none';
+  /**
+   * the fallback language when the page has no translations available for a given locale.
+   *
+   * Default to `defaultLanguage`, no fallback when set to `null`.
+   */
+  fallbackLanguage?: NoInfer<Languages> | null;
+}
+interface TranslationExtension<Keys extends string = string> {
+  keys: readonly Keys[];
+}
+interface TranslationPreset<Keys extends string = string> {
+  name: string;
+  value: Partial<Record<Keys, string>>;
+}
+interface TranslationsAPI<Languages extends string = string, Keys extends string = string> {
+  /** for type inference only, always `undefined` in runtime */
+  $inferLanguages: Languages;
+  /** for type inference only, always `undefined` in runtime */
+  $inferKeys: Keys;
+  config: I18nConfig<Languages>;
+  get: {
+    (lang: Languages): Partial<Record<Keys, string>>;
+    (lang: string): Partial<Record<Keys, string>> | undefined;
+  };
+  /** register allowed translation keys */
+  extend<const NewKeys extends string>(extension: TranslationExtension<NewKeys>): TranslationsAPI<Languages, Keys | NewKeys>;
+  /** add translations */
+  add(overrides: { [Lang in Languages]?: Partial<Record<Keys, string>>; }): TranslationsAPI<Languages, Keys>;
+  /** @deprecated the namespace parameter is now unnecessary  */
+  add(unused: string, overrides: { [Lang in Languages]?: Partial<Record<Keys, string>> & {
+    /** @deprecated the label is no longer used */
+    [key: string]: string;
+  }; }): TranslationsAPI<Languages, Keys>;
+  /** add language pack */
+  preset: (lang: Languages, preset: TranslationPreset<Keys>) => TranslationsAPI<Languages, Keys>;
+}
+interface I18nAPI<Languages extends string = string> extends I18nConfig<Languages> {
+  translations: () => TranslationsAPI<Languages, never>;
+}
+interface SingularTranslationsAPI<Keys extends string = string> {
+  /** for type inference only, always `undefined` in runtime */
+  $inferKeys: Keys;
+  get: () => Partial<Record<Keys, string>>;
+  /** register allowed translation keys */
+  extend<const NewKeys extends string>(extension: TranslationExtension<NewKeys>): SingularTranslationsAPI<Keys | NewKeys>;
+  /** add translations */
+  add(overrides: Partial<Record<Keys, string>>): SingularTranslationsAPI<Keys>;
+  /** @deprecated the namespace parameter is now unnecessary  */
+  add(unused: string, overrides: Partial<Record<Keys, string>> & {
+    /** @deprecated the label is no longer used */
+    [key: string]: string;
+  }): SingularTranslationsAPI<Keys>;
+  /** add language pack */
+  preset: (preset: TranslationPreset<Keys>) => SingularTranslationsAPI<Keys>;
+}
+declare function defineI18n<const Languages extends string>(config: I18nConfig<Languages>): I18nAPI<Languages>;
+/** create translations API without i18n */
+declare function defineTranslations(): SingularTranslationsAPI<never>;
+//#endregion
+export { TranslationPreset as a, defineTranslations as c, TranslationExtension as i, I18nConfig as n, TranslationsAPI as o, SingularTranslationsAPI as r, defineI18n as s, I18nAPI as t };

package/dist/index-E8Qh_yQs.d.ts

@@ -0,0 +1,49 @@
+import { i as Root, n as Item, r as Node, t as Folder } from "./definitions-CFOhwE1k.js";
+//#region src/page-tree/utils.d.ts
+/**
+ * Flatten tree to an array of page nodes
+ */
+declare function flattenTree(nodes: Node[]): Item[];
+/**
+ * Get neighbours of a page, useful for implementing "previous & next" buttons
+ */
+declare function findNeighbour(tree: Root, url: string, options?: {
+  separateRoot?: boolean;
+}): {
+  previous?: Item;
+  next?: Item;
+};
+declare function getPageTreeRoots(pageTree: Root | Folder): (Root | Folder)[];
+/**
+ * Get other **page** nodes that lives under the same parent.
+ *
+ * note: folders & its index nodes are not considered, use `findSiblings()` for more control.
+ */
+declare function getPageTreePeers(treeOrTrees: Root | Record<string, Root>, url: string): Item[];
+/**
+ * Get other tree nodes that lives under the same parent.
+ */
+declare function findSiblings(treeOrTrees: Root | Record<string, Root>, url: string): Node[];
+declare function findParent(from: Root | Folder, url: string): Root | Folder | undefined;
+/**
+ * Search the path of a node in the tree matched by the matcher.
+ *
+ * @returns The path to the target node (from starting root), or null if the page doesn't exist
+ */
+declare function findPath(nodes: Node[], matcher: (node: Node) => boolean, options?: {
+  includeSeparator?: boolean;
+}): Node[] | null;
+/**
+ * Find the structural projection of `page` (under the root folder `from`) in `to`:
+ * the page at the same file path relative to the root folder.
+ */
+declare function findProjection(from: Folder, to: Folder, page: Item): Item | undefined;
+/**
+ * Perform a depth-first search on page tree visiting every node.
+ *
+ * @param root - the root of page tree to visit.
+ * @param visitor - function to receive nodes, return `skip` to skip the children of current node, `break` to stop the search entirely.
+ */
+declare function visit<Root$1 extends Node | Root>(root: Root$1, visitor: <T extends Node | Root>(node: T, parent?: Root | Folder) => 'skip' | 'break' | T | void): Root$1;
+//#endregion
+export { findSiblings as a, getPageTreeRoots as c, findProjection as i, visit as l, findParent as n, flattenTree as o, findPath as r, getPageTreePeers as s, findNeighbour as t };

package/dist/is-equal-LdLqRs0o.js

@@ -0,0 +1,8 @@
+//#region src/utils/is-equal.ts
+function isEqualShallow(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return b.length === a.length && a.every((v, i) => isEqualShallow(v, b[i]));
+	return false;
+}
+//#endregion
+export { isEqualShallow as t };

package/dist/link.d.ts

@@ -0,0 +1,17 @@
+import { ComponentProps } from "react";
+//#region src/link.d.ts
+interface LinkProps extends ComponentProps<'a'> {
+  /**
+   * If the href is an external URL
+   *
+   * automatically determined by default
+   */
+  external?: boolean;
+  /**
+   * Prefetch links
+   */
+  prefetch?: boolean;
+}
+declare function Link({ ref, href, external, prefetch, children, ...props }: LinkProps): import("react").JSX.Element;
+//#endregion
+export { Link, Link as default, LinkProps };

package/dist/link.js

@@ -0,0 +1,23 @@
+"use client";
+import { Link as Link$1 } from "./framework/index.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/link.tsx
+function Link({ ref, href = "#", external = !!(href.match(/^\w+:/) || href.startsWith("//")), prefetch, children, ...props }) {
+	if (external) return /* @__PURE__ */ jsx("a", {
+		ref,
+		href,
+		rel: "noreferrer noopener",
+		target: "_blank",
+		...props,
+		children
+	});
+	return /* @__PURE__ */ jsx(Link$1, {
+		ref,
+		href,
+		prefetch,
+		...props,
+		children
+	});
+}
+//#endregion
+export { Link, Link as default };

package/dist/mdx-plugins/codeblock-utils.d.ts

@@ -0,0 +1,2 @@
+import { i as parseCodeBlockAttributes, n as CodeBlockTabsOptions, r as generateCodeBlockTabs, t as CodeBlockAttributes } from "../codeblock-utils-CyP8qsYv.js";
+export { CodeBlockAttributes, CodeBlockTabsOptions, generateCodeBlockTabs, parseCodeBlockAttributes };

package/dist/mdx-plugins/codeblock-utils.js

@@ -0,0 +1,68 @@
+//#region src/mdx-plugins/codeblock-utils.ts
+function generateCodeBlockTabs({ persist = false, defaultValue, triggers, tabs, ...options }) {
+	const attributes = [];
+	if (options.attributes) attributes.push(...options.attributes);
+	if (defaultValue) attributes.push({
+		type: "mdxJsxAttribute",
+		name: "defaultValue",
+		value: defaultValue
+	});
+	if (typeof persist === "object") attributes.push({
+		type: "mdxJsxAttribute",
+		name: "groupId",
+		value: persist.id
+	}, {
+		type: "mdxJsxAttribute",
+		name: "persist",
+		value: null
+	});
+	const children = [{
+		type: "mdxJsxFlowElement",
+		name: "CodeBlockTabsList",
+		attributes: [],
+		children: triggers.map((trigger) => ({
+			type: "mdxJsxFlowElement",
+			attributes: [{
+				type: "mdxJsxAttribute",
+				name: "value",
+				value: trigger.value
+			}],
+			name: "CodeBlockTabsTrigger",
+			children: trigger.children
+		}))
+	}];
+	for (const tab of tabs) children.push({
+		type: "mdxJsxFlowElement",
+		name: "CodeBlockTab",
+		attributes: [{
+			type: "mdxJsxAttribute",
+			name: "value",
+			value: tab.value
+		}],
+		children: tab.children
+	});
+	return {
+		type: "mdxJsxFlowElement",
+		name: "CodeBlockTabs",
+		attributes,
+		children
+	};
+}
+const AttributeRegex = /(?<=^|\s)(?<name>[a-zA-Z0-9_-]+)(?:=(?:"([^"]*)"|'([^']*)'|(\d+)))?/g;
+/**
+* Parse Fumadocs-style code block attributes from meta string, like `title="hello world"`
+*/
+function parseCodeBlockAttributes(meta, allowedNames) {
+	const attributes = {};
+	return {
+		rest: meta.replaceAll(AttributeRegex, (match, name, value_1, value_2, value_3) => {
+			if (allowedNames && !allowedNames.includes(name)) return match;
+			if (typeof value_3 === "string") attributes[name] = Number(value_3);
+			else attributes[name] = value_1 ?? value_2 ?? null;
+			return "";
+		}),
+		attributes
+	};
+}
+//#endregion
+export { generateCodeBlockTabs, parseCodeBlockAttributes };

package/dist/mdx-plugins/index.d.ts

@@ -0,0 +1,20 @@
+import { n as remarkGfm, t as RemarkGfmOptions } from "../remark-gfm-DpVfAX1x.js";
+import { i as transformerTab } from "../rehype-code.core-BjH1uHWj.js";
+import { r as transformerIcon, t as CodeBlockIcon } from "../transformer-icon-DlrneIS3.js";
+import { n as rehypeCode, r as rehypeCodeDefaultOptions, t as RehypeCodeOptions } from "../rehype-code-D-RFJb9W.js";
+import { n as remarkImage, t as RemarkImageOptions } from "../remark-image-BI2S9LOb.js";
+import { a as defaultStringifier, c as structure, i as StructuredData, n as StringifyOptions, o as remarkStructure, r as StructureOptions, s as remarkStructureDefaultOptions, t as Stringifier } from "../remark-structure-CnHwvNZr.js";
+import { n as remarkHeading, t as RemarkHeadingOptions } from "../remark-heading-DEIzTkU5.js";
+import { n as remarkAdmonition, t as RemarkAdmonitionOptions } from "../remark-admonition-BwTcmI_S.js";
+import { n as remarkDirectiveAdmonition, t as RemarkDirectiveAdmonitionOptions } from "../remark-directive-admonition-BLiJ5l43.js";
+import { n as RehypeTocOptions, r as rehypeToc, t as RehypeTOCItemType } from "../rehype-toc-K51AGb5U.js";
+import { n as remarkCodeTab, t as RemarkCodeTabOptions } from "../remark-code-tab-DE_4bdnu.js";
+import { n as remarkSteps, t as RemarkStepsOptions } from "../remark-steps-DqVEo0iq.js";
+import { n as remarkNpm, t as RemarkNpmOptions } from "../remark-npm-BbpvkJaT.js";
+import { i as parseCodeBlockAttributes, n as CodeBlockTabsOptions, r as generateCodeBlockTabs, t as CodeBlockAttributes } from "../codeblock-utils-CyP8qsYv.js";
+import { a as remarkMdxFiles, r as RemarkMdxFilesOptions } from "../remark-mdx-files-Buvxc-sa.js";
+import { n as remarkMdxMermaid, t as RemarkMdxMermaidOptions } from "../remark-mdx-mermaid-C1bCHHc6.js";
+import { n as RemarkFeedbackBlockOptions, r as remarkFeedbackBlock, t as FeedbackBlockProps } from "../remark-feedback-block-BxtINXN-.js";
+import { t as LLMsOptions } from "../remark-llms-bD3WvU2V.js";
+import "../index-DAYtLGbx.js";
+export { CodeBlockAttributes, type CodeBlockIcon, CodeBlockTabsOptions, FeedbackBlockProps, type LLMsOptions, RehypeCodeOptions, RehypeTOCItemType, RehypeTocOptions, RemarkAdmonitionOptions, RemarkCodeTabOptions, RemarkDirectiveAdmonitionOptions, RemarkFeedbackBlockOptions, type RemarkGfmOptions, RemarkHeadingOptions, RemarkImageOptions, type RemarkMdxFilesOptions, RemarkMdxMermaidOptions, RemarkNpmOptions, RemarkStepsOptions, Stringifier, StringifyOptions, StructureOptions, StructuredData, defaultStringifier, generateCodeBlockTabs, parseCodeBlockAttributes, rehypeCode, rehypeCodeDefaultOptions, rehypeToc, remarkAdmonition, remarkCodeTab, remarkDirectiveAdmonition, remarkFeedbackBlock, remarkGfm, remarkHeading, remarkImage, remarkMdxFiles, remarkMdxMermaid, remarkNpm, remarkSteps, remarkStructure, remarkStructureDefaultOptions, structure, transformerIcon, transformerTab };

package/dist/mdx-plugins/index.js

@@ -0,0 +1,18 @@
+import { remarkHeading } from "./remark-heading.js";
+import { generateCodeBlockTabs, parseCodeBlockAttributes } from "./codeblock-utils.js";
+import { remarkGfm } from "./remark-gfm.js";
+import { r as transformerTab } from "../rehype-code.core-BUwNuchP.js";
+import { transformerIcon } from "./transformer-icon.js";
+import { rehypeCode, rehypeCodeDefaultOptions } from "./rehype-code.js";
+import { remarkImage } from "./remark-image.js";
+import { defaultStringifier, remarkStructure, remarkStructureDefaultOptions, structure } from "./remark-structure.js";
+import { remarkAdmonition } from "./remark-admonition.js";
+import { remarkDirectiveAdmonition } from "./remark-directive-admonition.js";
+import { rehypeToc } from "./rehype-toc.js";
+import { remarkCodeTab } from "./remark-code-tab.js";
+import { remarkSteps } from "./remark-steps.js";
+import { remarkNpm } from "./remark-npm.js";
+import { remarkMdxFiles } from "./remark-mdx-files.js";
+import { remarkMdxMermaid } from "./remark-mdx-mermaid.js";
+import { remarkFeedbackBlock } from "./remark-feedback-block.js";
+export { defaultStringifier, generateCodeBlockTabs, parseCodeBlockAttributes, rehypeCode, rehypeCodeDefaultOptions, rehypeToc, remarkAdmonition, remarkCodeTab, remarkDirectiveAdmonition, remarkFeedbackBlock, remarkGfm, remarkHeading, remarkImage, remarkMdxFiles, remarkMdxMermaid, remarkNpm, remarkSteps, remarkStructure, remarkStructureDefaultOptions, structure, transformerIcon, transformerTab };

package/dist/mdx-plugins/rehype-code.core.d.ts

@@ -0,0 +1,3 @@
+import { i as transformerTab, n as createRehypeCode, r as rehypeCodeDefaultOptions, t as RehypeCodeOptionsCommon } from "../rehype-code.core-BjH1uHWj.js";
+import { r as transformerIcon, t as CodeBlockIcon } from "../transformer-icon-DlrneIS3.js";
+export { type CodeBlockIcon, RehypeCodeOptionsCommon, createRehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab };

package/dist/mdx-plugins/rehype-code.core.js

@@ -0,0 +1,3 @@
+import { n as rehypeCodeDefaultOptions, r as transformerTab, t as createRehypeCode } from "../rehype-code.core-BUwNuchP.js";
+import { transformerIcon } from "./transformer-icon.js";
+export { createRehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab };

package/dist/mdx-plugins/rehype-code.d.ts

@@ -0,0 +1,4 @@
+import { i as transformerTab } from "../rehype-code.core-BjH1uHWj.js";
+import { r as transformerIcon, t as CodeBlockIcon } from "../transformer-icon-DlrneIS3.js";
+import { n as rehypeCode, r as rehypeCodeDefaultOptions, t as RehypeCodeOptions } from "../rehype-code-D-RFJb9W.js";
+export { type CodeBlockIcon, RehypeCodeOptions, rehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab };

package/dist/mdx-plugins/rehype-code.js

@@ -0,0 +1,24 @@
+import { defaultShikiFactory, wasmShikiFactory } from "../highlight/shiki/full.js";
+import { n as rehypeCodeDefaultOptions$1, r as transformerTab, t as createRehypeCode } from "../rehype-code.core-BUwNuchP.js";
+import { transformerIcon } from "./transformer-icon.js";
+//#region src/mdx-plugins/rehype-code.ts
+const rehypeCodeDefaultOptions = {
+	engine: "js",
+	...rehypeCodeDefaultOptions$1()
+};
+const rehypeCode = createRehypeCode(async (_options) => {
+	const options = {
+		...rehypeCodeDefaultOptions,
+		..._options
+	};
+	const factory = options.engine === "oniguruma" ? wasmShikiFactory : defaultShikiFactory;
+	let highlighter;
+	if (options.langAlias) highlighter = await factory.init({ langAlias: options.langAlias });
+	else highlighter = await factory.getOrInit();
+	return {
+		highlighter,
+		options
+	};
+});
+//#endregion
+export { rehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab };

package/dist/mdx-plugins/rehype-toc.d.ts

@@ -0,0 +1,2 @@
+import { n as RehypeTocOptions, r as rehypeToc, t as RehypeTOCItemType } from "../rehype-toc-K51AGb5U.js";
+export { RehypeTOCItemType, RehypeTocOptions, rehypeToc };

package/dist/mdx-plugins/rehype-toc.js

@@ -0,0 +1,139 @@
+import { a as toMdxExportRaw, r as handleTag } from "../utils-Yx0IL9eW.js";
+import { visit } from "unist-util-visit";
+import { toEstree } from "hast-util-to-estree";
+//#region src/mdx-plugins/rehype-toc.ts
+const TocOnlyTag = "[toc]";
+const NoTocTag = "[!toc]";
+const HeadingTags = /* @__PURE__ */ new Set([
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+]);
+function rehypeToc({ exportToc = true } = {}) {
+	if (exportToc === true) exportToc = {
+		as: "esm",
+		name: "toc"
+	};
+	if (exportToc === false) return () => void 0;
+	return (tree, file) => {
+		const items = [];
+		visit(tree, "element", (element, idx, parent) => {
+			if (!HeadingTags.has(element.tagName) || element.children.length === 0) return;
+			const id = element.properties.id;
+			if (typeof id !== "string") return "skip";
+			let isTocOnly = false;
+			const last = element.children[element.children.length - 1];
+			if (last.type === "text") {
+				const noToc = handleTag(last.value, NoTocTag);
+				if (noToc !== false) {
+					last.value = noToc;
+					return "skip";
+				}
+				const tocOnly = handleTag(last.value, TocOnlyTag);
+				if (tocOnly !== false) {
+					isTocOnly = true;
+					last.value = tocOnly;
+				}
+			}
+			items.push({
+				title: element,
+				depth: Number(element.tagName[1]),
+				url: `#${id}`,
+				_step: typeof element.properties["data-fd-step"] === "number" ? element.properties["data-fd-step"] : void 0
+			});
+			if (isTocOnly && parent && typeof idx === "number") parent.children.splice(idx, 1);
+			return "skip";
+		});
+		if (exportToc.as === "esm") {
+			const esmItems = [];
+			for (const item of items) {
+				const root = toEstree(item.title, {
+					elementAttributeNameCase: "react",
+					stylePropertyNameCase: "dom"
+				}).body[0];
+				if (root.type === "ExpressionStatement" && root.expression.type === "JSXElement") esmItems.push({
+					...item,
+					title: root.expression
+				});
+			}
+			tree.children.push(toMdxExportRaw(exportToc.name, {
+				type: "ArrayExpression",
+				elements: esmItems.map((item) => {
+					const obj = {
+						type: "ObjectExpression",
+						properties: [
+							{
+								type: "Property",
+								method: false,
+								shorthand: false,
+								computed: false,
+								key: {
+									type: "Identifier",
+									name: "depth"
+								},
+								value: {
+									type: "Literal",
+									value: item.depth
+								},
+								kind: "init"
+							},
+							{
+								type: "Property",
+								method: false,
+								shorthand: false,
+								computed: false,
+								key: {
+									type: "Identifier",
+									name: "url"
+								},
+								value: {
+									type: "Literal",
+									value: item.url
+								},
+								kind: "init"
+							},
+							{
+								type: "Property",
+								method: false,
+								shorthand: false,
+								computed: false,
+								key: {
+									type: "Identifier",
+									name: "title"
+								},
+								value: {
+									type: "JSXFragment",
+									openingFragment: { type: "JSXOpeningFragment" },
+									closingFragment: { type: "JSXClosingFragment" },
+									children: item.title.children
+								},
+								kind: "init"
+							}
+						]
+					};
+					if (typeof item._step === "number") obj.properties.push({
+						type: "Property",
+						method: false,
+						shorthand: false,
+						computed: false,
+						key: {
+							type: "Identifier",
+							name: "_step"
+						},
+						value: {
+							type: "Literal",
+							value: item._step
+						},
+						kind: "init"
+					});
+					return obj;
+				})
+			}));
+		} else file.data.rehypeToc = items;
+	};
+}
+//#endregion
+export { rehypeToc };

package/dist/mdx-plugins/remark-admonition.d.ts

@@ -0,0 +1,2 @@
+import { n as remarkAdmonition, t as RemarkAdmonitionOptions } from "../remark-admonition-BwTcmI_S.js";
+export { RemarkAdmonitionOptions, remarkAdmonition };

package/dist/mdx-plugins/remark-admonition.js

@@ -0,0 +1,71 @@
+import { t as flattenNode } from "../utils-Yx0IL9eW.js";
+import { visit } from "unist-util-visit";
+//#region src/mdx-plugins/remark-admonition.ts
+/**
+* Remark Plugin to support Admonition syntax
+*
+* Useful when Migrating from Docusaurus
+*
+* @deprecated Use `remarkDirectiveAdmonition` with `remark-directive` configured instead.
+*/
+function remarkAdmonition(options = {}) {
+	const tag = options.tag ?? ":::";
+	const typeMap = options.typeMap ?? {
+		info: "info",
+		warn: "warn",
+		note: "info",
+		tip: "info",
+		warning: "warn",
+		danger: "error"
+	};
+	function replaceNodes(nodes) {
+		if (nodes.length === 0) return;
+		let open = -1;
+		let attributes = [];
+		let hasIntercept = false;
+		for (let i = 0; i < nodes.length; i++) {
+			if (nodes[i].type !== "paragraph") continue;
+			const text = flattenNode(nodes[i]);
+			const typeName = Object.keys(typeMap).find((type) => text.startsWith(`${tag}${type}`));
+			if (typeName) {
+				if (open !== -1) {
+					hasIntercept = true;
+					continue;
+				}
+				open = i;
+				attributes.push({
+					type: "mdxJsxAttribute",
+					name: "type",
+					value: typeMap[typeName]
+				});
+				const meta = text.slice(`${tag}${typeName}`.length);
+				if (meta.startsWith("[") && meta.endsWith("]")) attributes.push({
+					type: "mdxJsxAttribute",
+					name: "title",
+					value: meta.slice(1, -1)
+				});
+			}
+			if (open !== -1 && text === tag) {
+				const children = nodes.slice(open + 1, i);
+				nodes.splice(open, i - open + 1, {
+					type: "mdxJsxFlowElement",
+					name: "Callout",
+					attributes,
+					children: hasIntercept ? replaceNodes(children) : children
+				});
+				open = -1;
+				hasIntercept = false;
+				attributes = [];
+				i = open;
+			}
+		}
+	}
+	return (tree) => {
+		visit(tree, (node) => {
+			if (!("children" in node)) return;
+			replaceNodes(node.children);
+		});
+	};
+}
+//#endregion
+export { remarkAdmonition };

package/dist/mdx-plugins/remark-block-id.d.ts

@@ -0,0 +1,37 @@
+import { Transformer } from "unified";
+import { Root, RootContent } from "mdast";
+//#region src/mdx-plugins/remark-block-id.d.ts
+interface RemarkBlockIdOptions {
+  /**
+   * generate block ID.
+   */
+  generateId?: (ctx: {
+    node: RootContent;
+    text: string;
+  }) => string;
+  /**
+   * determine whether an ID should be generated for a given node.
+   *
+   * default: `true` for block nodes, otherwise `false`.
+   *
+   * @returns
+   * - `true`: generate an ID for the node.
+   * - `false`: skip the current node and look into its children.
+   * - `skip`: skip the current node and its children.
+   */
+  shouldGenerate?: (node: RootContent) => boolean | 'skip';
+  /**
+   * Add `data-block="<value>"` to updated nodes, pass `null` to disable.
+   *
+   * @default "default"
+   */
+  addDataAttribute?: string | null;
+}
+/**
+ * Generate ID for each block node in Markdown/MDX.
+ *
+ * Note: the uniqueness is only guaranteed per file.
+ */
+declare function remarkBlockId({ generateId, addDataAttribute, shouldGenerate }?: RemarkBlockIdOptions): Transformer<Root, Root>;
+//#endregion
+export { RemarkBlockIdOptions, remarkBlockId };

package/dist/mdx-plugins/remark-block-id.js

@@ -0,0 +1,41 @@
+import { t as flattenNode } from "../utils-Yx0IL9eW.js";
+import Slugger from "github-slugger";
+import { visit } from "unist-util-visit";
+import { createHash } from "node:crypto";
+//#region src/mdx-plugins/remark-block-id.ts
+/**
+* Generate ID for each block node in Markdown/MDX.
+*
+* Note: the uniqueness is only guaranteed per file.
+*/
+function remarkBlockId({ generateId, addDataAttribute = "default", shouldGenerate = (node) => {
+	switch (node.type) {
+		case "mdxJsxFlowElement": return "skip";
+		case "paragraph":
+		case "image":
+		case "listItem": return true;
+		default: return false;
+	}
+} } = {}) {
+	return (tree) => {
+		const slugger = new Slugger();
+		visit(tree, (node) => {
+			if (node.type === "root" || node.data?.hProperties?.id) return;
+			const resolved = shouldGenerate(node);
+			if (resolved === false) return;
+			if (resolved === "skip") return "skip";
+			const text = flattenNode(node).trim();
+			if (text.length === 0) return;
+			const id = generateId ? slugger.slug(generateId({
+				node,
+				text
+			})) : slugger.slug(createHash("sha256").update(text).digest("base64url"));
+			node.data ??= {};
+			node.data.hProperties ??= {};
+			node.data.hProperties.id = id;
+			if (addDataAttribute) node.data.hProperties["data-block"] = addDataAttribute;
+		});
+	};
+}
+//#endregion
+export { remarkBlockId };

package/dist/mdx-plugins/remark-code-tab.d.ts

@@ -0,0 +1,2 @@
+import { n as remarkCodeTab, t as RemarkCodeTabOptions } from "../remark-code-tab-DE_4bdnu.js";
+export { RemarkCodeTabOptions, remarkCodeTab };