@vezham/docs-core 1.0.1

package/dist/mdx-plugins/remark-code-tab.js

@@ -0,0 +1,190 @@
+import { generateCodeBlockTabs, parseCodeBlockAttributes } from "./codeblock-utils.js";
+import { visit } from "unist-util-visit";
+//#region src/mdx-plugins/remark-code-tab.ts
+const Types = {
+	CodeBlockTabs(processor, nodes, withMdx, withParent) {
+		const tabs = processTabValue(nodes);
+		let isFirstTab = true;
+		const options = {
+			triggers: [],
+			tabs: []
+		};
+		for (const [value, list] of tabs) {
+			if (isFirstTab) {
+				const tagGroup = list[0].data?.tabGroup;
+				options.defaultValue = value;
+				if (tagGroup) options.persist = { id: tagGroup };
+				isFirstTab = false;
+			}
+			options.triggers.push({
+				value,
+				children: withMdx ? mdxToAst(processor, value).children : [{
+					type: "text",
+					value
+				}]
+			});
+			options.tabs.push({
+				value,
+				children: list
+			});
+		}
+		const node = generateCodeBlockTabs(options);
+		if (!withParent) return node.children;
+		return [node];
+	},
+	Tabs(processor, nodes, withMdx, withParent) {
+		const tabs = Array.from(processTabValue(nodes).entries());
+		if (!withMdx) {
+			const children = tabs.map(([name, codes]) => {
+				return {
+					type: "mdxJsxFlowElement",
+					name: "Tab",
+					attributes: [{
+						type: "mdxJsxAttribute",
+						name: "value",
+						value: name
+					}],
+					children: codes
+				};
+			});
+			if (!withParent) return children;
+			return [{
+				type: "mdxJsxFlowElement",
+				name: "Tabs",
+				attributes: [{
+					type: "mdxJsxAttribute",
+					name: "items",
+					value: {
+						type: "mdxJsxAttributeValueExpression",
+						value: tabs.map(([name]) => name).join(", "),
+						data: { estree: {
+							type: "Program",
+							sourceType: "module",
+							comments: [],
+							body: [{
+								type: "ExpressionStatement",
+								expression: {
+									type: "ArrayExpression",
+									elements: tabs.map(([name]) => ({
+										type: "Literal",
+										value: name
+									}))
+								}
+							}]
+						} }
+					}
+				}],
+				children
+			}];
+		}
+		const children = [{
+			type: "mdxJsxFlowElement",
+			name: "TabsList",
+			attributes: [],
+			children: tabs.map(([name]) => ({
+				type: "mdxJsxFlowElement",
+				name: "TabsTrigger",
+				attributes: [{
+					type: "mdxJsxAttribute",
+					name: "value",
+					value: name
+				}],
+				children: [mdxToAst(processor, name)]
+			}))
+		}, ...tabs.map(([name, codes]) => ({
+			type: "mdxJsxFlowElement",
+			name: "TabsContent",
+			attributes: [{
+				type: "mdxJsxAttribute",
+				name: "value",
+				value: name
+			}],
+			children: codes
+		}))];
+		if (!withParent) return children;
+		return [{
+			type: "mdxJsxFlowElement",
+			name: "Tabs",
+			attributes: [{
+				type: "mdxJsxAttribute",
+				name: "defaultValue",
+				value: tabs[0][0]
+			}],
+			children
+		}];
+	}
+};
+function remarkCodeTab(options = {}) {
+	const { parseMdx = false, Tabs = "CodeBlockTabs" } = options;
+	return (tree) => {
+		visit(tree, (node) => {
+			if (!("children" in node) || node.data?._code_tab_visited) return "skip";
+			let localTabs = Tabs;
+			let localParseMdx = parseMdx;
+			let withParent = true;
+			if (node.type === "mdxJsxFlowElement" && node.name && node.name in Types) {
+				withParent = false;
+				localTabs = node.name;
+				if (node.name === "Tabs" && localParseMdx) localParseMdx = node.attributes.every((attribute) => attribute.type !== "mdxJsxAttribute" || attribute.name !== "items");
+			}
+			let start = -1;
+			let end = 0;
+			const close = () => {
+				if (start === -1 || start === end) return;
+				const replacement = Types[localTabs](this, node.children.slice(start, end), localParseMdx, withParent);
+				for (const element of replacement) {
+					element.data ??= {};
+					element.data._code_tab_visited = true;
+				}
+				node.children.splice(start, end - start, ...replacement);
+				end = start;
+				start = -1;
+			};
+			for (; end < node.children.length; end++) {
+				const child = node.children[end];
+				if (child.type !== "code" || !child.meta) {
+					close();
+					continue;
+				}
+				const meta = parseCodeBlockAttributes(child.meta, ["tab", "tab-group"]);
+				if (typeof meta.attributes.tab !== "string") {
+					close();
+					continue;
+				}
+				if (start === -1) start = end;
+				child.meta = meta.rest;
+				child.data ??= {};
+				child.data.tab = meta.attributes.tab;
+				if (typeof meta.attributes["tab-group"] === "string") child.data.tabGroup = meta.attributes["tab-group"];
+			}
+			close();
+		});
+	};
+}
+function processTabValue(nodes) {
+	const out = /* @__PURE__ */ new Map();
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		const name = node.data?.tab ?? `Tab ${i + 1}`;
+		let li = out.get(name);
+		if (!li) {
+			li = [];
+			out.set(name, li);
+		}
+		li.push(node);
+	}
+	return out;
+}
+/**
+* MDX tab name to tab trigger node children
+*/
+function mdxToAst(processor, name) {
+	const node = processor.parse(name);
+	node.children = node.children.flatMap((child) => {
+		if (child.type === "paragraph") return child.children;
+		return child;
+	});
+	return node;
+}
+//#endregion
+export { remarkCodeTab };

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

@@ -0,0 +1,2 @@
+import { n as remarkDirectiveAdmonition, t as RemarkDirectiveAdmonitionOptions } from "../remark-directive-admonition-BLiJ5l43.js";
+export { RemarkDirectiveAdmonitionOptions, remarkDirectiveAdmonition };

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

@@ -0,0 +1,57 @@
+import { visit } from "unist-util-visit";
+//#region src/mdx-plugins/remark-directive-admonition.ts
+/**
+* Remark Plugin to support Admonition syntax in Docusaurus, useful for migrating from Docusaurus.
+*
+* Requires [`remark-directive`](https://github.com/remarkjs/remark-directive) to be configured.
+*/
+function remarkDirectiveAdmonition({ tags: { CalloutContainer = "CalloutContainer", CalloutTitle = "CalloutTitle", CalloutDescription = "CalloutDescription" } = {}, types = {
+	note: "info",
+	tip: "info",
+	info: "info",
+	warn: "warning",
+	warning: "warning",
+	danger: "error",
+	success: "success"
+} } = {}) {
+	return (tree) => {
+		visit(tree, "containerDirective", (node) => {
+			if (!(node.name in types)) return;
+			const attributes = [{
+				type: "mdxJsxAttribute",
+				name: "type",
+				value: types[node.name]
+			}];
+			for (const [k, v] of Object.entries(node.attributes ?? {})) attributes.push({
+				type: "mdxJsxAttribute",
+				name: k,
+				value: v
+			});
+			const titleNodes = [];
+			const descriptionNodes = [];
+			for (const item of node.children) if (item.type === "paragraph" && item.data?.directiveLabel) titleNodes.push(...item.children);
+			else descriptionNodes.push(item);
+			const children = [];
+			if (titleNodes.length > 0) children.push({
+				type: "mdxJsxFlowElement",
+				name: CalloutTitle,
+				attributes: [],
+				children: titleNodes
+			});
+			if (descriptionNodes.length > 0) children.push({
+				type: "mdxJsxFlowElement",
+				name: CalloutDescription,
+				attributes: [],
+				children: descriptionNodes
+			});
+			Object.assign(node, {
+				type: "mdxJsxFlowElement",
+				attributes,
+				name: CalloutContainer,
+				children
+			});
+		});
+	};
+}
+//#endregion
+export { remarkDirectiveAdmonition };

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

@@ -0,0 +1,2 @@
+import { n as RemarkFeedbackBlockOptions, r as remarkFeedbackBlock, t as FeedbackBlockProps } from "../remark-feedback-block-BxtINXN-.js";
+export { FeedbackBlockProps, RemarkFeedbackBlockOptions, remarkFeedbackBlock };

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

@@ -0,0 +1,54 @@
+import { t as flattenNode } from "../utils-Yx0IL9eW.js";
+import { visit } from "unist-util-visit";
+import { createHash } from "node:crypto";
+//#region src/mdx-plugins/remark-feedback-block.ts
+/**
+* Generate MDX `<FeedbackBlock />` elements with an unique `id` for every block-like element.
+*
+* Note: the uniqueness is only guaranteed per MDX file/page.
+*/
+function remarkFeedbackBlock({ generateHash = ({ body }) => createHash("md5").update(body).digest("hex").substring(0, 16), tagName = "FeedbackBlock", resolve = (node) => {
+	switch (node.type) {
+		case "mdxJsxFlowElement": return "skip";
+		case "paragraph":
+		case "image":
+		case "listItem": return true;
+		default: return false;
+	}
+}, generateBody = true } = {}) {
+	return (tree) => {
+		const counts = /* @__PURE__ */ new Map();
+		visit(tree, (node, index, parent) => {
+			if (node.type === "root" || !parent || typeof index !== "number") return;
+			const resolved = resolve(node);
+			if (resolved === false) return;
+			if (resolved === "skip") return "skip";
+			const text = flattenNode(node).trim();
+			if (text.length === 0) return;
+			let id = generateHash({ body: text });
+			const count = counts.get(id) ?? 0;
+			if (count > 0) id = `${id}-${count}`;
+			counts.set(id, count + 1);
+			const wrapper = {
+				type: "mdxJsxFlowElement",
+				name: tagName,
+				attributes: [{
+					type: "mdxJsxAttribute",
+					name: "id",
+					value: id
+				}],
+				data: { _stringify: "children-only" },
+				children: [node]
+			};
+			if (generateBody) wrapper.attributes.push({
+				type: "mdxJsxAttribute",
+				name: "body",
+				value: text
+			});
+			parent.children[index] = wrapper;
+			return "skip";
+		});
+	};
+}
+//#endregion
+export { remarkFeedbackBlock };

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

@@ -0,0 +1,2 @@
+import { n as remarkGfm, t as RemarkGfmOptions } from "../remark-gfm-DpVfAX1x.js";
+export { type RemarkGfmOptions, remarkGfm };

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

@@ -0,0 +1,2 @@
+import remarkGfm from "remark-gfm";
+export { remarkGfm };

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

@@ -0,0 +1,2 @@
+import { n as remarkHeading, t as RemarkHeadingOptions } from "../remark-heading-DEIzTkU5.js";
+export { RemarkHeadingOptions, remarkHeading };

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

@@ -0,0 +1,46 @@
+import { t as flattenNode } from "../utils-Yx0IL9eW.js";
+import Slugger from "github-slugger";
+import { visit } from "unist-util-visit";
+//#region src/mdx-plugins/remark-heading.ts
+const regex = /\s*\[#(?<slug>[^]+?)]\s*$/;
+/**
+* Add heading ids and extract TOC
+*/
+function remarkHeading({ slug, customId = true, generateToc = true } = {}) {
+	let slugger;
+	if (!slug) {
+		slugger = new Slugger();
+		slug = (_root, _heading, text) => slugger.slug(text);
+	}
+	return (root, file) => {
+		const toc = [];
+		slugger?.reset();
+		visit(root, "heading", (heading) => {
+			heading.data ||= {};
+			heading.data.hProperties ||= {};
+			const props = heading.data.hProperties;
+			const lastNode = heading.children.at(-1);
+			if (lastNode?.type === "text" && customId) {
+				const match = regex.exec(lastNode.value);
+				if (match?.[1]) {
+					props.id = match[1];
+					lastNode.value = lastNode.value.slice(0, match.index);
+				}
+			}
+			let flattened = null;
+			if (!props.id) {
+				flattened ??= flattenNode(heading);
+				props.id = slug(root, heading, flattened);
+			}
+			if (generateToc) toc.push({
+				title: flattened ?? flattenNode(heading),
+				url: `#${props.id}`,
+				depth: heading.depth
+			});
+			return "skip";
+		});
+		if (generateToc) file.data.toc = toc;
+	};
+}
+//#endregion
+export { remarkHeading };

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

@@ -0,0 +1,2 @@
+import { n as remarkImage, t as RemarkImageOptions } from "../remark-image-BI2S9LOb.js";
+export { RemarkImageOptions, remarkImage };

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

@@ -0,0 +1,167 @@
+import { visit } from "unist-util-visit";
+import * as path$1 from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/mdx-plugins/remark-image.ts
+const VALID_BLUR_EXT = [
+	".jpeg",
+	".png",
+	".webp",
+	".avif",
+	".jpg"
+];
+const EXTERNAL_URL_REGEX = /^https?:\/\//;
+/**
+* Turn images into Next.js Image compatible usage.
+*/
+function remarkImage({ placeholder = "none", external = true, useImport = true, onError = "error", publicDir = path$1.join(process.cwd(), "public") } = {}) {
+	return async (tree, file) => {
+		const importsToInject = [];
+		const promises = [];
+		async function updateImage(src, node) {
+			if (src.type === "file" && useImport) {
+				const variableName = `__img${importsToInject.length}`;
+				const hasBlur = placeholder === "blur" && VALID_BLUR_EXT.some((ext) => src.file.endsWith(ext));
+				if (!file.dirname) throw new Error("When `useImport` is enabled, you must specify `dirname` in the VFile passed to compiler.");
+				importsToInject.push({
+					variableName,
+					importPath: getImportPath(src.file, file.dirname)
+				});
+				const out = {
+					children: [],
+					type: "mdxJsxFlowElement",
+					name: "img",
+					attributes: [{
+						type: "mdxJsxAttribute",
+						name: "alt",
+						value: node.alt ?? "image"
+					}, {
+						type: "mdxJsxAttribute",
+						name: "src",
+						value: {
+							type: "mdxJsxAttributeValueExpression",
+							value: variableName,
+							data: { estree: {
+								body: [{
+									type: "ExpressionStatement",
+									expression: {
+										type: "Identifier",
+										name: variableName
+									}
+								}],
+								type: "Program",
+								sourceType: "script"
+							} }
+						}
+					}]
+				};
+				if (node.title) out.attributes.push({
+					type: "mdxJsxAttribute",
+					name: "title",
+					value: node.title
+				});
+				if (hasBlur) out.attributes.push({
+					type: "mdxJsxAttribute",
+					name: "placeholder",
+					value: "blur"
+				});
+				return out;
+			}
+			const size = await getImageSize(src, external).catch((e) => {
+				throw new Error(`[Remark Image] Failed obtain image size for ${node.url} (public directory configured as ${publicDir})`, { cause: e });
+			});
+			if (!size) return;
+			node.data ??= {};
+			node.data.hProperties ??= {};
+			node.data.hProperties.src = src.type === "url" ? src.url.href : node.url;
+			node.data.hProperties.width = size.width.toString();
+			node.data.hProperties.height = size.height.toString();
+		}
+		visit(tree, "image", (node, idx, parent) => {
+			if (typeof idx !== "number" || !parent) return;
+			const src = parseSrc(decodeURI(node.url), publicDir, file.dirname);
+			if (!src) return;
+			const task = updateImage(src, node).catch((e) => {
+				if (onError === "ignore" || node.url.endsWith(".svg")) return;
+				if (onError === "hide") {
+					parent.children.splice(idx, 1);
+					return;
+				}
+				if (onError === "error") throw e;
+				onError(e);
+			}).then((res) => {
+				if (res) parent.children[idx] = res;
+			});
+			promises.push(task);
+		});
+		await Promise.all(promises);
+		if (importsToInject.length === 0) return;
+		const imports = importsToInject.map(({ variableName, importPath }) => ({
+			type: "mdxjsEsm",
+			data: { estree: { body: [{
+				type: "ImportDeclaration",
+				source: {
+					type: "Literal",
+					value: importPath
+				},
+				specifiers: [{
+					type: "ImportDefaultSpecifier",
+					local: {
+						type: "Identifier",
+						name: variableName
+					}
+				}]
+			}] } }
+		}));
+		tree.children.unshift(...imports);
+	};
+}
+function getImportPath(file, dir) {
+	const relative = path$1.relative(dir, file).replaceAll(path$1.sep, "/");
+	return relative.startsWith("../") ? relative : `./${relative}`;
+}
+/**
+* @param src - src href
+* @param publicDir - dir/url to resolve absolute paths
+* @param dir - dir to resolve relative paths
+*/
+function parseSrc(src, publicDir, dir) {
+	if (src.startsWith("file:///")) return {
+		type: "file",
+		file: fileURLToPath(src)
+	};
+	if (EXTERNAL_URL_REGEX.test(src)) return {
+		type: "url",
+		url: new URL(src)
+	};
+	if (src.startsWith("/")) {
+		if (EXTERNAL_URL_REGEX.test(publicDir)) {
+			const url = new URL(publicDir);
+			url.pathname = `/${[...url.pathname.split("/"), ...src.split("/")].filter((v) => v.length > 0).join("/")}`;
+			return {
+				type: "url",
+				url
+			};
+		}
+		return {
+			type: "file",
+			file: path$1.join(publicDir, src)
+		};
+	}
+	if (!dir) {
+		console.warn(`[Remark Image] found relative path ${src} but missing 'dirname' in VFile, this image will be skipped for now.`);
+		return;
+	}
+	return {
+		type: "file",
+		file: path$1.join(dir, src)
+	};
+}
+async function getImageSize(src, onExternal) {
+	const { probe } = await import("@fumari/image-size");
+	if (src.type === "file") return probe(src.file);
+	if (onExternal === false) return;
+	const { timeout } = typeof onExternal === "object" ? onExternal : {};
+	return probe(src.url, { timeout });
+}
+//#endregion
+export { remarkImage };

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

@@ -0,0 +1,2 @@
+import { n as placeholder, r as remarkLLMs, t as LLMsOptions } from "../remark-llms-bD3WvU2V.js";
+export { LLMsOptions, placeholder, remarkLLMs };