@fuzdev/mdz 0.1.0 → 0.3.0

package/src/lib/mdz_helpers.ts

@@ -7,7 +7,7 @@
  * @module
  */
 
-import type {MdzNode, MdzNodeText, MdzNodeComponent, MdzNodeElement} from './mdz.js';
+import type {MdzNode, MdzNodeText, MdzNodeComponent, MdzNodeElement, MdzTableAlign} from './mdz.ts';
 
 // Character codes for performance
 /** @nodocs */
@@ -47,6 +47,10 @@ export const RIGHT_PAREN = 41; // )
 /** @nodocs */
 export const COLON = 58; // :
 /** @nodocs */
+export const PIPE = 124; // |
+/** @nodocs */
+export const BACKSLASH = 92; // \
+/** @nodocs */
 export const PERIOD = 46; // .
 /** @nodocs */
 export const COMMA = 44; // ,
@@ -95,6 +99,23 @@ export const MIN_CODEBLOCK_BACKTICKS = 3; // Code blocks require minimum 3 backt
 export const MAX_LIST_NUMBER_DIGITS = 9; // Ordered list markers cap at 9 digits (CommonMark's cap)
 /** @nodocs */
 export const MAX_HEADING_LEVEL = 6; // Headings support levels 1-6
+/**
+ * Cap on inline link/tag nesting depth. Reached at this many open
+ * `Link`/`Element`/`Component` containers, a further `[` or `<tag>` opener
+ * renders as literal text in both parsers rather than opening — a strict
+ * untrusted-content dialect's bound on pathological nesting (CommonMark
+ * permits such a limit). It bounds both the sync lexer's recursion depth (no
+ * stack overflow) and, with the failure memo, its revert re-scan work (linear
+ * instead of quadratic) on adversarial nested `[`/`<`. Deliberately far above
+ * any real content (inline nesting rarely exceeds a handful); only pathological
+ * input reaches it. Mirrored in the streaming parser so the two agree on where
+ * the cap bites. Delimiters (`**`/`_`/`~~`/`` ` ``) are uncounted: first-closer-wins
+ * keeps them from nesting deeply on their own, and mixed delimiter/link chains
+ * only deep-nest through the links, which this bounds.
+ *
+ * @nodocs
+ */
+export const MAX_INLINE_NESTING_DEPTH = 100;
 /** @nodocs */
 export const HTTPS_PREFIX_LENGTH = 8; // Length of "https://"
 /** @nodocs */
@@ -287,6 +308,126 @@ export const mdz_remap_segments = (
 	return seg.source_start + (p - seg.inner_start);
 };
 
+// -- Table helpers --
+
+/** Trim line-whitespace from both ends of a `[start, end)` span. */
+const trim_table_cell = (
+	text: string,
+	start: number,
+	end: number,
+): {start: number; end: number} => {
+	let s = start;
+	let e = end;
+	while (s < e && is_line_whitespace(text.charCodeAt(s))) s++;
+	while (e > s && is_line_whitespace(text.charCodeAt(e - 1))) e--;
+	return {start: s, end: e};
+};
+
+/**
+ * Split a table row line `[line_start, line_end)` into its cell-content spans.
+ *
+ * A valid row starts with `|` and ends — after optional trailing whitespace —
+ * with `|`, yielding at least one cell. Returns each cell's trimmed
+ * `[start, end)` source span, or `null` when the line is not a valid pipe row
+ * (no leading `|`, no trailing `|`, or zero cells).
+ *
+ * Pipe-finding honors two protections so the cell content can hold a literal
+ * `|`: an inline-code span (a `` ` `` to its matching `` ` `` on the same line —
+ * an unclosed `` ` `` is literal and protects nothing) shields the pipes inside
+ * it, and a `\|` escape is consumed as a literal pipe. The escape is
+ * table-cell-scoped — the caller's inline tokenizer performs the matching
+ * `\|` → `|` substitution; this scanner only declines to split there.
+ *
+ * @nodocs
+ */
+export const mdz_split_table_row = (
+	text: string,
+	line_start: number,
+	line_end: number,
+): Array<{start: number; end: number}> | null => {
+	if (line_start >= line_end || text.charCodeAt(line_start) !== PIPE) return null;
+	const cells: Array<{start: number; end: number}> = [];
+	let i = line_start + 1; // past the leading pipe
+	let cell_start = i;
+	while (i < line_end) {
+		const char_code = text.charCodeAt(i);
+		if (char_code === BACKTICK) {
+			// inline-code span: skip to the matching backtick; unclosed → literal
+			let close = -1;
+			for (let k = i + 1; k < line_end; k++) {
+				if (text.charCodeAt(k) === BACKTICK) {
+					close = k;
+					break;
+				}
+			}
+			if (close === -1) {
+				i++;
+			} else {
+				i = close + 1;
+			}
+			continue;
+		}
+		if (char_code === BACKSLASH) {
+			// `\|` is a literal pipe, never a delimiter
+			i += i + 1 < line_end && text.charCodeAt(i + 1) === PIPE ? 2 : 1;
+			continue;
+		}
+		if (char_code === PIPE) {
+			cells.push(trim_table_cell(text, cell_start, i));
+			i++;
+			cell_start = i;
+			continue;
+		}
+		i++;
+	}
+	// the trailing pipe is required: only whitespace may follow the last one
+	for (let k = cell_start; k < line_end; k++) {
+		if (!is_line_whitespace(text.charCodeAt(k))) return null;
+	}
+	if (cells.length === 0) return null;
+	return cells;
+};
+
+/** Classify a trimmed delimiter cell `[start, end)`; `false` when it is not a valid delimiter cell. */
+const table_delimiter_align = (text: string, start: number, end: number): MdzTableAlign | false => {
+	let i = start;
+	let j = end;
+	if (i >= j) return false;
+	const left = text.charCodeAt(i) === COLON;
+	if (left) i++;
+	const right = j > i && text.charCodeAt(j - 1) === COLON;
+	if (right) j--;
+	if (i >= j) return false; // needs at least one dash
+	for (let k = i; k < j; k++) {
+		if (text.charCodeAt(k) !== HYPHEN) return false;
+	}
+	return left && right ? 'center' : left ? 'left' : right ? 'right' : null;
+};
+
+/**
+ * Parse a table delimiter row (`| --- | :-: | ---: |`) into its per-column
+ * alignment, or `null` when the line is not a valid delimiter row. Each cell
+ * must be an optional leading `:`, one or more `-`, and an optional trailing
+ * `:`. Splits with `mdz_split_table_row` so the column count matches the header.
+ *
+ * @nodocs
+ */
+export const mdz_parse_table_delimiter = (
+	text: string,
+	line_start: number,
+	line_end: number,
+): Array<MdzTableAlign> | null => {
+	const cells = mdz_split_table_row(text, line_start, line_end);
+	if (cells === null) return null;
+	const align: Array<MdzTableAlign> = [];
+	for (const cell of cells) {
+		const a = table_delimiter_align(text, cell.start, cell.end);
+		if (a === false) return null;
+		align.push(a);
+	}
+	return align;
+};
+
 /**
  * Lowercase an ASCII letter code; passes other chars through.
  * Mirrors the `[A-Z] → [a-z]` shift without touching non-ASCII.
@@ -423,6 +564,40 @@ const PATH_CHAR_TABLE: Uint8Array = (() => {
 export const is_valid_path_char = (char_code: number): boolean =>
 	char_code < 128 && PATH_CHAR_TABLE[char_code] === 1;
 
+// Character classes for the plain-text run scanners (the hottest loops in
+// both parsers) — one table load per character instead of a comparison chain.
+// A zero class is the common case: the char can't end or interrupt a text run.
+
+/** Always ends a text run: `` ` `` `*` `_` `~` `[` `]` `<`. @nodocs */
+export const TEXT_CLASS_STOP = 1;
+/** `\n` — run handling is context-dependent (soft break, paragraph break, block lookahead). @nodocs */
+export const TEXT_CLASS_NEWLINE = 2;
+/** `h`/`H` — potential URL scheme start, needs the prefix probe. @nodocs */
+export const TEXT_CLASS_URL = 4;
+/** `/` and `.` — potential path start, needs the boundary probe. @nodocs */
+export const TEXT_CLASS_PATH = 8;
+/** `\` — a literal-pipe escape candidate inside table cells only. @nodocs */
+export const TEXT_CLASS_BACKSLASH = 16;
+
+/** @nodocs */
+export const TEXT_SCAN_CLASS: Uint8Array = (() => {
+	const t = new Uint8Array(128);
+	t[BACKTICK] = TEXT_CLASS_STOP;
+	t[ASTERISK] = TEXT_CLASS_STOP;
+	t[UNDERSCORE] = TEXT_CLASS_STOP;
+	t[TILDE] = TEXT_CLASS_STOP;
+	t[LEFT_BRACKET] = TEXT_CLASS_STOP;
+	t[RIGHT_BRACKET] = TEXT_CLASS_STOP;
+	t[LEFT_ANGLE] = TEXT_CLASS_STOP;
+	t[NEWLINE] = TEXT_CLASS_NEWLINE;
+	t[H_LOWER] = TEXT_CLASS_URL;
+	t[H_UPPER] = TEXT_CLASS_URL;
+	t[SLASH] = TEXT_CLASS_PATH;
+	t[PERIOD] = TEXT_CLASS_PATH;
+	t[BACKSLASH] = TEXT_CLASS_BACKSLASH;
+	return t;
+})();
+
 /**
  * Trim trailing punctuation from URL/path per RFC 3986 and GFM rules.
  * - Trims simple trailing: .,;:!?]
@@ -636,6 +811,52 @@ export const mdz_resolve_relative_path = (reference: string, base: string): stri
 	return segments.join('/');
 };
 
+/**
+ * How a `Link` node's `reference` should render, shared by all three renderers
+ * (`MdzNodeView`, `MdzStreamNodeView`, `mdz_to_svelte`) so the safety gate and
+ * the resolve-vs-raw classification can't drift between them.
+ * @nodocs
+ */
+export type MdzLinkRender =
+	/** Unsafe protocol — render children only, no `<a>`. */
+	| {kind: 'unsafe'}
+	/** Route/relative path — wrap in `resolve()` (needs `$app/paths`). */
+	| {kind: 'resolve'; href: string}
+	/** Internal fragment/query/relative/bare ref — raw `href`, no `resolve()`. */
+	| {kind: 'internal'; href: string}
+	/** External link — raw `href` plus `target="_blank" rel="noopener"`. */
+	| {kind: 'external'; href: string};
+
+/**
+ * Classify a `Link` reference into how it should render. Pure — no rendering,
+ * no context; `base` is the resolved base path (or `undefined`).
+ * @nodocs
+ */
+export const mdz_classify_link = (
+	reference: string,
+	link_type: 'internal' | 'external' | undefined,
+	base: string | undefined,
+): MdzLinkRender => {
+	if (!mdz_is_safe_reference(reference)) return {kind: 'unsafe'};
+	if (link_type === 'internal') {
+		if (reference.startsWith('.') && base) {
+			return {kind: 'resolve', href: mdz_resolve_relative_path(reference, base)};
+		}
+		// fragment/query/relative/bare — `resolve()` only accepts absolute paths or
+		// route ids and throws on anything else
+		if (
+			reference.startsWith('#') ||
+			reference.startsWith('?') ||
+			reference.startsWith('.') ||
+			!reference.startsWith('/')
+		) {
+			return {kind: 'internal', href: reference};
+		}
+		return {kind: 'resolve', href: reference};
+	}
+	return {kind: 'external', href: reference};
+};
+
 /**
  * Push a node into a children array, coalescing with the previous Text node.
  * Mutates `prev.content` and `prev.end` when both are Text, avoiding array growth