mdast-pele 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 torben haack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,44 @@
-# Temporary Holding Version
+# mdast-pele
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Render Mermaid fences to static SVG with [Pele](https://pele.run) in remark and Sätteri pipelines.
+
+The browser needs no JavaScript. The generated SVG is themed with CSS variables.
+
+## Install
+
+```sh
+npm install mdast-pele
+```
+
+## Remark
+
+````js
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import { remarkPele } from 'mdast-pele/remark';
+import remarkRehype from 'remark-rehype';
+import rehypeStringify from 'rehype-stringify';
+
+const html = unified()
+	.use(remarkParse)
+	.use(remarkPele)
+	.use(remarkRehype, { allowDangerousHtml: true })
+	.use(rehypeStringify, { allowDangerousHtml: true })
+	.processSync('```mermaid\nflowchart LR\n A --> B\n```')
+	.toString();
+````
+
+## Sätteri
+
+```js
+import { markdownToHtml } from 'satteri';
+import { satteriPele } from 'mdast-pele/satteri';
+
+const { html } = markdownToHtml(source, { mdastPlugins: [satteriPele()] });
+```
+
+## Options
+
+`langs`, `errorMode`, `zoom`, `wrapper`, `className`, `caption` and all Pele `render()` options are supported. Add `zoom` to a fence to mark it for pan and zoom.
+
+Full docs: https://t128n.github.io/pele-x/

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { a as RenderOptions, i as PelePluginOptions, n as FenceContext, o as RenderResult, r as FenceMeta, t as ErrorMode } from "./types-BI4iEutF.js";
+export declare function renderDiagram(source: string, options?: RenderOptions): RenderResult;
+export declare function renderFenceToHtml(source: string, meta: FenceMeta, context: FenceContext, options?: PelePluginOptions): string;
+export declare function clearRenderCache(): void;
+export declare function diagramId(fileURL: string | undefined, index: number, source: string): string;
+export declare function parseFenceMeta(meta: string | null | undefined): FenceMeta;
+export declare function isPeleLang(lang: string | null | undefined, options?: PelePluginOptions): boolean;
+export type { ErrorMode, FenceContext, FenceMeta, PelePluginOptions, RenderOptions, RenderResult };

package/dist/index.js

@@ -0,0 +1 @@
+export { r as clearRenderCache, o as diagramId, t as isPeleLang, n as parseFenceMeta, i as renderDiagram, a as renderFenceToHtml } from "./meta-C5f6wlQq.js";

package/dist/meta-C5f6wlQq.js

@@ -0,0 +1,141 @@
+import { PeleError, render } from "pele";
+// src/errors.ts
+function escapeHtml(value) {
+	return value.replace(/[&<>"']/g, (character) => {
+		switch (character) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			case "\"": return "&quot;";
+			default: return "&#39;";
+		}
+	});
+}
+function formatError(error, context) {
+	const message = error instanceof Error ? error.message : String(error);
+	const errorLine = error instanceof PeleError && error.line > 0 ? error.line : void 0;
+	const line = context.line !== void 0 && errorLine !== void 0 ? context.line + errorLine - 1 : context.line ?? errorLine;
+	const location = context.fileURL ? `${context.fileURL}${line === void 0 ? "" : `:${line}`}` : line === void 0 ? "" : `line ${line}`;
+	return location ? `${location}: ${message}` : message;
+}
+function contextualError(error, context) {
+	const message = formatError(error, context);
+	if (error instanceof PeleError) return new PeleError(message, error.code, {
+		type: error.type,
+		mermaidType: error.mermaidType,
+		line: error.line,
+		column: error.column,
+		snippet: error.snippet
+	});
+	return new Error(message, { cause: error });
+}
+// src/id.ts
+function hash(value) {
+	let result = 2166136261;
+	for (let index = 0; index < value.length; index++) {
+		result ^= value.charCodeAt(index);
+		result = Math.imul(result, 16777619);
+	}
+	return (result >>> 0).toString(36).padStart(7, "0");
+}
+function diagramId(fileURL, index, source) {
+	return `pele-${hash(`${fileURL ?? ""}\0${source}`)}-${index.toString(36)}`;
+}
+// src/core.ts
+const cacheLimit = 100;
+const cache = /* @__PURE__ */ new Map();
+const functionIds = /* @__PURE__ */ new WeakMap();
+let nextFunctionId = 0;
+function functionId(value) {
+	let id = functionIds.get(value);
+	if (id === void 0) {
+		id = ++nextFunctionId;
+		functionIds.set(value, id);
+	}
+	return id;
+}
+function cacheKey(source, meta, idPrefix, marked, options) {
+	try {
+		return JSON.stringify([
+			source,
+			meta.title,
+			idPrefix,
+			marked,
+			options
+		], (_key, value) => {
+			if (typeof value === "function") return `function:${functionId(value)}`;
+			if (typeof value === "bigint") return `bigint:${value.toString()}`;
+			return value;
+		});
+	} catch {
+		return null;
+	}
+}
+function cached(key) {
+	const value = cache.get(key);
+	if (value !== void 0) {
+		cache.delete(key);
+		cache.set(key, value);
+	}
+	return value;
+}
+function store(key, value) {
+	cache.set(key, value);
+	if (cache.size > cacheLimit) {
+		const oldest = cache.keys().next().value;
+		if (oldest !== void 0) cache.delete(oldest);
+	}
+}
+function renderDiagram(source, options) {
+	return render(source, options);
+}
+function renderFenceToHtml(source, meta, context, options) {
+	const errorMode = options?.errorMode ?? "throw";
+	const marked = options?.zoom === true || options?.zoom === "marked" && meta.zoom;
+	const idPrefix = diagramId(context.fileURL, context.index, source);
+	const renderOptions = {
+		...options,
+		idPrefix
+	};
+	delete renderOptions.languages;
+	delete renderOptions.errorMode;
+	delete renderOptions.zoom;
+	const key = cacheKey(source, meta, idPrefix, marked, renderOptions);
+	if (key !== null) {
+		const hit = cached(key);
+		if (hit !== void 0) return hit;
+	}
+	try {
+		const { svg } = renderDiagram(source, renderOptions);
+		const caption = meta.title === void 0 ? "" : `<figcaption>${escapeHtml(meta.title)}</figcaption>`;
+		const html = `<figure class="pele-diagram"${marked ? " data-pele-zoom" : ""}>${svg}${caption}</figure>`;
+		if (key !== null) store(key, html);
+		return html;
+	} catch (error) {
+		const message = formatError(error, context);
+		if (errorMode === "warn") context.report?.(message);
+		if (errorMode === "throw") throw contextualError(error, context);
+		return `<pre class="pele-error" role="alert">${escapeHtml(message)}</pre>`;
+	}
+}
+function clearRenderCache() {
+	cache.clear();
+}
+// src/meta.ts
+const titlePattern = /(?:^|\s)title\s*=\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)')/;
+const quotedPattern = /"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g;
+const zoomPattern = /(?:^|\s)zoom(?=\s|$)/;
+const defaultLanguages = ["mermaid", "pele"];
+function parseFenceMeta(meta) {
+	if (!meta) return { zoom: false };
+	const titleMatch = titlePattern.exec(meta);
+	const title = titleMatch?.[1] ?? titleMatch?.[2];
+	const unquoted = meta.replace(quotedPattern, "");
+	const result = { zoom: zoomPattern.test(unquoted) };
+	if (title !== void 0) result.title = title.replace(/\\(["'\\])/g, "$1");
+	return result;
+}
+function isPeleLang(lang, options) {
+	return lang != null && (options?.languages ?? defaultLanguages).includes(lang);
+}
+export { renderFenceToHtml as a, renderDiagram as i, parseFenceMeta as n, diagramId as o, clearRenderCache as r, isPeleLang as t };

package/dist/remark.d.ts

@@ -0,0 +1,7 @@
+import { i as PelePluginOptions } from "./types-BI4iEutF.js";
+import { Root } from "mdast";
+export type RemarkTransformer = (tree: Root, file?: {
+  path?: string;
+  history?: string[];
+}) => void;
+export declare function remarkPele(options?: PelePluginOptions): RemarkTransformer;

package/dist/remark.js

@@ -0,0 +1,22 @@
+import { a as renderFenceToHtml, n as parseFenceMeta, t as isPeleLang } from "./meta-C5f6wlQq.js";
+import { visit } from "unist-util-visit";
+// src/remark.ts
+function remarkPele(options) {
+	return (tree, file) => {
+		const fileURL = file?.path ?? file?.history?.[0];
+		visit(tree, "code", (node, index, parent) => {
+			if (index == null || !parent || !isPeleLang(node.lang, options)) return;
+			const value = renderFenceToHtml(node.value, parseFenceMeta(node.meta), {
+				index,
+				fileURL,
+				line: node.position?.start.line
+			}, options);
+			parent.children[index] = {
+				type: "html",
+				value,
+				position: node.position
+			};
+		});
+	};
+}
+export { remarkPele };