@fuzdev/mdz 0.1.0 → 0.3.0

package/src/lib/mdz_stream_parser_url.ts

@@ -24,7 +24,7 @@ import {
 	is_word_char,
 	match_url_prefix_case_insensitive,
 	mdz_trim_url_punctuation,
-} from './mdz_helpers.js';
+} from './mdz_helpers.ts';
 import {
 	type MdzStreamParserState,
 	type TryResult,
@@ -34,7 +34,7 @@ import {
 	ensure_paragraph,
 	flush_text,
 	offset,
-} from './mdz_stream_parser_state.js';
+} from './mdz_stream_parser_state.ts';
 
 const HTTPS_PREFIX = 'https://';
 const HTTP_PREFIX = 'http://';

package/src/lib/mdz_stream_state.svelte.ts

@@ -10,7 +10,8 @@
 
 import {DEV} from 'esm-env';
 
-import type {MdzNodeId, MdzNodeType, MdzOpcode} from './mdz_opcodes.js';
+import type {MdzNodeId, MdzNodeType, MdzOpcode} from './mdz_opcodes.ts';
+import type {MdzTableAlign} from './mdz.ts';
 
 /**
  * A reactive node in the stream renderer tree.
@@ -31,6 +32,10 @@ export class MdzStreamNode {
 	ordered?: boolean;
 	start_number?: number;
 	number?: number;
+	/** Per-column alignment (Table nodes). */
+	align?: Array<MdzTableAlign>;
+	/** Whether this is the header row (TableRow nodes). */
+	header?: boolean;
 
 	constructor(id: MdzNodeId, type: MdzNodeType) {
 		this.id = id;
@@ -104,6 +109,8 @@ export class MdzStreamState {
 				if (opcode.ordered !== undefined) node.ordered = opcode.ordered;
 				if (opcode.start_number !== undefined) node.start_number = opcode.start_number;
 				if (opcode.number !== undefined) node.number = opcode.number;
+				if (opcode.align !== undefined) node.align = opcode.align;
+				if (opcode.header !== undefined) node.header = opcode.header;
 				this.#attach(node);
 				this.#stack.push(opcode.id);
 				break;

package/src/lib/mdz_to_svelte.ts

@@ -8,12 +8,12 @@
  * @module
  */
 
-import {UnreachableError} from '@fuzdev/fuz_util/error.js';
-import {escape_svelte_text} from '@fuzdev/fuz_util/svelte_preprocess_helpers.js';
-import {escape_js_string} from '@fuzdev/fuz_util/string.js';
+import {UnreachableError} from '@fuzdev/fuz_util/error.ts';
+import {escape_svelte_text} from '@fuzdev/fuz_util/svelte_preprocess_helpers.ts';
+import {escape_js_string} from '@fuzdev/fuz_util/string.ts';
 
-import type {MdzNode} from './mdz.js';
-import {mdz_resolve_relative_path, mdz_is_void_element} from './mdz_helpers.js';
+import type {MdzNode, MdzNodeTableRow} from './mdz.ts';
+import {mdz_is_void_element, mdz_classify_link} from './mdz_helpers.ts';
 
 /**
  * Result of converting `MdzNode` arrays to Svelte markup.
@@ -131,26 +131,21 @@ export const mdz_to_svelte = (
 
 			case 'Link': {
 				const children_markup = render_nodes(node.children);
-				if (node.link_type === 'internal') {
-					if (node.reference.startsWith('.') && base) {
-						const resolved = mdz_resolve_relative_path(node.reference, base);
-						imports.set('resolve', {path: '$app/paths', kind: 'named'});
-						return `<a href={resolve('${escape_js_string(resolved)}')}>${children_markup}</a>`;
-					}
-					if (
-						node.reference.startsWith('#') ||
-						node.reference.startsWith('?') ||
-						node.reference.startsWith('.') ||
-						// Bare references (e.g. `foo`) aren't absolute — resolve() throws on them
-						!node.reference.startsWith('/')
-					) {
-						return `<a href={'${escape_js_string(node.reference)}'}>${children_markup}</a>`;
-					}
+				// safety gate + resolve-vs-raw classification shared with the runtime
+				// views via `mdz_classify_link`, so the three renderers can't drift
+				// (an unsafe `javascript:`/`data:` ref renders as plain children, no
+				// `<a>` — defense in depth, since `mdz_to_svelte` is a public entry
+				// callable with hand-built trees that never went through `mdz_parse`)
+				const link = mdz_classify_link(node.reference, node.link_type, base);
+				if (link.kind === 'unsafe') return children_markup;
+				if (link.kind === 'resolve') {
 					imports.set('resolve', {path: '$app/paths', kind: 'named'});
-					return `<a href={resolve('${escape_js_string(node.reference)}')}>${children_markup}</a>`;
+					return `<a href={resolve('${escape_js_string(link.href)}')}>${children_markup}</a>`;
 				}
-				// External link — matches MdzNodeView: target="_blank" rel="noopener"
-				return `<a href={'${escape_js_string(node.reference)}'} target="_blank" rel="noopener">${children_markup}</a>`;
+				if (link.kind === 'external') {
+					return `<a href={'${escape_js_string(link.href)}'} target="_blank" rel="noopener">${children_markup}</a>`;
+				}
+				return `<a href={'${escape_js_string(link.href)}'}>${children_markup}</a>`;
 			}
 
 			case 'Paragraph':
@@ -171,6 +166,37 @@ export const mdz_to_svelte = (
 			case 'Blockquote':
 				return `<blockquote>${render_nodes(node.children)}</blockquote>`;
 
+			case 'Table': {
+				const {align} = node;
+				const render_row = (row: MdzNodeTableRow, tag: 'th' | 'td'): string => {
+					let cells = '';
+					// normalize to the column count: pad short rows, ignore extra cells
+					for (let i = 0; i < align.length; i++) {
+						const a = align[i];
+						const style = a ? ` style="text-align:${a}"` : '';
+						const cell = row.children[i];
+						cells += `<${tag}${style}>${cell ? render_nodes(cell.children) : ''}</${tag}>`;
+					}
+					return `<tr>${cells}</tr>`;
+				};
+				// by grammar the header row is always first (and the only one) —
+				// read it by index and skip it in the body, mirroring the node
+				// views (a `.filter()` pair re-partitions every row; see
+				// `MdzNodeView.svelte`'s "Table rendering de-quadratified" note)
+				let out = '<table>';
+				const header_row = node.children[0]?.header ? node.children[0] : undefined;
+				if (header_row) out += '<thead>' + render_row(header_row, 'th') + '</thead>';
+				let body = '';
+				for (const row of node.children) if (!row.header) body += render_row(row, 'td');
+				if (body) out += '<tbody>' + body + '</tbody>';
+				return out + '</table>';
+			}
+
+			case 'TableRow':
+			case 'TableCell':
+				// rendered within their `Table`; never reached through `render_nodes`
+				throw new Error(`mdz: ${node.type} must render within a Table`);
+
 			case 'Hr':
 				return '<hr />';
 

package/src/lib/mdz_token_parser.ts

@@ -18,16 +18,19 @@ import type {
 	MdzNodeList,
 	MdzNodeListItem,
 	MdzNodeBlockquote,
+	MdzNodeTable,
+	MdzNodeTableRow,
+	MdzNodeTableCell,
 	MdzNodeElement,
 	MdzNodeComponent,
-} from './mdz.js';
+} from './mdz.ts';
 import {
 	has_non_whitespace,
 	mdz_extract_single_tag,
 	mdz_heading_id,
 	mdz_merge_adjacent_text,
 	mdz_push_merging_text,
-} from './mdz_helpers.js';
+} from './mdz_helpers.ts';
 import {
 	type MdzToken,
 	type MdzTokenHeadingStart,
@@ -38,7 +41,25 @@ import {
 	type MdzTokenTagSelfClose,
 	type MdzTokenListOpen,
 	type MdzTokenListItemOpen,
-} from './mdz_lexer.js';
+	type MdzTokenTableOpen,
+	type MdzTokenTableRowOpen,
+	type MdzTokenTableCellOpen,
+} from './mdz_lexer.ts';
+
+/**
+ * Whether a token type ends the current inline context — the block-boundary
+ * set shared by the delimiter-pair and link children loops (an unclosed
+ * inline never swallows block structure).
+ */
+const token_is_block_boundary = (type: MdzToken['type']): boolean =>
+	type === 'paragraph_break' ||
+	type === 'heading_start' ||
+	type === 'hr' ||
+	type === 'codeblock' ||
+	type === 'list_open' ||
+	type === 'list_item_close' ||
+	type === 'blockquote_open' ||
+	type === 'table_open';
 
 /**
  * Builds an `MdzNode[]` tree from a lexed `MdzToken[]` stream.
@@ -52,10 +73,38 @@ export class MdzTokenParser {
 		this.#tokens = tokens;
 	}
 
+	/**
+	 * Rebind to a new token stream and rewind, so one parser instance can be
+	 * reused across inputs — the streaming table path reuses one across a row's
+	 * cells via `MdzTableCellParser`.
+	 *
+	 * @nodocs
+	 */
+	reset(tokens: Array<MdzToken>): void {
+		this.#tokens = tokens;
+		this.#index = 0;
+	}
+
 	parse(): Array<MdzNode> {
 		return this.#parse_block_stream(false);
 	}
 
+	/**
+	 * Parse the entire token stream as a single inline run — used for table
+	 * cells, whose tokens come from `MdzLexer.lex_table_cell`. Adjacent text
+	 * merges as it accumulates, matching `#parse_table_cell`.
+	 *
+	 * @nodocs
+	 */
+	parse_inline_run(): Array<MdzNode> {
+		const children: Array<MdzNode> = [];
+		while (this.#index < this.#tokens.length) {
+			const node = this.#parse_inline();
+			if (node) mdz_push_merging_text(children, node);
+		}
+		return children;
+	}
+
 	/**
 	 * Parse a run of block-level tokens into nodes — the document root, or a
 	 * blockquote's contents (a quote's content is a mini-document, so both
@@ -118,6 +167,13 @@ export class MdzTokenParser {
 				continue;
 			}
 
+			if (token.type === 'table_open') {
+				const flushed = this.#flush_paragraph(paragraph_children, true);
+				if (flushed) nodes.push(flushed);
+				nodes.push(this.#parse_table());
+				continue;
+			}
+
 			if (token.type === 'paragraph_break') {
 				const flushed = this.#flush_paragraph(paragraph_children, true);
 				if (flushed) nodes.push(flushed);
@@ -147,6 +203,74 @@ export class MdzTokenParser {
 		return {type: 'Blockquote', children, start: open.start, end};
 	}
 
+	#parse_table(): MdzNodeTable {
+		const open = this.#tokens[this.#index]! as MdzTokenTableOpen;
+		this.#index++;
+
+		const rows: Array<MdzNodeTableRow> = [];
+
+		while (this.#index < this.#tokens.length) {
+			const t = this.#tokens[this.#index]!;
+			if (t.type === 'table_row_open') {
+				rows.push(this.#parse_table_row());
+				continue;
+			}
+			if (t.type === 'table_close') {
+				this.#index++;
+				break;
+			}
+			this.#index++; // skip anything unexpected (defensive)
+		}
+
+		const end = rows.length > 0 ? rows[rows.length - 1]!.end : open.end;
+		return {type: 'Table', align: open.align, children: rows, start: open.start, end};
+	}
+
+	#parse_table_row(): MdzNodeTableRow {
+		const open = this.#tokens[this.#index]! as MdzTokenTableRowOpen;
+		const header = open.header;
+		this.#index++;
+
+		const cells: Array<MdzNodeTableCell> = [];
+
+		while (this.#index < this.#tokens.length) {
+			const t = this.#tokens[this.#index]!;
+			if (t.type === 'table_cell_open') {
+				cells.push(this.#parse_table_cell());
+				continue;
+			}
+			if (t.type === 'table_row_close') {
+				this.#index++;
+				return {type: 'TableRow', header, children: cells, start: open.start, end: t.end};
+			}
+			this.#index++; // skip anything unexpected (defensive)
+		}
+
+		const end = cells.length > 0 ? cells[cells.length - 1]!.end : open.end;
+		return {type: 'TableRow', header, children: cells, start: open.start, end};
+	}
+
+	#parse_table_cell(): MdzNodeTableCell {
+		const open = this.#tokens[this.#index]! as MdzTokenTableCellOpen;
+		const start = open.start;
+		this.#index++;
+
+		const children: Array<MdzNode> = [];
+
+		while (this.#index < this.#tokens.length) {
+			const t = this.#tokens[this.#index]!;
+			if (t.type === 'table_cell_close') {
+				this.#index++;
+				return {type: 'TableCell', children, start, end: t.end};
+			}
+			const node = this.#parse_inline();
+			if (node) mdz_push_merging_text(children, node);
+		}
+
+		const end = children.length > 0 ? children[children.length - 1]!.end : open.end;
+		return {type: 'TableCell', children, start, end};
+	}
+
 	#parse_heading(): MdzNodeHeading {
 		const token = this.#tokens[this.#index]! as MdzTokenHeadingStart;
 		const start = token.start;
@@ -238,6 +362,12 @@ export class MdzTokenParser {
 				children.push(this.#parse_blockquote());
 				continue;
 			}
+			if (t.type === 'table_open') {
+				flush();
+				in_paragraph = false;
+				children.push(this.#parse_table());
+				continue;
+			}
 			if (t.type === 'codeblock') {
 				flush();
 				in_paragraph = false;
@@ -375,15 +505,7 @@ export class MdzTokenParser {
 				this.#index++;
 				return {type: node_type, children, start, end: t.end};
 			}
-			if (
-				t.type === 'paragraph_break' ||
-				t.type === 'heading_start' ||
-				t.type === 'hr' ||
-				t.type === 'codeblock' ||
-				t.type === 'list_open' ||
-				t.type === 'list_item_close' ||
-				t.type === 'blockquote_open'
-			) {
+			if (token_is_block_boundary(t.type)) {
 				break;
 			}
 			const node = this.#parse_inline();
@@ -423,15 +545,7 @@ export class MdzTokenParser {
 				// No link_ref - treat as text
 				return {type: 'Text', content: '[', start, end: start + 1};
 			}
-			if (
-				t.type === 'paragraph_break' ||
-				t.type === 'heading_start' ||
-				t.type === 'hr' ||
-				t.type === 'codeblock' ||
-				t.type === 'list_open' ||
-				t.type === 'list_item_close' ||
-				t.type === 'blockquote_open'
-			) {
+			if (token_is_block_boundary(t.type)) {
 				break;
 			}
 			const node = this.#parse_inline();

package/src/lib/svelte_preprocess_mdz.ts

@@ -18,7 +18,7 @@ import type {ImportDeclaration, VariableDeclaration} from 'estree';
 import {parse, type PreprocessorGroup, type AST} from 'svelte/compiler';
 import MagicString from 'magic-string';
 import {walk} from 'zimmerframe';
-import {should_exclude_path} from '@fuzdev/fuz_util/path.js';
+import {should_exclude_path} from '@fuzdev/fuz_util/path.ts';
 import {
 	find_attribute,
 	extract_static_string,
@@ -34,10 +34,10 @@ import {
 	handle_preprocess_error,
 	type PreprocessImportInfo,
 	type ResolvedComponentImport,
-} from '@fuzdev/fuz_util/svelte_preprocess_helpers.js';
+} from '@fuzdev/fuz_util/svelte_preprocess_helpers.ts';
 
-import {mdz_parse} from './mdz.js';
-import {mdz_to_svelte} from './mdz_to_svelte.js';
+import {mdz_parse} from './mdz.ts';
+import {mdz_to_svelte, type MdzToSvelteResult} from './mdz_to_svelte.ts';
 
 /**
  * An estree `ImportDeclaration` augmented with Svelte's position data.
@@ -296,6 +296,33 @@ const collect_consumed_bindings = (
 	return consumed;
 };
 
+/**
+ * Parse a static mdz string and render it to Svelte markup. Returns `null` to
+ * leave the usage for the runtime — either the content raised a parse error
+ * (reported via `on_error`) or it contains unconfigured tags (which the
+ * precompiler emits nothing for; the runtime renders the fallback chrome).
+ */
+const render_static_mdz = (
+	content: string,
+	base: string | undefined,
+	context: FindMdzUsagesContext,
+): MdzToSvelteResult | null => {
+	let result: MdzToSvelteResult;
+	try {
+		result = mdz_to_svelte(mdz_parse(content), {
+			components: context.components,
+			elements: context.elements,
+			base,
+			code_component_import: context.code_component_import,
+			codeblock_component_import: context.codeblock_component_import,
+		});
+	} catch (error) {
+		handle_preprocess_error(error, '[fuz-mdz]', context.filename, context.on_error);
+		return null;
+	}
+	return result.has_unconfigured_tags ? null : result;
+};
+
 /**
  * Walks the AST to find `Mdz` component usages with static `content` props
  * and generates transformations to replace them with `MdzPrecompiled` children.
@@ -346,24 +373,8 @@ const find_mdz_usages = (
 			// Extract static string value
 			const content_value = extract_static_string(content_attr.value, context.bindings);
 			if (content_value !== null) {
-				// Parse mdz content and render to Svelte markup
-				let result;
-				try {
-					const nodes = mdz_parse(content_value);
-					result = mdz_to_svelte(nodes, {
-						components: context.components,
-						elements: context.elements,
-						base,
-						code_component_import: context.code_component_import,
-						codeblock_component_import: context.codeblock_component_import,
-					});
-				} catch (error) {
-					handle_preprocess_error(error, '[fuz-mdz]', context.filename, context.on_error);
-					return;
-				}
-
-				// If content has unconfigured tags, skip this usage (fall back to runtime)
-				if (result.has_unconfigured_tags) return;
+				const result = render_static_mdz(content_value, base, context);
+				if (result === null) return; // parse error or unconfigured tags — leave for runtime
 
 				const consumed = collect_consumed_bindings(content_attr.value, context.bindings);
 				const replacement = build_replacement(node, exclude_attrs, result.markup, context.source);
@@ -390,22 +401,10 @@ const find_mdz_usages = (
 			// Parse and render each branch
 			const branch_results: Array<{markup: string; imports: Map<string, PreprocessImportInfo>}> =
 				[];
-			try {
-				for (const branch of chain) {
-					const nodes = mdz_parse(branch.value);
-					const result = mdz_to_svelte(nodes, {
-						components: context.components,
-						elements: context.elements,
-						base,
-						code_component_import: context.code_component_import,
-						codeblock_component_import: context.codeblock_component_import,
-					});
-					if (result.has_unconfigured_tags) return;
-					branch_results.push({markup: result.markup, imports: result.imports});
-				}
-			} catch (error) {
-				handle_preprocess_error(error, '[fuz-mdz]', context.filename, context.on_error);
-				return;
+			for (const branch of chain) {
+				const result = render_static_mdz(branch.value, base, context);
+				if (result === null) return; // parse error or unconfigured tags — leave for runtime
+				branch_results.push({markup: result.markup, imports: result.imports});
 			}
 
 			// Build {#if}/{:else if}/{:else} markup

package/src/lib/tsdoc_mdz.ts

@@ -8,7 +8,7 @@
  * @module
  */
 
-import {mdz_is_url} from './mdz_helpers.js';
+import {mdz_is_url} from './mdz_helpers.ts';
 
 /** Format a reference as mdz: URLs pass through, identifiers get backticks. */
 const format_reference = (ref: string): string => (mdz_is_url(ref) ? ref : `\`${ref}\``);