@livemark/markdown 0.0.0-stage → 0.45.0

package/build/models/message.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+export const Messages = z.strictObject({
+    "nav.docs": z.string().default("Docs"),
+    "nav.more": z.string().default("More"),
+    "nav.navigation": z.string().default("Navigation"),
+    "nav.chooseSection": z.string().default("Choose section"),
+    "nav.section": z.string().default("Section"),
+    "nav.toggleSubmenu": z.string().default("Toggle {title} submenu"),
+    "nav.previous": z.string().default("Previous"),
+    "nav.next": z.string().default("Next"),
+    "nav.backToTop": z.string().default("Back to top"),
+    "nav.close": z.string().default("Close"),
+    "nav.sections": z.string().default("Sections"),
+    "nav.articles": z.string().default("Articles"),
+    "nav.links": z.string().default("Links"),
+    "nav.releases": z.string().default("Releases"),
+    "nav.posts": z.string().default("Posts"),
+    "nav.tags": z.string().default("Tags"),
+    "nav.breadcrumbs": z.string().default("Breadcrumbs"),
+    "language.choose": z.string().default("Choose language"),
+    "language.untranslated": z.string().default("Not translated yet"),
+    "theme.change": z.string().default("Change theme"),
+    "theme.light": z.string().default("Light"),
+    "theme.dark": z.string().default("Dark"),
+    "theme.system": z.string().default("System"),
+    "shortcuts.title": z.string().default("Keyboard shortcuts"),
+    "shortcuts.search": z.string().default("Search"),
+    "shortcuts.theme": z.string().default("Toggle theme"),
+    "shortcuts.sidebar": z.string().default("Toggle sidebar"),
+    "shortcuts.scrollDown": z.string().default("Scroll down"),
+    "shortcuts.scrollUp": z.string().default("Scroll up"),
+    "shortcuts.top": z.string().default("Back to top"),
+    "shortcuts.bottom": z.string().default("Go to bottom"),
+    "shortcuts.next": z.string().default("Next page"),
+    "shortcuts.previous": z.string().default("Previous page"),
+    "search.label": z.string().default("Search"),
+    "search.description": z.string().default("Search documentation"),
+    "search.placeholder": z.string().default("Search docs..."),
+    "search.empty": z.string().default("No results found."),
+    "search.hint": z.string().default("Type to search across all contents."),
+    "search.close": z.string().default("Close search"),
+    "search.pages": z.string().default("Pages"),
+    "search.button": z.string().default("Search..."),
+    "search.navigate": z.string().default("navigate"),
+    "search.select": z.string().default("select"),
+    "search.dismiss": z.string().default("close"),
+    "toc.title": z.string().default("On this page"),
+    "toc.contents": z.string().default("Contents"),
+    "toc.actions": z.string().default("Actions"),
+    "toc.inline": z.string().default("Table of Contents"),
+    "page.updated": z.string().default("Updated {date}"),
+    "page.published": z.string().default("Published {date}"),
+    "page.edit": z.string().default("Edit on GitHub"),
+    "page.view": z.string().default("View on GitHub"),
+    "page.copyMarkdown": z.string().default("Copy Markdown"),
+    "page.openChatGpt": z.string().default("Open in ChatGPT"),
+    "page.openClaude": z.string().default("Open in Claude"),
+    "page.llmPrompt": z.string().default("Read {url}, I want to ask questions about it."),
+    "code.copy": z.string().default("Copy code"),
+    "code.copied": z.string().default("Copied!"),
+    "code.wrapOn": z.string().default("Enable wrap"),
+    "code.wrapOff": z.string().default("Disable wrap"),
+    "code.expand": z.string().default("Expand"),
+    "callout.note": z.string().default("Note"),
+    "callout.info": z.string().default("Info"),
+    "callout.tip": z.string().default("Tip"),
+    "callout.warning": z.string().default("Warning"),
+    "callout.danger": z.string().default("Danger"),
+    "blog.title": z.string().default("Blog"),
+    "blog.allPosts": z.string().default("All Posts"),
+    "blog.recentPosts": z.string().default("Recent Posts"),
+    "blog.rssFeed": z.string().default("RSS Feed"),
+    "blog.tagged": z.string().default("Posts tagged '{tag}'"),
+    "changelog.title": z.string().default("Changelog"),
+    "changelog.allReleases": z.string().default("All Releases"),
+    "changelog.recentReleases": z.string().default("Recent Releases"),
+    "error.notFound": z.string().default("The page you're looking for doesn't exist."),
+    "error.goBack": z.string().default("Go Back"),
+    "error.tryAgain": z.string().default("Try Again"),
+    "error.home": z.string().default("Home"),
+    "media.loadingDiagram": z.string().default("Loading diagram…"),
+    "media.youtube": z.string().default("YouTube video"),
+    "media.soundcloud": z.string().default("SoundCloud audio"),
+    "footnote.missing": z.string().default("Footnote not found"),
+    "footer.createdWith": z.string().default("Created with {heart} and {livemark}"),
+});
+export const MessageOverrides = z.partialRecord(Messages.keyof(), z.string());
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message.js","sourceRoot":"","sources":["../../source/models/message.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from \"zod\"\n\n/** UI strings; each default is the English text, so `Messages.parse({})` is English. */\nexport type Messages = z.infer<typeof Messages>\nexport const Messages = z.strictObject({\n  \"nav.docs\": z.string().default(\"Docs\"),\n  \"nav.more\": z.string().default(\"More\"),\n  \"nav.navigation\": z.string().default(\"Navigation\"),\n  \"nav.chooseSection\": z.string().default(\"Choose section\"),\n  \"nav.section\": z.string().default(\"Section\"),\n  \"nav.toggleSubmenu\": z.string().default(\"Toggle {title} submenu\"),\n  \"nav.previous\": z.string().default(\"Previous\"),\n  \"nav.next\": z.string().default(\"Next\"),\n  \"nav.backToTop\": z.string().default(\"Back to top\"),\n  \"nav.close\": z.string().default(\"Close\"),\n  \"nav.sections\": z.string().default(\"Sections\"),\n  \"nav.articles\": z.string().default(\"Articles\"),\n  \"nav.links\": z.string().default(\"Links\"),\n  \"nav.releases\": z.string().default(\"Releases\"),\n  \"nav.posts\": z.string().default(\"Posts\"),\n  \"nav.tags\": z.string().default(\"Tags\"),\n  \"nav.breadcrumbs\": z.string().default(\"Breadcrumbs\"),\n  \"language.choose\": z.string().default(\"Choose language\"),\n  \"language.untranslated\": z.string().default(\"Not translated yet\"),\n  \"theme.change\": z.string().default(\"Change theme\"),\n  \"theme.light\": z.string().default(\"Light\"),\n  \"theme.dark\": z.string().default(\"Dark\"),\n  \"theme.system\": z.string().default(\"System\"),\n  \"shortcuts.title\": z.string().default(\"Keyboard shortcuts\"),\n  \"shortcuts.search\": z.string().default(\"Search\"),\n  \"shortcuts.theme\": z.string().default(\"Toggle theme\"),\n  \"shortcuts.sidebar\": z.string().default(\"Toggle sidebar\"),\n  \"shortcuts.scrollDown\": z.string().default(\"Scroll down\"),\n  \"shortcuts.scrollUp\": z.string().default(\"Scroll up\"),\n  \"shortcuts.top\": z.string().default(\"Back to top\"),\n  \"shortcuts.bottom\": z.string().default(\"Go to bottom\"),\n  \"shortcuts.next\": z.string().default(\"Next page\"),\n  \"shortcuts.previous\": z.string().default(\"Previous page\"),\n  \"search.label\": z.string().default(\"Search\"),\n  \"search.description\": z.string().default(\"Search documentation\"),\n  \"search.placeholder\": z.string().default(\"Search docs...\"),\n  \"search.empty\": z.string().default(\"No results found.\"),\n  \"search.hint\": z.string().default(\"Type to search across all contents.\"),\n  \"search.close\": z.string().default(\"Close search\"),\n  \"search.pages\": z.string().default(\"Pages\"),\n  \"search.button\": z.string().default(\"Search...\"),\n  \"search.navigate\": z.string().default(\"navigate\"),\n  \"search.select\": z.string().default(\"select\"),\n  \"search.dismiss\": z.string().default(\"close\"),\n  \"toc.title\": z.string().default(\"On this page\"),\n  \"toc.contents\": z.string().default(\"Contents\"),\n  \"toc.actions\": z.string().default(\"Actions\"),\n  \"toc.inline\": z.string().default(\"Table of Contents\"),\n  \"page.updated\": z.string().default(\"Updated {date}\"),\n  \"page.published\": z.string().default(\"Published {date}\"),\n  \"page.edit\": z.string().default(\"Edit on GitHub\"),\n  \"page.view\": z.string().default(\"View on GitHub\"),\n  \"page.copyMarkdown\": z.string().default(\"Copy Markdown\"),\n  \"page.openChatGpt\": z.string().default(\"Open in ChatGPT\"),\n  \"page.openClaude\": z.string().default(\"Open in Claude\"),\n  \"page.llmPrompt\": z.string().default(\"Read {url}, I want to ask questions about it.\"),\n  \"code.copy\": z.string().default(\"Copy code\"),\n  \"code.copied\": z.string().default(\"Copied!\"),\n  \"code.wrapOn\": z.string().default(\"Enable wrap\"),\n  \"code.wrapOff\": z.string().default(\"Disable wrap\"),\n  \"code.expand\": z.string().default(\"Expand\"),\n  \"callout.note\": z.string().default(\"Note\"),\n  \"callout.info\": z.string().default(\"Info\"),\n  \"callout.tip\": z.string().default(\"Tip\"),\n  \"callout.warning\": z.string().default(\"Warning\"),\n  \"callout.danger\": z.string().default(\"Danger\"),\n  \"blog.title\": z.string().default(\"Blog\"),\n  \"blog.allPosts\": z.string().default(\"All Posts\"),\n  \"blog.recentPosts\": z.string().default(\"Recent Posts\"),\n  \"blog.rssFeed\": z.string().default(\"RSS Feed\"),\n  \"blog.tagged\": z.string().default(\"Posts tagged '{tag}'\"),\n  \"changelog.title\": z.string().default(\"Changelog\"),\n  \"changelog.allReleases\": z.string().default(\"All Releases\"),\n  \"changelog.recentReleases\": z.string().default(\"Recent Releases\"),\n  \"error.notFound\": z.string().default(\"The page you're looking for doesn't exist.\"),\n  \"error.goBack\": z.string().default(\"Go Back\"),\n  \"error.tryAgain\": z.string().default(\"Try Again\"),\n  \"error.home\": z.string().default(\"Home\"),\n  \"media.loadingDiagram\": z.string().default(\"Loading diagram…\"),\n  \"media.youtube\": z.string().default(\"YouTube video\"),\n  \"media.soundcloud\": z.string().default(\"SoundCloud audio\"),\n  \"footnote.missing\": z.string().default(\"Footnote not found\"),\n  \"footer.createdWith\": z.string().default(\"Created with {heart} and {livemark}\"),\n})\n\n/** A key of {@link Messages}. */\nexport type MessageKey = keyof Messages\n\n/** Per-key overrides a project sets for one language; unknown keys are rejected. */\nexport type MessageOverrides = z.infer<typeof MessageOverrides>\nexport const MessageOverrides = z.partialRecord(Messages.keyof(), z.string())\n"]}

package/build/models/plugins.d.ts

@@ -0,0 +1,10 @@
+import type { Pluggable } from "textlane";
+import { z } from "zod";
+/** Plugins added to the Markdown pipeline: unified-style attachers or native textlane
+ *  plugins. `md` runs on the Markdown tree before heading ids and components, `html` on
+ *  the HTML tree before heading slugs and the table of contents. */
+export type MarkdownPlugins = z.infer<typeof MarkdownPlugins>;
+export declare const MarkdownPlugins: z.ZodObject<{
+    md: z.ZodOptional<z.ZodArray<z.ZodCustom<Pluggable, Pluggable>>>;
+    html: z.ZodOptional<z.ZodArray<z.ZodCustom<Pluggable, Pluggable>>>;
+}, z.core.$strict>;

package/build/models/plugins.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export const MarkdownPlugins = z.strictObject({
+    md: z.array(z.custom()).optional(),
+    html: z.array(z.custom()).optional(),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NvdXJjZS9tb2RlbHMvcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFBO0FBTXZCLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxDQUFDLENBQUMsWUFBWSxDQUFDO0lBQzVDLEVBQUUsRUFBRSxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQWEsQ0FBQyxDQUFDLFFBQVEsRUFBRTtJQUM3QyxJQUFJLEVBQUUsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsTUFBTSxFQUFhLENBQUMsQ0FBQyxRQUFRLEVBQUU7Q0FDaEQsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBQbHVnZ2FibGUgfSBmcm9tIFwidGV4dGxhbmVcIlxuaW1wb3J0IHsgeiB9IGZyb20gXCJ6b2RcIlxuXG4vKiogUGx1Z2lucyBhZGRlZCB0byB0aGUgTWFya2Rvd24gcGlwZWxpbmU6IHVuaWZpZWQtc3R5bGUgYXR0YWNoZXJzIG9yIG5hdGl2ZSB0ZXh0bGFuZVxuICogIHBsdWdpbnMuIGBtZGAgcnVucyBvbiB0aGUgTWFya2Rvd24gdHJlZSBiZWZvcmUgaGVhZGluZyBpZHMgYW5kIGNvbXBvbmVudHMsIGBodG1sYCBvblxuICogIHRoZSBIVE1MIHRyZWUgYmVmb3JlIGhlYWRpbmcgc2x1Z3MgYW5kIHRoZSB0YWJsZSBvZiBjb250ZW50cy4gKi9cbmV4cG9ydCB0eXBlIE1hcmtkb3duUGx1Z2lucyA9IHouaW5mZXI8dHlwZW9mIE1hcmtkb3duUGx1Z2lucz5cbmV4cG9ydCBjb25zdCBNYXJrZG93blBsdWdpbnMgPSB6LnN0cmljdE9iamVjdCh7XG4gIG1kOiB6LmFycmF5KHouY3VzdG9tPFBsdWdnYWJsZT4oKSkub3B0aW9uYWwoKSxcbiAgaHRtbDogei5hcnJheSh6LmN1c3RvbTxQbHVnZ2FibGU+KCkpLm9wdGlvbmFsKCksXG59KVxuIl19

package/build/models/theme.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+/** Light syntax highlighting theme (Shiki) */
+/** A light Shiki theme name. */
+export type CodeThemeLight = z.infer<typeof CodeThemeLight>;
+export declare const CodeThemeLight: z.ZodEnum<{
+    "ayu-light": "ayu-light";
+    "catppuccin-latte": "catppuccin-latte";
+    "everforest-light": "everforest-light";
+    "github-light": "github-light";
+    "github-light-default": "github-light-default";
+    "github-light-high-contrast": "github-light-high-contrast";
+    "gruvbox-light-hard": "gruvbox-light-hard";
+    "gruvbox-light-medium": "gruvbox-light-medium";
+    "gruvbox-light-soft": "gruvbox-light-soft";
+    "horizon-bright": "horizon-bright";
+    "kanagawa-lotus": "kanagawa-lotus";
+    "light-plus": "light-plus";
+    "material-theme-lighter": "material-theme-lighter";
+    "min-light": "min-light";
+    "night-owl-light": "night-owl-light";
+    "one-light": "one-light";
+    "rose-pine-dawn": "rose-pine-dawn";
+    "slack-ochin": "slack-ochin";
+    "snazzy-light": "snazzy-light";
+    "solarized-light": "solarized-light";
+    "vitesse-light": "vitesse-light";
+}>;
+/** Dark syntax highlighting theme (Shiki) */
+/** A dark Shiki theme name. */
+export type CodeThemeDark = z.infer<typeof CodeThemeDark>;
+export declare const CodeThemeDark: z.ZodEnum<{
+    andromeeda: "andromeeda";
+    "aurora-x": "aurora-x";
+    "ayu-dark": "ayu-dark";
+    "ayu-mirage": "ayu-mirage";
+    "catppuccin-frappe": "catppuccin-frappe";
+    "catppuccin-macchiato": "catppuccin-macchiato";
+    "catppuccin-mocha": "catppuccin-mocha";
+    "dark-plus": "dark-plus";
+    dracula: "dracula";
+    "dracula-soft": "dracula-soft";
+    "everforest-dark": "everforest-dark";
+    "github-dark": "github-dark";
+    "github-dark-default": "github-dark-default";
+    "github-dark-dimmed": "github-dark-dimmed";
+    "github-dark-high-contrast": "github-dark-high-contrast";
+    "gruvbox-dark-hard": "gruvbox-dark-hard";
+    "gruvbox-dark-medium": "gruvbox-dark-medium";
+    "gruvbox-dark-soft": "gruvbox-dark-soft";
+    horizon: "horizon";
+    houston: "houston";
+    "kanagawa-dragon": "kanagawa-dragon";
+    "kanagawa-wave": "kanagawa-wave";
+    laserwave: "laserwave";
+    "material-theme": "material-theme";
+    "material-theme-darker": "material-theme-darker";
+    "material-theme-ocean": "material-theme-ocean";
+    "material-theme-palenight": "material-theme-palenight";
+    "min-dark": "min-dark";
+    monokai: "monokai";
+    "night-owl": "night-owl";
+    nord: "nord";
+    "one-dark-pro": "one-dark-pro";
+    plastic: "plastic";
+    poimandres: "poimandres";
+    red: "red";
+    "rose-pine": "rose-pine";
+    "rose-pine-moon": "rose-pine-moon";
+    "slack-dark": "slack-dark";
+    "solarized-dark": "solarized-dark";
+    "synthwave-84": "synthwave-84";
+    "tokyo-night": "tokyo-night";
+    vesper: "vesper";
+    "vitesse-black": "vitesse-black";
+    "vitesse-dark": "vitesse-dark";
+}>;

package/build/models/theme.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export const CodeThemeLight = z.enum([
+    "ayu-light",
+    "catppuccin-latte",
+    "everforest-light",
+    "github-light",
+    "github-light-default",
+    "github-light-high-contrast",
+    "gruvbox-light-hard",
+    "gruvbox-light-medium",
+    "gruvbox-light-soft",
+    "horizon-bright",
+    "kanagawa-lotus",
+    "light-plus",
+    "material-theme-lighter",
+    "min-light",
+    "night-owl-light",
+    "one-light",
+    "rose-pine-dawn",
+    "slack-ochin",
+    "snazzy-light",
+    "solarized-light",
+    "vitesse-light",
+]);
+export const CodeThemeDark = z.enum([
+    "andromeeda",
+    "aurora-x",
+    "ayu-dark",
+    "ayu-mirage",
+    "catppuccin-frappe",
+    "catppuccin-macchiato",
+    "catppuccin-mocha",
+    "dark-plus",
+    "dracula",
+    "dracula-soft",
+    "everforest-dark",
+    "github-dark",
+    "github-dark-default",
+    "github-dark-dimmed",
+    "github-dark-high-contrast",
+    "gruvbox-dark-hard",
+    "gruvbox-dark-medium",
+    "gruvbox-dark-soft",
+    "horizon",
+    "houston",
+    "kanagawa-dragon",
+    "kanagawa-wave",
+    "laserwave",
+    "material-theme",
+    "material-theme-darker",
+    "material-theme-ocean",
+    "material-theme-palenight",
+    "min-dark",
+    "monokai",
+    "night-owl",
+    "nord",
+    "one-dark-pro",
+    "plastic",
+    "poimandres",
+    "red",
+    "rose-pine",
+    "rose-pine-moon",
+    "slack-dark",
+    "solarized-dark",
+    "synthwave-84",
+    "tokyo-night",
+    "vesper",
+    "vitesse-black",
+    "vitesse-dark",
+]);
+//# sourceMappingURL=data:application/json;base64,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

package/build/models/toc.d.ts

@@ -0,0 +1,5 @@
+export interface TocItem {
+    url: string;
+    title: string;
+    depth: number;
+}

package/build/models/toc.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9jLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc291cmNlL21vZGVscy90b2MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgVG9jSXRlbSB7XG4gIHVybDogc3RyaW5nXG4gIHRpdGxlOiBzdHJpbmdcbiAgZGVwdGg6IG51bWJlclxufVxuIl19

package/build/plugins/twoslash.d.ts

@@ -0,0 +1,13 @@
+import type { Root } from "hast";
+/** A fenced code block whose meta names `twoslash` */
+export declare const TWOSLASH_FENCE: RegExp;
+/** Re-highlight the code blocks whose meta names `twoslash` with Shiki's twoslash
+ *  transformer: the one stage textlane cannot run natively, as it needs TypeScript. */
+export declare function twoslashStage(options: {
+    themes: {
+        light: string;
+        dark: string;
+    };
+}): (tree: Root) => Promise<void>;
+/** Start TypeScript in the twoslash worker now, so it is ready once a block needs it */
+export declare function warmTwoslash(): void;

package/build/plugins/twoslash.js

@@ -0,0 +1,146 @@
+import { Worker } from "node:worker_threads";
+import { readNodeText } from "../helpers/node-text.js";
+/** A fenced code block whose meta names `twoslash` */
+export const TWOSLASH_FENCE = /^[ \t>]*(?:`{3,}|~{3,})[^\n]*\btwoslash\b/m;
+const TWOSLASH = /(?:^|\s)twoslash(?:\s|$)/;
+/** Re-highlight the code blocks whose meta names `twoslash` with Shiki's twoslash
+ *  transformer: the one stage textlane cannot run natively, as it needs TypeScript. */
+export function twoslashStage(options) {
+    return async (tree) => {
+        const blocks = [];
+        for (const node of walkElements(tree)) {
+            if (node.tagName !== "pre")
+                continue;
+            const meta = node.properties["data-meta"] ?? node.properties.dataMeta;
+            if (typeof meta !== "string" || !TWOSLASH.test(meta))
+                continue;
+            blocks.push({ node, meta, lang: readLanguage(node) });
+        }
+        const themes = options.themes;
+        await Promise.all(blocks.map(async (block) => {
+            const pre = await renderBlock({
+                ...block,
+                code: readNodeText(block.node),
+                themes,
+            });
+            if (!pre)
+                return;
+            block.node.properties = structuredClone(pre.properties);
+            block.node.children = structuredClone(pre.children);
+        }));
+    };
+}
+/** Start TypeScript in the twoslash worker now, so it is ready once a block needs it */
+export function warmTwoslash() {
+    readWorker();
+}
+// Translated pages repeat the same blocks, which twoslash would check again
+const rendered = new Map();
+function renderBlock(request) {
+    const key = JSON.stringify([request.lang, request.meta, request.themes, request.code]);
+    let pre = rendered.get(key);
+    if (!pre) {
+        pre = callWorker(request);
+        rendered.set(key, pre);
+    }
+    return pre;
+}
+// TypeScript takes ~0.8 s to start on the thread twoslash runs on; a worker keeps it
+// off the main thread, where textlane compiles every other article meanwhile
+let worker;
+function readWorker() {
+    if (worker)
+        return worker;
+    const thread = new Worker(WORKER_SOURCE, {
+        eval: true,
+        // an eval'd worker resolves bare specifiers from the cwd, so it imports the
+        // packages this module resolves rather than resolving them itself
+        workerData: {
+            shiki: import.meta.resolve("shiki"),
+            twoslash: import.meta.resolve("@shikijs/twoslash"),
+        },
+    });
+    const pending = new Map();
+    thread.on("message", (message) => {
+        const call = pending.get(message.id);
+        pending.delete(message.id);
+        if (pending.size === 0)
+            thread.unref();
+        if (message.error)
+            call?.reject(new Error(message.error));
+        else
+            call?.resolve(message.pre);
+    });
+    thread.on("error", error => {
+        for (const call of pending.values())
+            call.reject(error);
+        pending.clear();
+        worker = undefined;
+    });
+    // Only a worker with blocks in flight keeps the build alive; `on("message")` refs it
+    thread.unref();
+    worker = { thread, pending, next: 0 };
+    return worker;
+}
+function callWorker(request) {
+    const current = readWorker();
+    const id = current.next++;
+    return new Promise((resolve, reject) => {
+        current.pending.set(id, { resolve, reject });
+        current.thread.ref();
+        current.thread.postMessage({ id, ...request });
+    });
+}
+// The first twoslash call builds TypeScript's program over `lib.*.d.ts`; one throwaway
+// block pays that while the main thread still has other articles to compile
+const WORKER_SOURCE = `
+const { parentPort, workerData } = require("node:worker_threads")
+const ready = (async () => {
+  const { bundledLanguages, getSingletonHighlighter } = await import(workerData.shiki)
+  const { transformerTwoslash } = await import(workerData.twoslash)
+  const transformer = transformerTwoslash({ explicitTrigger: true })
+  const highlighter = await getSingletonHighlighter({ themes: [], langs: ["ts"] })
+  highlighter.codeToHast("const a = 1", {
+    lang: "ts",
+    theme: "none",
+    meta: { __raw: "twoslash" },
+    transformers: [transformer],
+  })
+  return { bundledLanguages, highlighter, transformer }
+})()
+parentPort.on("message", async request => {
+  try {
+    const { bundledLanguages, highlighter, transformer } = await ready
+    const lang = request.lang in bundledLanguages ? request.lang : "ts"
+    await highlighter.loadLanguage(lang)
+    await highlighter.loadTheme(request.themes.light, request.themes.dark)
+    const fragment = highlighter.codeToHast(request.code, {
+      lang,
+      themes: request.themes,
+      meta: { __raw: request.meta, "data-meta": request.meta },
+      transformers: [transformer],
+    })
+    const pre = fragment.children[0]
+    parentPort.postMessage({ id: request.id, pre: pre && pre.type === "element" ? pre : undefined })
+  } catch (error) {
+    parentPort.postMessage({ id: request.id, error: String((error && error.stack) || error) })
+  }
+})
+`;
+// addLanguageClass put `language-<name>` on the block's `<code>`
+function readLanguage(pre) {
+    const code = pre.children.find((child) => child.type === "element" && child.tagName === "code");
+    const classes = code?.properties.className;
+    const name = Array.isArray(classes)
+        ? classes.find(item => typeof item === "string" && item.startsWith("language-"))
+        : undefined;
+    return typeof name === "string" ? name.slice("language-".length) : "ts";
+}
+function* walkElements(node) {
+    if (node.type === "element")
+        yield node;
+    if ("children" in node)
+        for (const child of node.children)
+            yield* walkElements(child);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"twoslash.js","sourceRoot":"","sources":["../../source/plugins/twoslash.ts"],"names":[],"mappings":"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","sourcesContent":["import { Worker } from \"node:worker_threads\"\nimport type { Element, ElementContent, Root, RootContent } from \"hast\"\nimport { readNodeText } from \"../helpers/node-text.ts\"\n\n/** A fenced code block whose meta names `twoslash` */\nexport const TWOSLASH_FENCE = /^[ \\t>]*(?:`{3,}|~{3,})[^\\n]*\\btwoslash\\b/m\n\nconst TWOSLASH = /(?:^|\\s)twoslash(?:\\s|$)/\n\n/** Re-highlight the code blocks whose meta names `twoslash` with Shiki's twoslash\n *  transformer: the one stage textlane cannot run natively, as it needs TypeScript. */\nexport function twoslashStage(options: { themes: { light: string; dark: string } }) {\n  return async (tree: Root) => {\n    const blocks: { node: Element; meta: string; lang: string }[] = []\n    for (const node of walkElements(tree)) {\n      if (node.tagName !== \"pre\") continue\n      const meta = node.properties[\"data-meta\"] ?? node.properties.dataMeta\n      if (typeof meta !== \"string\" || !TWOSLASH.test(meta)) continue\n      blocks.push({ node, meta, lang: readLanguage(node) })\n    }\n    const themes = options.themes\n    await Promise.all(\n      blocks.map(async block => {\n        const pre = await renderBlock({\n          ...block,\n          code: readNodeText(block.node),\n          themes,\n        })\n        if (!pre) return\n        block.node.properties = structuredClone(pre.properties)\n        block.node.children = structuredClone(pre.children) as ElementContent[]\n      }),\n    )\n  }\n}\n\n/** Start TypeScript in the twoslash worker now, so it is ready once a block needs it */\nexport function warmTwoslash() {\n  readWorker()\n}\n\ninterface BlockRequest {\n  code: string\n  lang: string\n  meta: string\n  themes: { light: string; dark: string }\n}\n\n// Translated pages repeat the same blocks, which twoslash would check again\nconst rendered = new Map<string, Promise<Element | undefined>>()\n\nfunction renderBlock(request: BlockRequest) {\n  const key = JSON.stringify([request.lang, request.meta, request.themes, request.code])\n  let pre = rendered.get(key)\n  if (!pre) {\n    pre = callWorker(request)\n    rendered.set(key, pre)\n  }\n  return pre\n}\n\ninterface Pending {\n  resolve: (pre: Element | undefined) => void\n  reject: (error: Error) => void\n}\n\n// TypeScript takes ~0.8 s to start on the thread twoslash runs on; a worker keeps it\n// off the main thread, where textlane compiles every other article meanwhile\nlet worker: { thread: Worker; pending: Map<number, Pending>; next: number } | undefined\n\nfunction readWorker() {\n  if (worker) return worker\n  const thread = new Worker(WORKER_SOURCE, {\n    eval: true,\n    // an eval'd worker resolves bare specifiers from the cwd, so it imports the\n    // packages this module resolves rather than resolving them itself\n    workerData: {\n      shiki: import.meta.resolve(\"shiki\"),\n      twoslash: import.meta.resolve(\"@shikijs/twoslash\"),\n    },\n  })\n  const pending = new Map<number, Pending>()\n  thread.on(\"message\", (message: { id: number; pre?: Element; error?: string }) => {\n    const call = pending.get(message.id)\n    pending.delete(message.id)\n    if (pending.size === 0) thread.unref()\n    if (message.error) call?.reject(new Error(message.error))\n    else call?.resolve(message.pre)\n  })\n  thread.on(\"error\", error => {\n    for (const call of pending.values()) call.reject(error)\n    pending.clear()\n    worker = undefined\n  })\n  // Only a worker with blocks in flight keeps the build alive; `on(\"message\")` refs it\n  thread.unref()\n  worker = { thread, pending, next: 0 }\n  return worker\n}\n\nfunction callWorker(request: BlockRequest) {\n  const current = readWorker()\n  const id = current.next++\n  return new Promise<Element | undefined>((resolve, reject) => {\n    current.pending.set(id, { resolve, reject })\n    current.thread.ref()\n    current.thread.postMessage({ id, ...request })\n  })\n}\n\n// The first twoslash call builds TypeScript's program over `lib.*.d.ts`; one throwaway\n// block pays that while the main thread still has other articles to compile\nconst WORKER_SOURCE = `\nconst { parentPort, workerData } = require(\"node:worker_threads\")\nconst ready = (async () => {\n  const { bundledLanguages, getSingletonHighlighter } = await import(workerData.shiki)\n  const { transformerTwoslash } = await import(workerData.twoslash)\n  const transformer = transformerTwoslash({ explicitTrigger: true })\n  const highlighter = await getSingletonHighlighter({ themes: [], langs: [\"ts\"] })\n  highlighter.codeToHast(\"const a = 1\", {\n    lang: \"ts\",\n    theme: \"none\",\n    meta: { __raw: \"twoslash\" },\n    transformers: [transformer],\n  })\n  return { bundledLanguages, highlighter, transformer }\n})()\nparentPort.on(\"message\", async request => {\n  try {\n    const { bundledLanguages, highlighter, transformer } = await ready\n    const lang = request.lang in bundledLanguages ? request.lang : \"ts\"\n    await highlighter.loadLanguage(lang)\n    await highlighter.loadTheme(request.themes.light, request.themes.dark)\n    const fragment = highlighter.codeToHast(request.code, {\n      lang,\n      themes: request.themes,\n      meta: { __raw: request.meta, \"data-meta\": request.meta },\n      transformers: [transformer],\n    })\n    const pre = fragment.children[0]\n    parentPort.postMessage({ id: request.id, pre: pre && pre.type === \"element\" ? pre : undefined })\n  } catch (error) {\n    parentPort.postMessage({ id: request.id, error: String((error && error.stack) || error) })\n  }\n})\n`\n\n// addLanguageClass put `language-<name>` on the block's `<code>`\nfunction readLanguage(pre: Element) {\n  const code = pre.children.find(\n    (child): child is Element => child.type === \"element\" && child.tagName === \"code\",\n  )\n  const classes = code?.properties.className\n  const name = Array.isArray(classes)\n    ? classes.find(item => typeof item === \"string\" && item.startsWith(\"language-\"))\n    : undefined\n  return typeof name === \"string\" ? name.slice(\"language-\".length) : \"ts\"\n}\n\nfunction* walkElements(node: Root | RootContent): Generator<Element> {\n  if (node.type === \"element\") yield node\n  if (\"children\" in node) for (const child of node.children) yield* walkElements(child)\n}\n"]}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@livemark/markdown",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.45.0",
+  "description": "Internal: the Markdown pipeline and components shared by livemark and @livemark/vite",
+  "license": "MIT",
+  "author": "Evgeny Karev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/datisthq/livemark",
+    "directory": "markdown"
+  },
+  "files": [
+    "build",
+    "source",
+    "!source/**/*.unit.ts",
+    "!source/**/fixtures"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./standalone.css": "./source/standalone.css",
+    "./package.json": "./package.json",
+    "./components/*": "./source/components/*.tsx",
+    "./elements/*": "./source/elements/*.tsx",
+    "./hooks/*": "./source/hooks/*.ts",
+    "./styles/*": "./source/styles/*.css",
+    "./*.ts": {
+      "source": "./source/*.ts",
+      "types": "./source/*.ts",
+      "default": "./build/*.js"
+    },
+    "./*.tsx": "./source/*.tsx"
+  },
+  "dependencies": {
+    "@base-ui/react": "1.9.0",
+    "@shikijs/twoslash": "^4.5.0",
+    "@tailwindcss/typography": "^0.5.20",
+    "@tanstack/react-router": "1.170.42",
+    "@types/hast": "3.0.4",
+    "@types/mdast": "^4.0.4",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "class-variance-authority": "0.7.1",
+    "cn": "0.4.0",
+    "katex": "0.19.0",
+    "lucide-react": "0.577.0",
+    "mermaid": "^12.1.0",
+    "react-medium-image-zoom": "^5.4.9",
+    "shiki": "4.5.0",
+    "tailwindcss": "4.3.3",
+    "textlane": "0.3.0",
+    "tw-animate-css": "1.4.0",
+    "yaml": "^2.9.1",
+    "zod": "4.6.6"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "engines": {
+    "node": "^24.11.0"
+  },
+  "scripts": {
+    "build": "tsgo --project tsconfig.build.json"
+  }
 }

package/source/actions/markdown/compile.ts

@@ -0,0 +1,82 @@
+import { flattenToc } from "../../helpers/toc-outline.ts"
+import type { MarkdownPlugins } from "../../models/plugins.ts"
+import { TWOSLASH_FENCE } from "../../plugins/twoslash.ts"
+import { createProcessor } from "../processor/create.ts"
+
+/** How Markdown compiles: the code themes, plugins, raw HTML and image URLs. */
+export interface MarkdownOptions {
+  codeThemeLight?: string
+  codeThemeDark?: string
+  plugins?: MarkdownPlugins
+  allowDangerousHtml?: boolean
+  root?: string
+  base?: string
+}
+
+/** Internal: compile a Markdown or MDX body (no frontmatter) into code and its outline.
+ *  `program` is an ES module, `function-body` the body `new Function` evaluates. */
+export async function compileMarkdown(props: {
+  content: string
+  filePath: string
+  format: "md" | "mdx"
+  outputFormat: "program" | "function-body"
+  options: MarkdownOptions
+}) {
+  if (props.format === "mdx" && props.options.allowDangerousHtml === false) {
+    throw new Error(
+      `${props.filePath}: MDX runs code, which allowDangerousHtml: false forbids`,
+    )
+  }
+  const twoslash = TWOSLASH_FENCE.test(props.content)
+  const processor = readProcessor(
+    props.options,
+    props.format,
+    props.outputFormat,
+    twoslash,
+  )
+  const file = await processor.process({ value: props.content, path: props.filePath })
+  return { code: String(file.value), toc: flattenToc(file.data.toc) }
+}
+
+/** A file's format: its frontmatter `format` when set, else `.mdx` is MDX. */
+export function detectMarkdownFormat(props: { filePath: string; format?: unknown }) {
+  if (props.format === "md" || props.format === "mdx") return props.format
+  return props.filePath.endsWith(".mdx") ? "mdx" : "md"
+}
+
+// A frozen processor runs any number of files, so each variant is built once per options
+const processors = new WeakMap<
+  MarkdownOptions,
+  Map<string, ReturnType<typeof createProcessor>>
+>()
+
+function readProcessor(
+  options: MarkdownOptions,
+  format: "md" | "mdx",
+  outputFormat: "program" | "function-body",
+  twoslash: boolean,
+) {
+  let variants = processors.get(options)
+  if (!variants) {
+    variants = new Map()
+    processors.set(options, variants)
+  }
+  const key = `${format}:${outputFormat}:${twoslash}`
+  let processor = variants.get(key)
+  if (!processor) {
+    processor = createProcessor({
+      format,
+      twoslash,
+      outputFormat,
+      allowDangerousHtml: options.allowDangerousHtml ?? true,
+      // Livemark's own defaults in models/config.ts
+      codeThemeLight: options.codeThemeLight ?? "catppuccin-latte",
+      codeThemeDark: options.codeThemeDark ?? "catppuccin-mocha",
+      plugins: options.plugins,
+      root: options.root,
+      base: options.base,
+    })
+    variants.set(key, processor)
+  }
+  return processor
+}