comark-ui 0.0.0 → 0.7.1

package/dist/editor-CNivEuMH.d.mts

@@ -0,0 +1,131 @@
+import { ComarkPlugin } from "comark";
+import { AnyExtension, Extension, JSONContent, Node } from "@tiptap/core";
+import { StarterKitOptions } from "@tiptap/starter-kit";
+import { EditorState, Plugin, PluginKey, Transaction } from "@tiptap/pm/state";
+import { DecorationSet } from "@tiptap/pm/view";
+//#region src/editor/kit.d.ts
+interface ComarkKitOptions {
+  /**
+   * Passed to StarterKit. A collaborative editor turns `undoRedo` off, since Yjs keeps its own history. Comark has no
+   * underline syntax, so `underline` is always off.
+   */
+  starterKit?: Partial<StarterKitOptions>;
+}
+/** Markdown's image, inline as Comark parses it, drawn as a player when comark-media would play it. */
+declare const ComarkImage: Node<import("@tiptap/extension-image").ImageOptions, any>;
+/** A block component, `::name`, or a block of raw HTML. Its children are blocks and its `#slot`s. */
+declare const ComarkBlock: Node<any, any>;
+/** A component's named slot, `#name`. */
+declare const ComarkSlot: Node<any, any>;
+/** An inline component, `:name[text]{props}`, or inline raw HTML. */
+declare const ComarkInline: Node<any, any>;
+/** An HTML comment between blocks. */
+declare const ComarkComment: Node<any, any>;
+/**
+ * The schema `fromMarkdown` and `toMarkdown` read and write: StarterKit's nodes and marks, task lists, inline images,
+ * tables, and Comark's components, slots, and comments. It needs no DOM, so a server can load it to convert a document
+ * for a collaborative room.
+ */
+declare const ComarkKit: Extension<ComarkKitOptions, any>;
+//#endregion
+//#region src/editor/markdown.d.ts
+interface EditorDocument {
+  /** The document as Tiptap JSON, for `setContent` or a collaborative room. */
+  doc: JSONContent;
+  /** The front matter, which stays outside the editor: a collaborative room keeps only the body. */
+  frontmatter: Record<string, unknown>;
+  /** The Markdown holds something the editor can't keep, so writing it back would change more than the edit. */
+  lossy: boolean;
+}
+/** Reads Markdown into the editor's document. */
+declare function fromMarkdown(markdown: string): Promise<EditorDocument>;
+/** Writes the editor's document, such as `editor.getJSON()`, back to Markdown. */
+declare function toMarkdown(doc: JSONContent, options?: {
+  frontmatter?: Record<string, unknown>;
+}): Promise<string>;
+type MarkdownCheck = {
+  editable: true;
+  /** The Markdown as the editor writes it, which the first save produces. */ markdown: string;
+} | {
+  editable: false;
+};
+/**
+ * Whether the editor can open this Markdown and save it without changing what readers see. Pass the parse plugins the
+ * page renders with, so syntax only they read, such as footnote definitions, counts too.
+ */
+declare function checkMarkdown(markdown: string, options?: {
+  plugins?: readonly ComarkPlugin<any, any>[];
+}): Promise<MarkdownCheck>;
+//#endregion
+//#region src/editor/upload.d.ts
+interface UploadOptions {
+  /**
+   * Sends one file and resolves with the URL the document links to. Call `progress` with a fraction from 0 to 1 as the
+   * bytes go; `fetch` can't report them, so use XMLHttpRequest's `upload.onprogress`. Without it, nothing uploads.
+   */
+  upload?: (file: File, progress: (fraction: number) => void) => Promise<string>;
+  /** Which files to take from a paste or a drop. Images, video, and audio by default. */
+  accept: (file: File) => boolean;
+  /** Called when `upload` rejects. The placeholder is gone by then. */
+  onError?: (error: unknown, file: File) => void;
+}
+/** What a placeholder shows while its file uploads. */
+interface PendingUpload {
+  id: number;
+  file: File;
+  /** From 0 to 1, or `null` until the first progress report. */
+  fraction: number | null;
+  /** A `blob:` URL for an image or video's preview, for this browser only. */
+  preview?: string;
+}
+/** The state an editor view gives the plugin: a test can pass a plain object. */
+interface View {
+  readonly state: EditorState;
+  dispatch(tr: Transaction): void;
+}
+declare const uploadKey: PluginKey<DecorationSet>;
+/** Where placeholder `id` sits now, after every edit since it was added. */
+declare function findUpload(state: EditorState, id: number): number | undefined;
+/**
+ * Uploads `files` into the document at `pos`. Each shows a placeholder there until its URL comes back, then becomes an
+ * image node, which comark-media plays when its URL ends in a video or audio extension. The placeholder is a
+ * decoration, so a collaborative room never sees a file that hasn't finished.
+ */
+declare function startUploads(view: View, files: File[], pos: number, options: UploadOptions): Promise<string | undefined>[];
+/** The plugin alone, for a ProseMirror editor without Tiptap. */
+declare function uploadPlugin(options: UploadOptions): Plugin<DecorationSet>;
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    comarkUpload: {
+      /** Uploads files at the cursor, as a paste would, such as the ones a file picker returns. */
+      uploadFiles: (files: File[]) => ReturnType;
+    };
+  }
+}
+/** Uploads pasted and dropped files, with a placeholder that shows the progress. Pass `upload` to turn it on. */
+declare const Upload: Extension<UploadOptions, any>;
+//#endregion
+//#region src/editor/codec.d.ts
+/**
+ * A schema and Markdown codec that a server and its browsers share, as a collaborative room needs: the server converts
+ * the stored Markdown with it, and every editor that joins builds the same schema from `extensions()`. ViteHub
+ * Realtime's `editor` option takes it as it is.
+ */
+interface EditorCodec {
+  extensions(): AnyExtension[];
+  fromMarkdown(markdown: string): Promise<JSONContent>;
+  toMarkdown(doc: JSONContent): Promise<string>;
+  /** Whether the room may save this document. `canonical` is what the first save writes for it unchanged. */
+  verify(markdown: string): Promise<{
+    writable: boolean;
+    canonical?: string;
+  }>;
+}
+interface EditorCodecOptions {
+  kit?: ComarkKitOptions;
+  /** The parse plugins the page renders with, so a document only they read opens read-only. */
+  plugins?: readonly ComarkPlugin<any, any>[];
+}
+declare function createEditorCodec(options?: EditorCodecOptions): EditorCodec;
+//#endregion
+export { ComarkSlot as S, ComarkComment as _, Upload as a, ComarkKit as b, startUploads as c, EditorDocument as d, MarkdownCheck as f, ComarkBlock as g, toMarkdown as h, PendingUpload as i, uploadKey as l, fromMarkdown as m, EditorCodecOptions as n, UploadOptions as o, checkMarkdown as p, createEditorCodec as r, findUpload as s, EditorCodec as t, uploadPlugin as u, ComarkImage as v, ComarkKitOptions as x, ComarkInline as y };

package/dist/editor-vue.d.mts

@@ -0,0 +1,57 @@
+import { x as ComarkKitOptions } from "./editor-CNivEuMH.mjs";
+import { ComarkPlugin } from "comark";
+import { AnyExtension } from "@tiptap/core";
+import { Editor } from "@tiptap/vue-3";
+import { PropType, Ref } from "vue";
+//#region src/editor-vue.d.ts
+export interface UseComarkEditorOptions {
+  /** Added after ComarkKit, such as a placeholder. */
+  extensions?: AnyExtension[];
+  kit?: ComarkKitOptions;
+  /** The parse plugins the page renders with, so a document only they read is opened read-only. */
+  plugins?: readonly ComarkPlugin<any, any>[];
+}
+/**
+ * A Tiptap editor bound to a Markdown string: an edit writes the Markdown back, and a change from outside reloads the
+ * editor. A document the editor can't save unchanged (see `checkMarkdown`) opens read-only, with `editable` false.
+ */
+export declare function useComarkEditor(markdown: Ref<string>, options?: UseComarkEditorOptions): {
+  editor: import("vue").ShallowRef<Editor | undefined, Editor | undefined>;
+  editable: Ref<boolean, boolean>;
+};
+/** `useComarkEditor` as a component: `<ComarkEditor v-model="markdown" />`. */
+export declare const ComarkEditor: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  modelValue: {
+    type: StringConstructor;
+    required: true;
+  };
+  extensions: {
+    type: PropType<AnyExtension[]>;
+    default: undefined;
+  };
+  plugins: {
+    type: PropType<ComarkPlugin<any, any>[]>;
+    default: undefined;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  modelValue: {
+    type: StringConstructor;
+    required: true;
+  };
+  extensions: {
+    type: PropType<AnyExtension[]>;
+    default: undefined;
+  };
+  plugins: {
+    type: PropType<ComarkPlugin<any, any>[]>;
+    default: undefined;
+  };
+}>> & Readonly<{
+  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+  extensions: AnyExtension[];
+  plugins: ComarkPlugin<any, any>[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion

package/dist/editor-vue.mjs

@@ -0,0 +1,85 @@
+import { c as fromMarkdown, l as toMarkdown, m as ComarkKit, s as checkMarkdown } from "./editor-BAdok66p.mjs";
+import { Editor, EditorContent } from "@tiptap/vue-3";
+import { defineComponent, h, onScopeDispose, ref, shallowRef, watch } from "vue";
+//#region src/editor-vue.ts
+/**
+* A Tiptap editor bound to a Markdown string: an edit writes the Markdown back, and a change from outside reloads the
+* editor. A document the editor can't save unchanged (see `checkMarkdown`) opens read-only, with `editable` false.
+*/
+function useComarkEditor(markdown, options = {}) {
+	const editor = shallowRef();
+	const editable = ref(false);
+	let frontmatter = {};
+	let written;
+	let loads = 0;
+	let saves = 0;
+	async function save() {
+		const current = editor.value;
+		if (!current) return;
+		const run = ++saves;
+		const next = await toMarkdown(current.getJSON(), { frontmatter });
+		if (run !== saves) return;
+		written = next;
+		markdown.value = next;
+	}
+	async function load(source) {
+		const run = ++loads;
+		++saves;
+		const [check, read] = await Promise.all([checkMarkdown(source, { plugins: options.plugins }), fromMarkdown(source)]);
+		if (run !== loads) return;
+		frontmatter = read.frontmatter;
+		editable.value = check.editable;
+		if (editor.value) {
+			editor.value.commands.setContent(read.doc, { emitUpdate: false });
+			editor.value.setEditable(check.editable, false);
+			return;
+		}
+		editor.value = new Editor({
+			extensions: [ComarkKit.configure(options.kit), ...options.extensions ?? []],
+			content: read.doc,
+			editable: check.editable,
+			onUpdate: () => void save()
+		});
+	}
+	watch(markdown, (value) => {
+		if (value !== written) load(value);
+	}, { immediate: true });
+	onScopeDispose(() => editor.value?.destroy());
+	return {
+		editor,
+		editable
+	};
+}
+/** `useComarkEditor` as a component: `<ComarkEditor v-model="markdown" />`. */
+const ComarkEditor = defineComponent({
+	name: "ComarkEditor",
+	props: {
+		modelValue: {
+			type: String,
+			required: true
+		},
+		extensions: {
+			type: Array,
+			default: void 0
+		},
+		plugins: {
+			type: Array,
+			default: void 0
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(props, { emit }) {
+		const markdown = ref(props.modelValue);
+		watch(() => props.modelValue, (value) => markdown.value = value);
+		watch(markdown, (value) => {
+			if (value !== props.modelValue) emit("update:modelValue", value);
+		});
+		const { editor } = useComarkEditor(markdown, {
+			extensions: props.extensions,
+			plugins: props.plugins
+		});
+		return () => editor.value ? h(EditorContent, { editor: editor.value }) : null;
+	}
+});
+//#endregion
+export { ComarkEditor, useComarkEditor };

package/dist/editor.d.mts

@@ -0,0 +1,2 @@
+import { S as ComarkSlot, _ as ComarkComment, a as Upload, b as ComarkKit, c as startUploads, d as EditorDocument, f as MarkdownCheck, g as ComarkBlock, h as toMarkdown, i as PendingUpload, l as uploadKey, m as fromMarkdown, n as EditorCodecOptions, o as UploadOptions, p as checkMarkdown, r as createEditorCodec, s as findUpload, t as EditorCodec, u as uploadPlugin, v as ComarkImage, x as ComarkKitOptions, y as ComarkInline } from "./editor-CNivEuMH.mjs";
+export { ComarkBlock, ComarkComment, ComarkImage, ComarkInline, ComarkKit, type ComarkKitOptions, ComarkSlot, type EditorCodec, type EditorCodecOptions, type EditorDocument, type MarkdownCheck, type PendingUpload, Upload, type UploadOptions, checkMarkdown, createEditorCodec, findUpload, fromMarkdown, startUploads, toMarkdown, uploadKey, uploadPlugin };

package/dist/editor.mjs

@@ -0,0 +1 @@
+export { u as ComarkBlock, d as ComarkComment, f as ComarkImage, p as ComarkInline, m as ComarkKit, h as ComarkSlot, n as Upload, s as checkMarkdown, t as createEditorCodec, r as findUpload, c as fromMarkdown, i as startUploads, l as toMarkdown, a as uploadKey, o as uploadPlugin } from "./editor-BAdok66p.mjs";

package/dist/html.d.mts

@@ -0,0 +1,7 @@
+import { a as criticCss, n as Preset, r as PresetOptions } from "./index-B0YvApci.mjs";
+import { NodeHandler } from "comark";
+//#region src/html.d.ts
+/** Every plugin for `@comark/html`, with the `components` to render them. */
+declare const _default: (options?: PresetOptions) => Preset<NodeHandler>;
+//#endregion
+export { type PresetOptions, criticCss, _default as default };

package/dist/html.mjs

@@ -0,0 +1,90 @@
+import { t as typesetCss } from "./typeset-css-DPB0S1bV.mjs";
+import { n as preset, t as criticCss } from "./src-DROB05U6.mjs";
+import { mermaidCss } from "./client.mjs";
+import * as annotate from "comark-annotate/html";
+import * as badge from "comark-badge/html";
+import * as cards from "comark-cards/html";
+import * as carousel from "comark-carousel/html";
+import * as cast from "comark-cast/html";
+import * as charts from "comark-charts/html";
+import * as chips from "comark-chips/html";
+import * as code from "comark-code/html";
+import * as codeNotes from "comark-code-notes/html";
+import * as colors from "comark-colors/html";
+import * as details from "comark-details/html";
+import * as diagrams from "comark-diagrams/html";
+import * as diff from "comark-diff/html";
+import * as embed from "comark-embed/html";
+import * as fields from "comark-fields/html";
+import * as fileTree from "comark-file-tree/html";
+import * as github from "comark-github/html";
+import * as icon from "comark-icon/html";
+import * as links from "comark-links/html";
+import * as magicMove from "comark-magic-move/html";
+import * as mark from "comark-mark/html";
+import * as math from "comark-mathml/html";
+import * as media from "comark-media/html";
+import pele, { Pele } from "comark-pele/html";
+import * as metrics from "comark-metrics/html";
+import * as outline from "comark-outline/html";
+import * as properties from "comark-properties/html";
+import * as qr from "comark-qr/html";
+import * as quiz from "comark-quiz/html";
+import * as sources from "comark-sources/html";
+import * as steps from "comark-steps/html";
+import * as table from "comark-table/html";
+import * as tabs from "comark-tabs/html";
+import * as tests from "comark-tests/html";
+import * as zoom from "comark-zoom/html";
+//#region src/html.ts
+const styled = /* @__PURE__ */ new WeakSet();
+const mermaid = {
+	default: pele,
+	components: { pele: ((node, state) => {
+		const styles = styled.has(state.context) ? "" : `<style data-comark-mermaid>${mermaidCss}</style>`;
+		styled.add(state.context);
+		return styles + Pele(node);
+	}) }
+};
+const typeset = () => `<style data-comark-typeset>${typesetCss}</style>`;
+/** Every plugin for `@comark/html`, with the `components` to render them. */
+var html_default = (options) => preset({
+	annotate,
+	badge,
+	cards,
+	carousel,
+	cast,
+	charts,
+	chips,
+	code,
+	codeNotes,
+	colors,
+	details,
+	diagrams,
+	diff,
+	embed,
+	fields,
+	fileTree,
+	github,
+	icon,
+	links,
+	magicMove,
+	mark,
+	math,
+	media,
+	mermaid,
+	metrics,
+	outline,
+	properties,
+	qr,
+	quiz,
+	sources,
+	steps,
+	table,
+	tabs,
+	tests,
+	typeset,
+	zoom
+}, options);
+//#endregion
+export { criticCss, html_default as default };

package/dist/index-B0YvApci.d.mts

@@ -0,0 +1,173 @@
+import { CriticOptions, css as criticCss } from "comark-critic";
+import { FigureOptions } from "comark-figure";
+import { FootnotesOptions } from "comark-footnotes";
+import { IconOptions, Icons } from "comark-icon";
+import { IncludeOptions } from "comark-include";
+import { KeysOptions } from "comark-keys";
+import { ReadingTimeOptions } from "comark-reading-time";
+import { XrefOptions } from "comark-xref";
+import { ComarkPlugin } from "comark";
+import { BadgeOptions } from "comark-badge";
+import { CastOptions } from "comark-cast";
+import { ChartsOptions } from "comark-charts";
+import { ChipsOptions } from "comark-chips";
+import { CodeOptions } from "comark-code";
+import { DetailsOptions } from "comark-details";
+import { DiagramsOptions } from "comark-diagrams";
+import { FileTreeOptions } from "comark-file-tree";
+import { CalloutsOptions, ReferencesOptions } from "comark-github";
+import { AnchorsOptions, ExternalOptions } from "comark-links";
+import { MathOptions } from "comark-mathml";
+import { MediaOptions } from "comark-media";
+import { PeleConfig } from "comark-pele";
+import { PropertiesOptions } from "comark-properties";
+import { QuizOptions } from "comark-quiz";
+import { TableOptions } from "comark-table";
+import { TabsOptions } from "comark-tabs";
+import { TestsOptions } from "comark-tests";
+import { ZoomOptions } from "comark-zoom";
+//#region src/typeset.d.ts
+/** The node that adds the styles. The plugin adds one at the end of every document. */
+declare const TYPESET_TAG = "typeset-styles";
+/** Adds the node that writes the typeset styles at the end of the document. The preset turns it on by default. */
+declare const typeset: import("comark").ComarkPluginFactory<unknown, {}, {}>;
+//#endregion
+//#region src/index.d.ts
+/**
+ * `false` turns a plugin off, and an object turns it on with those options. Everything but `include` is on, and cast,
+ * table, and tests read no files until they get options.
+ */
+type PresetOptions = {
+  /** Pastes files into the Markdown before the other plugins read it. Off, since it reads from disk by default. */
+  include?: IncludeOptions | boolean;
+  /** HTML only: Vue, React, and Svelte have no annotate components. */
+  annotate?: boolean;
+  carousel?: boolean;
+  /** Reads no cast files unless you pass `{ root }` or `{ read }`; inline casts render either way. */
+  cast?: CastOptions | boolean;
+  cjk?: boolean;
+  deflist?: boolean;
+  figure?: FigureOptions | boolean;
+  critic?: CriticOptions | boolean;
+  charts?: ChartsOptions | boolean;
+  /** Pass `{ download: false }` when parsing in a browser, which may not download another site's images. */
+  chips?: ChipsOptions | boolean;
+  colors?: boolean;
+  /** Sends each diagram's source to `https://kroki.io` unless you pass your own `server`, or `{ draw: false }`. */
+  diagrams?: DiagramsOptions | boolean;
+  /** Draws `mermaid` fences with comark-pele, on the server and offline. */
+  mermaid?: PeleConfig | boolean;
+  /** HTML only: Vue, React, and Svelte have no diff components. */
+  diff?: boolean;
+  embed?: boolean;
+  footnotes?: FootnotesOptions | boolean;
+  github?: {
+    callouts?: CalloutsOptions | boolean;
+    references?: ReferencesOptions | boolean;
+    html?: boolean;
+  } | boolean;
+  /** Also resolves the icons of cards, details, file trees, tabs, and code actions, so they share its options. */
+  icon?: IconOptions | boolean;
+  magicMove?: boolean;
+  mark?: boolean;
+  /** Typesets `$…$`, `$$…$$`, and `math` fences as MathML while parsing, in place of Comark's math plugin. */
+  math?: MathOptions | boolean;
+  details?: DetailsOptions | boolean;
+  links?: {
+    external?: ExternalOptions | boolean;
+    anchors?: AnchorsOptions | boolean;
+  } | boolean;
+  fileTree?: FileTreeOptions | boolean;
+  fields?: boolean;
+  properties?: PropertiesOptions | boolean;
+  /** HTML only: Vue, React, and Svelte have no quiz components. */
+  quiz?: QuizOptions | boolean;
+  keys?: KeysOptions | boolean;
+  badge?: BadgeOptions | boolean;
+  media?: MediaOptions | boolean;
+  metrics?: boolean;
+  /** Reads no data files unless you pass `{ root }` or `{ read }`; CSV fences render either way. */
+  table?: TableOptions | boolean;
+  cards?: boolean;
+  qr?: boolean;
+  sources?: boolean;
+  steps?: boolean;
+  readingTime?: ReadingTimeOptions | boolean;
+  tabs?: TabsOptions | boolean;
+  outline?: boolean;
+  xref?: XrefOptions | boolean;
+  /** Reads no JUnit reports unless you pass `{ root }` or `{ read }`; inline reports render either way. */
+  tests?: TestsOptions | boolean;
+  zoom?: ZoomOptions | boolean;
+  code?: CodeOptions | boolean;
+  codeNotes?: boolean;
+  /**
+   * The text around the blocks, from shadcn/typeset on the same tokens: headings, paragraphs, lists, tables, code, and
+   * quotes. `false` leaves the text to your own styles.
+   */
+  typeset?: boolean;
+};
+type AnyPlugin = ComarkPlugin<any, any>;
+type Part<C, O = void> = {
+  default: (options?: O) => AnyPlugin;
+  components: Record<string, C>;
+};
+/** One renderer's entry of each package with components, by the option that turns it on. */
+type Renderer<C> = {
+  annotate?: Part<C>;
+  carousel: Part<C>;
+  cast: Part<C, CastOptions>;
+  charts: Part<C, ChartsOptions>;
+  chips: Part<C, ChipsOptions>;
+  colors: Part<C>;
+  diagrams: Part<C, DiagramsOptions>;
+  mermaid: Part<C, PeleConfig>;
+  diff?: Part<C>;
+  embed: Part<C>;
+  github: {
+    callouts: (options?: CalloutsOptions) => AnyPlugin;
+    references: (options?: ReferencesOptions) => AnyPlugin;
+    html: () => AnyPlugin;
+    components: Record<string, C>;
+  };
+  icon: Part<C, IconOptions | Icons>;
+  details: Part<C, DetailsOptions>;
+  links: {
+    external: (options?: ExternalOptions) => AnyPlugin;
+    anchors: (options?: AnchorsOptions) => AnyPlugin;
+    components: Record<string, C>;
+  };
+  fileTree: Part<C, FileTreeOptions>;
+  fields: Part<C>;
+  properties: Part<C, PropertiesOptions>;
+  quiz?: Part<C, QuizOptions>;
+  badge: Part<C, BadgeOptions>;
+  magicMove: Part<C>;
+  mark: Part<C>;
+  math: Part<C, MathOptions>;
+  media: Part<C, MediaOptions>;
+  metrics: Part<C>;
+  table: Part<C, TableOptions>;
+  cards: Part<C, {
+    iconResolver?: Icons;
+  }>;
+  qr: Part<C>;
+  sources: Part<C>;
+  steps: Part<C>;
+  tabs: Part<C, TabsOptions>;
+  outline: Part<C>;
+  tests: Part<C, TestsOptions>;
+  zoom: Part<C, ZoomOptions>;
+  code: Part<C, CodeOptions>;
+  codeNotes: Part<C>;
+  /** The component that writes the typeset styles into the document, as `typeset-styles`. */
+  typeset: C;
+};
+type Preset<C> = {
+  plugins: AnyPlugin[];
+  components: Record<string, C>;
+};
+/** Builds a renderer's preset. Use the one from `comark-ui/html`, `/vue`, `/react`, or `/svelte`. */
+declare function preset<C>(renderer: Renderer<C>, options?: PresetOptions): Preset<C>;
+//#endregion
+export { criticCss as a, typeset as c, Renderer as i, Preset as n, preset as o, PresetOptions as r, TYPESET_TAG as s, AnyPlugin as t };

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { t as typesetCss } from "./typeset-css-DdOGL7WF.mjs";
+import { a as criticCss, c as typeset, i as Renderer, n as Preset, o as preset, r as PresetOptions, s as TYPESET_TAG, t as AnyPlugin } from "./index-B0YvApci.mjs";
+export { AnyPlugin, Preset, PresetOptions, Renderer, TYPESET_TAG, criticCss, preset, typeset, typesetCss };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { t as typesetCss } from "./typeset-css-DPB0S1bV.mjs";
+import { i as typeset, n as preset, r as TYPESET_TAG, t as criticCss } from "./src-DROB05U6.mjs";
+export { TYPESET_TAG, criticCss, preset, typeset, typesetCss };

package/dist/nuxt-ui.d.mts

@@ -0,0 +1,17 @@
+//#region src/nuxt-ui.d.ts
+export type NuxtUiTheme = {
+  /** `ui.colors` from the app's `app.config.ts`, such as `{ primary: "indigo", neutral: "zinc" }`. */
+  colors?: Record<string, string | undefined>;
+  /** The app's main CSS file: its `@theme` colors and fonts, and the `--ui-*` variables its `:root` and `.dark` set. */
+  css?: string;
+};
+/**
+ * Rebuilds a Nuxt UI app's `--ui-*` variables from its `app.config` colors and main CSS, for a page that renders
+ * Comark outside the app, such as a review document. The plugins read those variables, so the page matches the app.
+ * Light mode sits on `:root` and `.light`, dark on `.dark` and on a system in dark mode, all in the `theme` layer.
+ */
+export declare function nuxtUiTheme(theme?: NuxtUiTheme): {
+  css: string;
+  issues: string[];
+};
+//#endregion