@fuzdev/mdz 0.2.0 → 0.4.0

package/src/lib/mdz_helpers.ts

@@ -7,7 +7,13 @@
  * @module
  */
 
-import type {MdzNode, MdzNodeText, MdzNodeComponent, MdzNodeElement, MdzTableAlign} from './mdz.ts';
+import type {
+	MdzNode,
+	MdzNodeText,
+	MdzNodeComponent,
+	MdzNodeElement,
+	MdzTableAlign
+} from './mdz.ts';
 
 // Character codes for performance
 /** @nodocs */
@@ -99,6 +105,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 */
@@ -180,7 +203,7 @@ export interface MdzBlockquotePrefix {
 export const mdz_match_blockquote_prefix = (
 	text: string,
 	i: number,
-	forced: boolean,
+	forced: boolean
 ): MdzBlockquotePrefix | 'pending' | null => {
 	let depth = 0;
 	let pos = i;
@@ -190,23 +213,23 @@ export const mdz_match_blockquote_prefix = (
 		depth++;
 		pos++;
 		if (pos >= text.length) {
-			return forced ? {depth, content_start: pos} : 'pending';
+			return forced ? { depth, content_start: pos } : 'pending';
 		}
 		const c = text.charCodeAt(pos);
 		if (c === RIGHT_ANGLE) continue; // tight run
 		if (c === SPACE) {
 			if (pos + 1 >= text.length) {
 				// could be a separator (next chunk starts with `>`) or the terminator
-				return forced ? {depth, content_start: pos + 1} : 'pending';
+				return forced ? { depth, content_start: pos + 1 } : 'pending';
 			}
 			if (text.charCodeAt(pos + 1) === RIGHT_ANGLE) {
 				pos++; // separator — continue the run at the next `>`
 				continue;
 			}
-			return {depth, content_start: pos + 1}; // terminating space
+			return { depth, content_start: pos + 1 }; // terminating space
 		}
 		if (c === NEWLINE) {
-			return {depth, content_start: pos}; // bare prefix line
+			return { depth, content_start: pos }; // bare prefix line
 		}
 		if (is_line_whitespace(c)) {
 			// tab/CR is not the marker space — valid only as tolerated trailing
@@ -216,17 +239,17 @@ export const mdz_match_blockquote_prefix = (
 				j++;
 			}
 			if (j >= text.length) {
-				return forced ? {depth, content_start: pos} : 'pending';
+				return forced ? { depth, content_start: pos } : 'pending';
 			}
 			if (text.charCodeAt(j) === NEWLINE) {
-				return {depth, content_start: pos};
+				return { depth, content_start: pos };
 			}
 			// trailing content after non-space whitespace — fall through to backtrack
 		}
 		// invalid char directly after a `>`: this `>` is content; the separator
 		// space before it (if any) re-serves as the terminator
 		if (depth >= 2 && text.charCodeAt(pos - 2) === SPACE) {
-			return {depth: depth - 1, content_start: pos - 1};
+			return { depth: depth - 1, content_start: pos - 1 };
 		}
 		return null;
 	}
@@ -243,7 +266,7 @@ export const mdz_match_blockquote_prefix = (
 export const mdz_blockquote_line_has_content = (
 	text: string,
 	content_start: number,
-	forced: boolean,
+	forced: boolean
 ): boolean | 'pending' => {
 	let i = content_start;
 	while (i < text.length && is_line_whitespace(text.charCodeAt(i))) {
@@ -274,8 +297,8 @@ export const mdz_blockquote_strip_width = (text: string, i: number): number =>
  * @nodocs
  */
 export const mdz_remap_segments = (
-	segments: Array<{inner_start: number; source_start: number}>,
-	p: number,
+	segments: Array<{ inner_start: number; source_start: number }>,
+	p: number
 ): number => {
 	let lo = 0;
 	let hi = segments.length - 1;
@@ -297,13 +320,13 @@ export const mdz_remap_segments = (
 const trim_table_cell = (
 	text: string,
 	start: number,
-	end: number,
-): {start: number; end: 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};
+	return { start: s, end: e };
 };
 
 /**
@@ -326,10 +349,10 @@ const trim_table_cell = (
 export const mdz_split_table_row = (
 	text: string,
 	line_start: number,
-	line_end: number,
-): Array<{start: number; end: number}> | null => {
+	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}> = [];
+	const cells: Array<{ start: number; end: number }> = [];
 	let i = line_start + 1; // past the leading pipe
 	let cell_start = i;
 	while (i < line_end) {
@@ -398,7 +421,7 @@ const table_delimiter_align = (text: string, start: number, end: number): MdzTab
 export const mdz_parse_table_delimiter = (
 	text: string,
 	line_start: number,
-	line_end: number,
+	line_end: number
 ): Array<MdzTableAlign> | null => {
 	const cells = mdz_split_table_row(text, line_start, line_end);
 	if (cells === null) return null;
@@ -547,6 +570,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: .,;:!?]
@@ -718,7 +775,7 @@ const VOID_ELEMENTS = new Set([
 	'meta',
 	'source',
 	'track',
-	'wbr',
+	'wbr'
 ]);
 
 /**
@@ -760,6 +817,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
@@ -804,10 +907,10 @@ export const mdz_merge_adjacent_text = (nodes: Array<MdzNode>): Array<MdzNode> =
 					type: 'Text',
 					content: pending.content + node.content,
 					start: pending.start,
-					end: node.end,
+					end: node.end
 				};
 			} else {
-				pending = {...node};
+				pending = { ...node };
 			}
 		} else {
 			if (pending) {
@@ -830,7 +933,7 @@ export const mdz_merge_adjacent_text = (nodes: Array<MdzNode>): Array<MdzNode> =
  *   or `null` if the content should be wrapped in a paragraph
  */
 export const mdz_extract_single_tag = (
-	nodes: Array<MdzNode>,
+	nodes: Array<MdzNode>
 ): MdzNodeComponent | MdzNodeElement | null => {
 	let tag: MdzNodeComponent | MdzNodeElement | null = null;