@refrakt-md/editor 0.6.0

package/app/src/lib/components/TagsInput.svelte

@@ -0,0 +1,109 @@
+<script lang="ts">
+	interface Props {
+		tags: string[];
+		onchange: (tags: string[]) => void;
+	}
+
+	let { tags, onchange }: Props = $props();
+	let inputValue = $state('');
+
+	function addTag(value: string) {
+		const trimmed = value.trim();
+		if (trimmed && !tags.includes(trimmed)) {
+			onchange([...tags, trimmed]);
+		}
+		inputValue = '';
+	}
+
+	function removeTag(index: number) {
+		onchange(tags.filter((_, i) => i !== index));
+	}
+
+	function handleKeydown(e: KeyboardEvent) {
+		if (e.key === 'Enter' || e.key === ',') {
+			e.preventDefault();
+			addTag(inputValue);
+		} else if (e.key === 'Backspace' && inputValue === '' && tags.length > 0) {
+			removeTag(tags.length - 1);
+		}
+	}
+</script>
+
+<div class="tags-input">
+	{#each tags as tag, i}
+		<span class="tags-input__tag">
+			{tag}
+			<button
+				class="tags-input__remove"
+				onclick={() => removeTag(i)}
+				aria-label="Remove {tag}"
+			>&times;</button>
+		</span>
+	{/each}
+	<input
+		class="tags-input__field"
+		type="text"
+		bind:value={inputValue}
+		onkeydown={handleKeydown}
+		onblur={() => { if (inputValue.trim()) addTag(inputValue); }}
+		placeholder={tags.length === 0 ? 'Add tags...' : ''}
+	/>
+</div>
+
+<style>
+	.tags-input {
+		display: flex;
+		flex-wrap: wrap;
+		gap: var(--ed-space-1);
+		padding: 0.3rem;
+		border: 1px solid var(--ed-border-default);
+		border-radius: var(--ed-radius-sm);
+		background: var(--ed-surface-0);
+		min-height: 2rem;
+		align-items: center;
+	}
+
+	.tags-input:focus-within {
+		border-color: var(--ed-accent);
+		box-shadow: 0 0 0 2px var(--ed-accent-ring);
+	}
+
+	.tags-input__tag {
+		display: inline-flex;
+		align-items: center;
+		gap: 0.2rem;
+		padding: 0.15rem 0.5rem;
+		background: var(--ed-accent-subtle);
+		color: var(--ed-heading);
+		border-radius: 99px;
+		font-size: var(--ed-text-xs);
+		font-weight: 600;
+		line-height: 1.2;
+	}
+
+	.tags-input__remove {
+		background: none;
+		border: none;
+		color: var(--ed-heading);
+		cursor: pointer;
+		font-size: 0.85rem;
+		padding: 0;
+		line-height: 1;
+		opacity: 0.6;
+	}
+
+	.tags-input__remove:hover {
+		opacity: 1;
+	}
+
+	.tags-input__field {
+		flex: 1;
+		min-width: 60px;
+		border: none;
+		outline: none;
+		font-size: var(--ed-text-base);
+		padding: var(--ed-space-1) var(--ed-space-2);
+		background: transparent;
+		color: var(--ed-text-primary);
+	}
+</style>

package/app/src/lib/editor/block-parser.ts

@@ -0,0 +1,437 @@
+import type { RuneInfo } from '../api/client.js';
+
+/**
+ * Block types recognized by the visual editor.
+ *
+ * - heading:  `# …` through `###### …`
+ * - paragraph: plain text (may span multiple lines)
+ * - fence:    ``` code blocks ```
+ * - rune:     `{% name … %}…{% /name %}` or self-closing `{% name … /%}`
+ * - list:     `- …` or `1. …` runs
+ * - quote:    `> …` runs
+ * - hr:       `---` / `***` / `___`
+ * - image:    `![alt](src)` on its own line
+ */
+export type BlockType =
+	| 'heading'
+	| 'paragraph'
+	| 'fence'
+	| 'rune'
+	| 'list'
+	| 'quote'
+	| 'hr'
+	| 'image';
+
+export interface Block {
+	id: string;
+	type: BlockType;
+	/** Raw source text for this block (including tag delimiters for runes) */
+	source: string;
+	/** 0-based start line in the document */
+	startLine: number;
+	/** 0-based end line (exclusive) */
+	endLine: number;
+}
+
+export interface HeadingBlock extends Block {
+	type: 'heading';
+	level: number;
+	text: string;
+}
+
+export interface RuneBlock extends Block {
+	type: 'rune';
+	runeName: string;
+	selfClosing: boolean;
+	/** Parsed attribute key=value pairs */
+	attributes: Record<string, string>;
+	/** Inner content (between open/close tags) */
+	innerContent: string;
+}
+
+export interface FenceBlock extends Block {
+	type: 'fence';
+	language: string;
+	code: string;
+}
+
+export interface ListBlock extends Block {
+	type: 'list';
+	ordered: boolean;
+}
+
+export type ParsedBlock =
+	| HeadingBlock
+	| RuneBlock
+	| FenceBlock
+	| ListBlock
+	| (Block & { type: 'paragraph' | 'quote' | 'hr' | 'image' });
+
+/** Deterministic hash (djb2) for stable block IDs across re-parses */
+function hashSource(s: string): string {
+	let h = 5381;
+	for (let i = 0; i < s.length; i++) {
+		h = ((h << 5) + h + s.charCodeAt(i)) >>> 0;
+	}
+	return h.toString(36);
+}
+
+/** Generate a stable ID from block source content, deduplicating identical blocks */
+function stableId(source: string, seen: Map<string, number>): string {
+	const hash = hashSource(source);
+	const count = seen.get(hash) ?? 0;
+	seen.set(hash, count + 1);
+	return count === 0 ? `blk_${hash}` : `blk_${hash}_${count}`;
+}
+
+// ── Rune tag regex helpers ───────────────────────────────────────────
+
+/** Matches an opening rune tag: {% name attr="val" attr=2 %} or self-closing {% name /%} */
+const RUNE_OPEN_RE = /^\{%\s+(\w[\w-]*)((?:\s+\w[\w-]*(?:="[^"]*"|=[\w.-]+)?)*)\s*(\/?)\s*%\}/;
+
+/** Matches a closing rune tag: {% /name %} */
+function runeCloseRe(name: string): RegExp {
+	return new RegExp(`^\\{%\\s+/${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*%\\}`);
+}
+
+/** Parse attribute string like `method="POST" path="/users" count=3 auth` into Record */
+function parseAttributes(raw: string): Record<string, string> {
+	const attrs: Record<string, string> = {};
+	const re = /(\w[\w-]*)(?:="([^"]*)"|=([\w.-]+))?/g;
+	let m: RegExpExecArray | null;
+	while ((m = re.exec(raw)) !== null) {
+		attrs[m[1]] = m[2] ?? m[3] ?? 'true';
+	}
+	return attrs;
+}
+
+/** Serialize attributes back to Markdoc syntax */
+export function serializeAttributes(attrs: Record<string, string>): string {
+	const parts: string[] = [];
+	for (const [key, value] of Object.entries(attrs)) {
+		if (value === 'true') {
+			parts.push(key);
+		} else {
+			parts.push(`${key}="${value}"`);
+		}
+	}
+	return parts.length > 0 ? ' ' + parts.join(' ') : '';
+}
+
+// ── Main parser ──────────────────────────────────────────────────────
+
+/**
+ * Parse a Markdoc body string into an ordered list of blocks.
+ * Each block maps to a contiguous range of source lines.
+ */
+export function parseBlocks(source: string): ParsedBlock[] {
+	const lines = source.split('\n');
+	const blocks: ParsedBlock[] = [];
+	const seen = new Map<string, number>();
+	let i = 0;
+
+	while (i < lines.length) {
+		const line = lines[i];
+		const trimmed = line.trimStart();
+
+		// Skip blank lines between blocks
+		if (trimmed === '') {
+			i++;
+			continue;
+		}
+
+		// ── Fenced code blocks ───────────────────────────────────
+		if (trimmed.startsWith('```') || trimmed.startsWith('~~~')) {
+			const fence = trimmed.slice(0, 3);
+			const lang = trimmed.slice(3).trim();
+			const start = i;
+			i++;
+			const codeLines: string[] = [];
+			while (i < lines.length && !lines[i].trimStart().startsWith(fence)) {
+				codeLines.push(lines[i]);
+				i++;
+			}
+			if (i < lines.length) i++; // skip closing fence
+			const src = lines.slice(start, i).join('\n');
+			blocks.push({
+				id: stableId(src, seen),
+				type: 'fence',
+				source: src,
+				startLine: start,
+				endLine: i,
+				language: lang,
+				code: codeLines.join('\n'),
+			});
+			continue;
+		}
+
+		// ── Rune tags ────────────────────────────────────────────
+		const runeMatch = RUNE_OPEN_RE.exec(trimmed);
+		if (runeMatch) {
+			const name = runeMatch[1];
+			const attrStr = runeMatch[2] ?? '';
+			const selfClose = runeMatch[3] === '/';
+			const start = i;
+
+			if (selfClose) {
+				i++;
+				const src = lines.slice(start, i).join('\n');
+				blocks.push({
+					id: stableId(src, seen),
+					type: 'rune',
+					source: src,
+					startLine: start,
+					endLine: i,
+					runeName: name,
+					selfClosing: true,
+					attributes: parseAttributes(attrStr),
+					innerContent: '',
+				});
+			} else {
+				// Find matching close tag
+				i++;
+				const closeRe = runeCloseRe(name);
+				const innerLines: string[] = [];
+				let depth = 1;
+				while (i < lines.length) {
+					const lt = lines[i].trimStart();
+					// Check for nested open of same name
+					const nestedOpen = RUNE_OPEN_RE.exec(lt);
+					if (nestedOpen && nestedOpen[1] === name && nestedOpen[3] !== '/') {
+						depth++;
+					}
+					if (closeRe.test(lt)) {
+						depth--;
+						if (depth === 0) break;
+					}
+					innerLines.push(lines[i]);
+					i++;
+				}
+				if (i < lines.length) i++; // skip close tag
+				const src = lines.slice(start, i).join('\n');
+				blocks.push({
+					id: stableId(src, seen),
+					type: 'rune',
+					source: src,
+					startLine: start,
+					endLine: i,
+					runeName: name,
+					selfClosing: false,
+					attributes: parseAttributes(attrStr),
+					innerContent: innerLines.join('\n'),
+				});
+			}
+			continue;
+		}
+
+		// ── Headings ─────────────────────────────────────────────
+		const headingMatch = trimmed.match(/^(#{1,6})\s+(.*)/);
+		if (headingMatch) {
+			const start = i;
+			i++;
+			const src = lines.slice(start, i).join('\n');
+			blocks.push({
+				id: stableId(src, seen),
+				type: 'heading',
+				source: src,
+				startLine: start,
+				endLine: i,
+				level: headingMatch[1].length,
+				text: headingMatch[2],
+			});
+			continue;
+		}
+
+		// ── HR ───────────────────────────────────────────────────
+		if (/^(---+|___+|\*\*\*+)\s*$/.test(trimmed)) {
+			const start = i;
+			i++;
+			const src = lines.slice(start, i).join('\n');
+			blocks.push({
+				id: stableId(src, seen),
+				type: 'hr',
+				source: src,
+				startLine: start,
+				endLine: i,
+			});
+			continue;
+		}
+
+		// ── Image (standalone line) ──────────────────────────────
+		if (/^!\[.*\]\(.*\)\s*$/.test(trimmed)) {
+			const start = i;
+			i++;
+			const src = lines.slice(start, i).join('\n');
+			blocks.push({
+				id: stableId(src, seen),
+				type: 'image',
+				source: src,
+				startLine: start,
+				endLine: i,
+			});
+			continue;
+		}
+
+		// ── Blockquote ───────────────────────────────────────────
+		if (trimmed.startsWith('>')) {
+			const start = i;
+			while (i < lines.length && (lines[i].trimStart().startsWith('>') || (lines[i].trim() !== '' && !isBlockStart(lines[i])))) {
+				i++;
+			}
+			const src = lines.slice(start, i).join('\n');
+			blocks.push({
+				id: stableId(src, seen),
+				type: 'quote',
+				source: src,
+				startLine: start,
+				endLine: i,
+			});
+			continue;
+		}
+
+		// ── List ─────────────────────────────────────────────────
+		const listMatch = trimmed.match(/^(\d+\.|[-*+])\s/);
+		if (listMatch) {
+			const ordered = /^\d+\./.test(listMatch[1]);
+			const start = i;
+			while (i < lines.length) {
+				const lt = lines[i].trimStart();
+				// Continue if it's a list item, continuation indent, or blank line within
+				if (/^(\d+\.|[-*+])\s/.test(lt) || (lt === '' && i + 1 < lines.length && /^(\s+|\d+\.|[-*+]\s)/.test(lines[i + 1])) || (lt !== '' && lines[i].startsWith('  '))) {
+					i++;
+				} else {
+					break;
+				}
+			}
+			const src = lines.slice(start, i).join('\n');
+			blocks.push({
+				id: stableId(src, seen),
+				type: 'list',
+				source: src,
+				startLine: start,
+				endLine: i,
+				ordered,
+			});
+			continue;
+		}
+
+		// ── Paragraph (catch-all) ────────────────────────────────
+		{
+			const start = i;
+			while (i < lines.length && lines[i].trim() !== '' && !isBlockStart(lines[i])) {
+				i++;
+			}
+			const src = lines.slice(start, i).join('\n');
+			blocks.push({
+				id: stableId(src, seen),
+				type: 'paragraph',
+				source: src,
+				startLine: start,
+				endLine: i,
+			});
+		}
+	}
+
+	return blocks;
+}
+
+/** Check if a line starts a new block-level element */
+function isBlockStart(line: string): boolean {
+	const t = line.trimStart();
+	if (t.startsWith('#')) return true;
+	if (t.startsWith('```') || t.startsWith('~~~')) return true;
+	if (RUNE_OPEN_RE.test(t)) return true;
+	if (/^(---+|___+|\*\*\*+)\s*$/.test(t)) return true;
+	if (t.startsWith('>')) return true;
+	if (/^(\d+\.|[-*+])\s/.test(t)) return true;
+	if (/^!\[.*\]\(.*\)\s*$/.test(t)) return true;
+	return false;
+}
+
+// ── Serialization ────────────────────────────────────────────────────
+
+/** Reconstruct source text from blocks */
+export function serializeBlocks(blocks: ParsedBlock[]): string {
+	return blocks.map((b) => b.source).join('\n\n');
+}
+
+/** Rebuild a rune block's source from its attributes and inner content */
+export function rebuildRuneSource(block: RuneBlock): string {
+	const attrStr = serializeAttributes(block.attributes);
+	if (block.selfClosing) {
+		return `{% ${block.runeName}${attrStr} /%}`;
+	}
+	const inner = block.innerContent.trim();
+	if (inner) {
+		return `{% ${block.runeName}${attrStr} %}\n${inner}\n{% /${block.runeName} %}`;
+	}
+	return `{% ${block.runeName}${attrStr} %}\n\n{% /${block.runeName} %}`;
+}
+
+/** Rebuild a heading block's source from level and text */
+export function rebuildHeadingSource(block: HeadingBlock): string {
+	return '#'.repeat(block.level) + ' ' + block.text;
+}
+
+/** Rebuild a fence block's source from language and code */
+export function rebuildFenceSource(block: FenceBlock): string {
+	return '```' + block.language + '\n' + block.code + '\n```';
+}
+
+// ── Rune lookup helper ───────────────────────────────────────────────
+
+/** Build a map from rune name/alias to RuneInfo */
+export function buildRuneMap(runes: RuneInfo[]): Map<string, RuneInfo> {
+	const map = new Map<string, RuneInfo>();
+	for (const r of runes) {
+		map.set(r.name, r);
+		for (const alias of r.aliases) {
+			map.set(alias, r);
+		}
+	}
+	return map;
+}
+
+// ── Example content extraction ───────────────────────────────────────
+
+/** Extract the inner content from a full rune example string, stripping the opening/closing tags */
+export function extractRuneInner(example: string, name: string): string {
+	const lines = example.split('\n');
+	// Strip opening tag line ({% name ... %})
+	const openRe = new RegExp(`^\\{%\\s+${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b.*%\\}\\s*$`);
+	const closeRe = new RegExp(`^\\{%\\s+/${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*%\\}\\s*$`);
+
+	let start = 0;
+	let end = lines.length;
+
+	if (openRe.test(lines[0].trim())) start = 1;
+	if (end > start && closeRe.test(lines[end - 1].trim())) end -= 1;
+
+	return lines.slice(start, end).join('\n').trim();
+}
+
+/** Human-readable label for a block, used in rail labels and edit panel header */
+export function blockLabel(block: ParsedBlock): string {
+	switch (block.type) {
+		case 'heading':
+			return `H${(block as HeadingBlock).level}`;
+		case 'rune':
+			return (block as RuneBlock).runeName;
+		case 'fence': {
+			const lang = (block as FenceBlock).language;
+			return lang ? `Code (${lang})` : 'Code';
+		}
+		case 'list':
+			return (block as ListBlock).ordered ? 'Ordered List' : 'List';
+		case 'quote':
+			return 'Blockquote';
+		case 'hr':
+			return 'Divider';
+		case 'image':
+			return 'Image';
+		case 'paragraph':
+			return 'Paragraph';
+		default:
+			return block.type;
+	}
+}

package/app/src/lib/preview/block-renderer.ts

@@ -0,0 +1,74 @@
+import Markdoc from '@markdoc/markdoc';
+import { tags, nodes, serializeTree } from '@refrakt-md/runes';
+import { createTransform, renderToHtml } from '@refrakt-md/transform';
+import type { ThemeConfig, RendererNode } from '@refrakt-md/transform';
+import { baseConfig } from '@refrakt-md/theme-base';
+
+/** Runes needing external resources or runtime data — show placeholder in editor */
+const RUNTIME_ONLY_TYPES = new Set([
+	'Nav', 'NavGroup', 'NavItem',   // needs RfContext.pages
+]);
+
+/**
+ * Restore postTransform hooks that were stripped during JSON serialization.
+ * The server strips functions from the themeConfig before sending it as JSON;
+ * we merge them back from the statically-imported baseConfig.
+ */
+function restorePostTransforms(config: ThemeConfig): ThemeConfig {
+	const runes = { ...config.runes };
+	for (const [name, rune] of Object.entries(baseConfig.runes)) {
+		if (rune.postTransform && runes[name]) {
+			runes[name] = { ...runes[name], postTransform: rune.postTransform };
+		}
+	}
+	return { ...config, runes };
+}
+
+/**
+ * Render a single block's Markdoc source to HTML via the identity transform.
+ * Pure function, runs client-side, sub-millisecond per block.
+ *
+ * Returns `{ html, isComponent }`:
+ * - `html`: the rendered HTML string
+ * - `isComponent`: true if the block's root rune needs runtime resources (needs placeholder)
+ */
+export function renderBlockPreview(
+	source: string,
+	themeConfig: ThemeConfig,
+	highlightTransform?: ((tree: RendererNode) => RendererNode) | null,
+): { html: string; isComponent: boolean } {
+	const ast = Markdoc.parse(source);
+	const fullConfig = restorePostTransforms(themeConfig);
+	const renderable = Markdoc.transform(ast, {
+		tags,
+		nodes,
+		variables: { __source: source, __icons: fullConfig.icons },
+	});
+	const serialized = serializeTree(renderable) as RendererNode;
+
+	// Check if the root rune needs runtime resources (placeholder)
+	const isComponent = checkIsRuntimeOnly(serialized);
+
+	const transform = createTransform(fullConfig);
+	let transformed = transform(serialized);
+
+	// Apply syntax highlighting if available
+	if (highlightTransform) {
+		transformed = highlightTransform(transformed);
+	}
+
+	const html = renderToHtml(transformed);
+
+	return { html, isComponent };
+}
+
+/** Walk the tree to check if any root-level rune needs runtime resources */
+function checkIsRuntimeOnly(node: RendererNode): boolean {
+	if (node === null || node === undefined) return false;
+	if (typeof node === 'string' || typeof node === 'number') return false;
+	if (Array.isArray(node)) return node.some(checkIsRuntimeOnly);
+	if ('attributes' in node && node.attributes?.typeof) {
+		return RUNTIME_ONLY_TYPES.has(node.attributes.typeof);
+	}
+	return false;
+}

package/dist/css.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Bundle a CSS file by recursively inlining @import statements.
+ * Handles relative paths only (no url() or external imports).
+ */
+export declare function bundleCss(entryPath: string): string;
+//# sourceMappingURL=css.d.ts.map

package/dist/css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../src/css.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGnD"}

package/dist/css.js

@@ -0,0 +1,25 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+/**
+ * Bundle a CSS file by recursively inlining @import statements.
+ * Handles relative paths only (no url() or external imports).
+ */
+export function bundleCss(entryPath) {
+    const seen = new Set();
+    return resolveImports(entryPath, seen);
+}
+function resolveImports(filePath, seen) {
+    const abs = resolve(filePath);
+    if (seen.has(abs))
+        return '';
+    seen.add(abs);
+    if (!existsSync(abs))
+        return `/* missing: ${filePath} */`;
+    const css = readFileSync(abs, 'utf-8');
+    const dir = dirname(abs);
+    return css.replace(/@import\s+['"]([^'"]+)['"];?/g, (_match, importPath) => {
+        const resolved = resolve(dir, importPath);
+        return resolveImports(resolved, seen);
+    });
+}
+//# sourceMappingURL=css.js.map

package/dist/css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.js","sourceRoot":"","sources":["../src/css.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAE7C;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAC,SAAiB;IAC1C,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,OAAO,cAAc,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AACxC,CAAC;AAED,SAAS,cAAc,CAAC,QAAgB,EAAE,IAAiB;IAC1D,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC9B,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO,EAAE,CAAC;IAC7B,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAEd,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,eAAe,QAAQ,KAAK,CAAC;IAE1D,MAAM,GAAG,GAAG,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IACvC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAEzB,OAAO,GAAG,CAAC,OAAO,CAAC,+BAA+B,EAAE,CAAC,MAAM,EAAE,UAAkB,EAAE,EAAE;QAClF,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAC1C,OAAO,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { startEditor } from './server.js';
+export type { EditorOptions } from './server.js';
+export { bundleCss } from './css.js';
+export { renderPreviewPage, renderPreviewContent } from './preview.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { startEditor } from './server.js';
+export { bundleCss } from './css.js';
+export { renderPreviewPage, renderPreviewContent } from './preview.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC"}