@fuzdev/mdz 0.3.0 → 0.5.0

package/src/lib/mdz_stream_parser_link.ts

@@ -5,9 +5,13 @@
  * @module
  */
 
-import type {MdzNodeTypeContainer} from './mdz_opcodes.ts';
+import type { MdzNodeTypeContainer } from './mdz_opcodes.ts';
+import type { MdzAttribute } from './mdz.ts';
 import {
 	A_UPPER,
+	APOSTROPHE,
+	DOUBLE_QUOTE,
+	EQUALS,
 	LEFT_BRACKET,
 	LEFT_PAREN,
 	MAX_INLINE_NESTING_DEPTH,
@@ -21,7 +25,7 @@ import {
 	is_tag_name_char,
 	is_valid_path_char,
 	mdz_is_safe_reference,
-	mdz_is_url,
+	mdz_is_url
 } from './mdz_helpers.ts';
 import {
 	type MdzStreamParserState,
@@ -36,10 +40,10 @@ import {
 	offset,
 	pop_stack_entry,
 	push_stack_entry,
-	revert_above,
+	revert_above
 } from './mdz_stream_parser_state.ts';
-import {consume_delimiter_as_text} from './mdz_stream_parser_text.ts';
-import {mdz_debug_work} from './mdz_debug_work.ts';
+import { consume_delimiter_as_text } from './mdz_stream_parser_text.ts';
+import { mdz_debug_work } from './mdz_debug_work.ts';
 
 // -- Links --
 
@@ -57,7 +61,7 @@ export const try_link_open = (state: MdzStreamParserState): boolean => {
 
 	const id = alloc_id(state);
 	const link_start = offset(state);
-	emit(state, {type: 'open', id, node_type: 'Link', start: link_start});
+	emit(state, { type: 'open', id, node_type: 'Link', start: link_start });
 	push_stack_entry(state, id, 'Link', link_start, '[');
 	state.active_text_id = null;
 	state.pos++;
@@ -76,12 +80,12 @@ export const try_link_open = (state: MdzStreamParserState): boolean => {
 export const abort_link_to_text = (
 	state: MdzStreamParserState,
 	link_stack_idx: number,
-	bracket_pos: number,
+	bracket_pos: number
 ): void => {
 	flush_text(state);
 	revert_above(state, link_stack_idx);
 	const entry = pop_stack_entry(state);
-	emit(state, {type: 'revert', id: entry.id, replacement_text: '[', start: entry.start});
+	emit(state, { type: 'revert', id: entry.id, replacement_text: '[', start: entry.start });
 	state.active_text_id = null;
 	accumulate_text(state, ']', offset(state, bracket_pos));
 	state.pos = bracket_pos + 1;
@@ -164,7 +168,7 @@ export const try_complete_link = (state: MdzStreamParserState, link_stack_idx: n
 		id: entry.id,
 		end: offset(state, i + 1),
 		reference,
-		link_type,
+		link_type
 	});
 	state.active_text_id = null;
 	state.pos = i + 1;
@@ -211,11 +215,77 @@ export const try_tag_open = (state: MdzStreamParserState): TryResult => {
 
 	const name = state.buffer.slice(name_start, i);
 
-	// skip whitespace
-	while (i < state.buffer.length && state.buffer.charCodeAt(i) === SPACE) {
-		i++;
+	// Attribute loop: consume space-separated attributes until `/>` or `>`.
+	// This widens the held-tag-open rescan surface (the TODO above) with the
+	// attribute/value text — still line-bounded, since a newline anywhere aborts
+	// the whole tag (`not_match`). Every buffer-end point holds (`need_more`) so
+	// the same tree is produced regardless of where feeds split. The quoted-value
+	// terminator search reuses `buffer_index_of` (memoized, append-aware) so a
+	// long streamed value doesn't rescan quadratically across held retries,
+	// matching `try_complete_link`.
+	const attributes: Array<MdzAttribute> = [];
+	const seen = new Set<string>();
+	for (;;) {
+		// skip a run of literal spaces only (tabs/newlines are not SPACE)
+		let had_space = false;
+		while (i < state.buffer.length && state.buffer.charCodeAt(i) === SPACE) {
+			i++;
+			had_space = true;
+		}
+		if (i >= state.buffer.length) return 'need_more';
+
+		const c = state.buffer.charCodeAt(i);
+		// `/>` or `>` ends the open tag — break to the existing self-close / commit
+		if (c === SLASH || c === RIGHT_ANGLE) break;
+		// otherwise an attribute name must follow, space-separated from what
+		// precedes it (`<a x="1"y="2">` — `y` abuts the closing quote — reverts)
+		if (!is_letter(c)) return 'not_match';
+		if (!had_space) return 'not_match';
+
+		// collect the attribute name (same grammar as tag names)
+		const attr_start = i;
+		i++; // first char already passed is_letter
+		while (i < state.buffer.length && is_tag_name_char(state.buffer.charCodeAt(i))) {
+			i++;
+		}
+		if (i >= state.buffer.length) return 'need_more'; // mid-name — could still grow
+		const attr_name = state.buffer.slice(attr_start, i);
+		// duplicate names are ambiguous (Svelte compile-errors) → literal tag
+		if (seen.has(attr_name)) return 'not_match';
+		seen.add(attr_name);
+
+		let value: string | true = true; // bare name is boolean `true`
+		if (state.buffer.charCodeAt(i) === EQUALS) {
+			i++; // consume =
+			if (i >= state.buffer.length) return 'need_more'; // nothing after `=` yet
+			// the value must be immediately quoted — no space, no `{`, no unquoted
+			const quote_code = state.buffer.charCodeAt(i);
+			if (quote_code !== DOUBLE_QUOTE && quote_code !== APOSTROPHE) return 'not_match';
+			i++; // consume opening quote
+			const value_start = i;
+			// find the matching quote and the next newline via the memoized,
+			// append-aware search; a `>` inside the value is content, consumed
+			// atomically here so a `</Name>`-shaped substring never reaches
+			// `try_close_tag`
+			const quote_str = quote_code === DOUBLE_QUOTE ? '"' : "'";
+			const q = buffer_index_of(state, quote_str, value_start);
+			const n = buffer_index_of(state, '\n', value_start);
+			if (q !== -1 && (n === -1 || q < n)) {
+				value = state.buffer.slice(value_start, q);
+				i = q + 1; // past the closing quote
+			} else if (n !== -1 && (q === -1 || n < q)) {
+				return 'not_match'; // newline inside the value → literal tag
+			} else {
+				return 'need_more'; // neither found yet — unterminated so far, hold
+			}
+		}
+		attributes.push({
+			name: attr_name,
+			value,
+			start: offset(state, attr_start),
+			end: offset(state, i)
+		});
 	}
-	if (i >= state.buffer.length) return 'need_more';
 
 	// check for self-closing />
 	if (state.buffer.charCodeAt(i) === SLASH && i + 1 >= state.buffer.length) {
@@ -230,8 +300,8 @@ export const try_tag_open = (state: MdzStreamParserState): TryResult => {
 		ensure_paragraph(state);
 		const id = alloc_id(state);
 		const tag_start = offset(state, start);
-		emit(state, {type: 'open', id, node_type, start: tag_start, name});
-		emit(state, {type: 'close', id, end: offset(state, i + 2)});
+		emit(state, { type: 'open', id, node_type, start: tag_start, name, attributes });
+		emit(state, { type: 'close', id, end: offset(state, i + 2) });
 		state.active_text_id = null;
 		state.pos = i + 2;
 		state.column += i + 2 - start;
@@ -253,8 +323,8 @@ export const try_tag_open = (state: MdzStreamParserState): TryResult => {
 	ensure_paragraph(state);
 	const id = alloc_id(state);
 	const tag_start = offset(state, start);
-	const delimiter = state.buffer.slice(start, i); // e.g., "<Alert>"
-	emit(state, {type: 'open', id, node_type, start: tag_start, name});
+	const delimiter = state.buffer.slice(start, i); // e.g., "<Alert>" or "<Alert x="1">"
+	emit(state, { type: 'open', id, node_type, start: tag_start, name, attributes });
 	push_stack_entry(state, id, node_type, tag_start, delimiter, name);
 	state.active_text_id = null;
 	state.pos = i;
@@ -307,7 +377,7 @@ export const try_close_tag = (state: MdzStreamParserState): TryResult => {
 	flush_text(state);
 	revert_above(state, found_idx);
 	const entry = pop_stack_entry(state);
-	emit(state, {type: 'close', id: entry.id, end: offset(state, i)});
+	emit(state, { type: 'close', id: entry.id, end: offset(state, i) });
 	state.active_text_id = null;
 	state.column += i - state.pos;
 	state.pos = i;

package/src/lib/mdz_stream_parser_list.ts

@@ -27,9 +27,9 @@ import {
 	ZERO,
 	is_line_whitespace,
 	mdz_match_blockquote_prefix,
-	mdz_blockquote_line_has_content,
+	mdz_blockquote_line_has_content
 } from './mdz_helpers.ts';
-import {match_table_in_item_head, open_table_in_item} from './mdz_stream_parser_table.ts';
+import { match_table_in_item_head, open_table_in_item } from './mdz_stream_parser_table.ts';
 import {
 	type MdzStreamParserState,
 	type TryResult,
@@ -44,7 +44,7 @@ import {
 	extend_accumulated_end,
 	flush_text,
 	offset,
-	push_stack_entry,
+	push_stack_entry
 } from './mdz_stream_parser_state.ts';
 
 /**
@@ -76,7 +76,7 @@ export interface MdzStreamListMarker {
 const rest_is_blank = (
 	state: MdzStreamParserState,
 	from: number,
-	forced: boolean,
+	forced: boolean
 ): boolean | 'pending' => {
 	let i = from;
 	while (i < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(i))) {
@@ -98,9 +98,9 @@ const rest_is_blank = (
 export const match_list_marker = (
 	state: MdzStreamParserState,
 	i: number,
-	forced: boolean,
+	forced: boolean
 ): MdzStreamListMarker | 'pending' | null => {
-	const {buffer} = state;
+	const { buffer } = state;
 	const c = buffer.charCodeAt(i);
 	if (c === HYPHEN) {
 		const after = i + 1;
@@ -113,7 +113,7 @@ export const match_list_marker = (
 				start: i,
 				marker_end: after,
 				content_start: after,
-				empty: true,
+				empty: true
 			};
 		}
 		// in bounds: `blank === false` means the scan found a char at or past `after`
@@ -121,7 +121,7 @@ export const match_list_marker = (
 		const content_start = after + 1;
 		const empty = rest_is_blank(state, content_start, forced);
 		if (empty === 'pending') return 'pending';
-		return {ordered: false, number: 0, start: i, marker_end: after, content_start, empty};
+		return { ordered: false, number: 0, start: i, marker_end: after, content_start, empty };
 	}
 	if (c >= ZERO && c <= NINE) {
 		let j = i + 1;
@@ -142,7 +142,7 @@ export const match_list_marker = (
 				start: i,
 				marker_end: after,
 				content_start: after,
-				empty: true,
+				empty: true
 			};
 		}
 		// in bounds: `blank === false` means the scan found a char at or past `after`
@@ -150,7 +150,7 @@ export const match_list_marker = (
 		const content_start = after + 1;
 		const empty = rest_is_blank(state, content_start, forced);
 		if (empty === 'pending') return 'pending';
-		return {ordered: true, number, start: i, marker_end: after, content_start, empty};
+		return { ordered: true, number, start: i, marker_end: after, content_start, empty };
 	}
 	return null;
 };
@@ -179,9 +179,9 @@ export interface MdzStreamFenceOpener {
 export const match_fence_opener = (
 	state: MdzStreamParserState,
 	i: number,
-	forced: boolean,
+	forced: boolean
 ): MdzStreamFenceOpener | 'pending' | null => {
-	const {buffer} = state;
+	const { buffer } = state;
 	let j = i;
 	let count = 0;
 	while (j < buffer.length && buffer.charCodeAt(j) === BACKTICK) {
@@ -202,7 +202,7 @@ export const match_fence_opener = (
 	}
 	if (j >= buffer.length) return forced ? null : 'pending'; // the opener needs its newline
 	if (buffer.charCodeAt(j) !== NEWLINE) return null;
-	return {backtick_count: count, lang, content_start: j + 1};
+	return { backtick_count: count, lang, content_start: j + 1 };
 };
 
 /** Emit a `ListItem` open for `marker` and push its frame. */
@@ -210,9 +210,9 @@ const open_list_item = (state: MdzStreamParserState, marker: MdzStreamListMarker
 	const id = alloc_id(state);
 	const start = offset(state, marker.start);
 	if (marker.ordered) {
-		emit(state, {type: 'open', id, node_type: 'ListItem', start, number: marker.number});
+		emit(state, { type: 'open', id, node_type: 'ListItem', start, number: marker.number });
 	} else {
-		emit(state, {type: 'open', id, node_type: 'ListItem', start});
+		emit(state, { type: 'open', id, node_type: 'ListItem', start });
 	}
 	push_stack_entry(state, id, 'ListItem', start);
 	if (marker.empty) {
@@ -226,7 +226,7 @@ const open_list_item = (state: MdzStreamParserState, marker: MdzStreamListMarker
 const open_list_level = (
 	state: MdzStreamParserState,
 	indent: number,
-	marker: MdzStreamListMarker,
+	marker: MdzStreamListMarker
 ): void => {
 	const id = alloc_id(state);
 	const start = offset(state, marker.start);
@@ -237,14 +237,14 @@ const open_list_level = (
 			node_type: 'List',
 			start,
 			ordered: true,
-			start_number: marker.number,
+			start_number: marker.number
 		});
 	} else {
-		emit(state, {type: 'open', id, node_type: 'List', start, ordered: false});
+		emit(state, { type: 'open', id, node_type: 'List', start, ordered: false });
 	}
 	push_stack_entry(state, id, 'List', start);
 	open_list_item(state, marker);
-	state.list_levels.push({indent, ordered: marker.ordered});
+	state.list_levels.push({ indent, ordered: marker.ordered });
 };
 
 /**
@@ -256,7 +256,7 @@ const open_list_level = (
 const begin_item_run = (
 	state: MdzStreamParserState,
 	marker: MdzStreamListMarker,
-	line_start: number,
+	line_start: number
 ): void => {
 	let i = marker.content_start;
 	while (i < state.buffer.length && is_line_whitespace(state.buffer.charCodeAt(i))) {
@@ -289,7 +289,7 @@ const list_continuation_target = (state: MdzStreamParserState, indent: number):
 const continue_run = (
 	state: MdzStreamParserState,
 	nl_pos: number,
-	content_pos: number,
+	content_pos: number
 ): boolean => {
 	accumulate_text(state, '\n', offset(state, nl_pos));
 	extend_accumulated_end(state, offset(state, content_pos));
@@ -352,9 +352,9 @@ export const try_list_start = (state: MdzStreamParserState, forced: boolean): Tr
  */
 export const process_list_line = (
 	state: MdzStreamParserState,
-	forced: boolean,
+	forced: boolean
 ): boolean | 'blockquote' => {
-	const {buffer} = state;
+	const { buffer } = state;
 	const nl_pos = state.pos;
 	const line_start = nl_pos + 1;
 	let j = line_start;
@@ -462,13 +462,19 @@ export const process_list_line = (
 				}
 				const id = alloc_id(state);
 				const cb_start = offset(state, j);
-				emit(state, {type: 'open', id, node_type: 'Codeblock', start: cb_start, lang: fence.lang});
+				emit(state, {
+					type: 'open',
+					id,
+					node_type: 'Codeblock',
+					start: cb_start,
+					lang: fence.lang
+				});
 				state.codeblock = {
 					id,
 					backtick_count: fence.backtick_count,
 					text_id: null,
 					fence_indent: indent,
-					start: cb_start,
+					start: cb_start
 				};
 				state.active_text_id = null;
 				state.pos = fence.content_start;

package/src/lib/mdz_stream_parser_state.ts

@@ -8,10 +8,10 @@
  * @module
  */
 
-import type {MdzNodeTypeContainer, MdzNodeId, MdzOpcode} from './mdz_opcodes.ts';
-import type {MdzTableCellParser} from './mdz.ts';
-import {NEWLINE, has_non_whitespace, mdz_heading_id_from_text} from './mdz_helpers.ts';
-import {mdz_debug_work} from './mdz_debug_work.ts';
+import type { MdzNodeTypeContainer, MdzNodeId, MdzOpcode } from './mdz_opcodes.ts';
+import type { MdzTableCellParser } from './mdz.ts';
+import { NEWLINE, has_non_whitespace, mdz_heading_id_from_text } from './mdz_helpers.ts';
+import { mdz_debug_work } from './mdz_debug_work.ts';
 
 /**
  * Tri-state result for `try_*` parser handlers.
@@ -114,7 +114,7 @@ export interface MdzBlockquoteState {
 	 * offsets — one per quote line; the line's content and terminating
 	 * newline are contiguous in both coordinate spaces.
 	 */
-	segments: Array<{inner_start: number; source_start: number}>;
+	segments: Array<{ inner_start: number; source_start: number }>;
 	/** Total bytes fed to the inner document so far. */
 	inner_len: number;
 	/**
@@ -218,7 +218,7 @@ export interface MdzStreamParserState {
 	 * a dedent to that indent ends the table, returning control to the list).
 	 * `cell_parser` is the table's shared cell parser, rebound per row.
 	 */
-	table: {id: MdzNodeId; item_indent: number | null; cell_parser: MdzTableCellParser} | null;
+	table: { id: MdzNodeId; item_indent: number | null; cell_parser: MdzTableCellParser } | null;
 	/**
 	 * Whether the innermost open ListItem's first inline run is current.
 	 * Content then flows directly into the ListItem frame — the sync AST
@@ -343,7 +343,7 @@ export const create_state = (): MdzStreamParserState => ({
 	last_empty_item_end: 0,
 	base_offset: 0,
 	search_memo: null,
-	open_counts: {Bold: 0, Italic: 0, Strikethrough: 0, Link: 0},
+	open_counts: { Bold: 0, Italic: 0, Strikethrough: 0, Link: 0 },
 	open_link_tag_depth: 0,
 	open_tag_counts: null,
 	in_heading: false,
@@ -357,7 +357,7 @@ export const create_state = (): MdzStreamParserState => ({
 	paragraph_stack_idx: -1,
 	last_text_id: null,
 	last_text_ended_with_newline: false,
-	last_text_was_singleton_newline: false,
+	last_text_was_singleton_newline: false
 });
 
 /** @nodocs */
@@ -377,7 +377,7 @@ export const push_stack_entry = (
 	node_type: MdzNodeTypeContainer,
 	start: number,
 	delimiter: string = '',
-	tag_name?: string,
+	tag_name?: string
 ): void => {
 	state.stack.push({
 		id,
@@ -386,7 +386,7 @@ export const push_stack_entry = (
 		tag_name,
 		has_children: false,
 		has_non_whitespace_content: false,
-		start,
+		start
 	});
 	if (node_type === 'Paragraph') {
 		state.paragraph_stack_idx = state.stack.length - 1;
@@ -412,7 +412,7 @@ export const push_stack_entry = (
 const bump_open_count = (
 	state: MdzStreamParserState,
 	node_type: MdzNodeTypeContainer,
-	delta: number,
+	delta: number
 ): void => {
 	const counts = state.open_counts;
 	if (node_type === 'Bold') counts.Bold += delta;
@@ -502,7 +502,7 @@ const memo_index_of = (
 	state: MdzStreamParserState,
 	memo: BufferSearchMemo,
 	needle: string,
-	from: number,
+	from: number
 ): number => {
 	const global_from = state.base_offset + from;
 	const global_end = state.base_offset + state.buffer.length;
@@ -548,13 +548,13 @@ const memo_index_of = (
 export const buffer_index_of = (
 	state: MdzStreamParserState,
 	needle: string,
-	from: number,
+	from: number
 ): number => {
 	const map = (state.search_memo ??= new Map());
 	let memo = map.get(needle);
 	if (memo === undefined) {
 		// "scanned [0, 0), found nothing" — memo_index_of handles the full scan
-		memo = {from: 0, result: -1, searched_to: 0};
+		memo = { from: 0, result: -1, searched_to: 0 };
 		map.set(needle, memo);
 	}
 	return memo_index_of(state, memo, needle, from);
@@ -642,7 +642,7 @@ export const emit = (state: MdzStreamParserState, op: MdzOpcode): void => {
 export const accumulate_text = (
 	state: MdzStreamParserState,
 	text: string,
-	start_offset: number,
+	start_offset: number
 ): void => {
 	if (state.accumulated_text.length === 0) {
 		state.accumulated_text_start = start_offset;
@@ -678,7 +678,7 @@ export const flush_text = (state: MdzStreamParserState): void => {
 			type: 'append_text',
 			id: state.active_text_id,
 			content: state.accumulated_text,
-			end: state.accumulated_text_end,
+			end: state.accumulated_text_end
 		});
 	} else {
 		ensure_paragraph(state);
@@ -690,7 +690,7 @@ export const flush_text = (state: MdzStreamParserState): void => {
 			content: state.accumulated_text,
 			text_type: 'Text',
 			start,
-			end: state.accumulated_text_end,
+			end: state.accumulated_text_end
 		});
 		state.active_text_id = id;
 	}
@@ -709,7 +709,7 @@ export const ensure_paragraph = (state: MdzStreamParserState): void => {
 	if (state.in_heading || state.in_paragraph || state.in_list_item_run) return;
 	const id = alloc_id(state);
 	const start = offset(state);
-	emit(state, {type: 'open', id, node_type: 'Paragraph', start});
+	emit(state, { type: 'open', id, node_type: 'Paragraph', start });
 	push_stack_entry(state, id, 'Paragraph', start);
 	state.in_paragraph = true;
 };
@@ -769,7 +769,7 @@ export const revert_above = (state: MdzStreamParserState, target_idx: number): v
 			type: 'revert',
 			id: entry.id,
 			replacement_text: entry.delimiter,
-			start: entry.start,
+			start: entry.start
 		});
 	}
 	state.active_text_id = null;
@@ -820,7 +820,7 @@ export const revert_failed_close = (state: MdzStreamParserState, stack_idx: numb
 		type: 'revert',
 		id: entry.id,
 		replacement_text: entry.delimiter,
-		start: entry.start,
+		start: entry.start
 	});
 	// structural opcode seals the prior text run (mirrors `emit`)
 	seal_text_run(state);
@@ -852,7 +852,7 @@ export const trim_trailing_newline = (state: MdzStreamParserState): void => {
 	}
 	if (state.last_text_id === null || !state.last_text_ended_with_newline) return;
 	// emit trim opcode; consumer adjusts content and removes empty nodes
-	emit(state, {type: 'trim_text', id: state.last_text_id, count: 1});
+	emit(state, { type: 'trim_text', id: state.last_text_id, count: 1 });
 	// if this trim empties a singleton text node, clear active_text_id so
 	// subsequent content doesn't merge into a deleted node via append_text
 	if (state.last_text_was_singleton_newline) {
@@ -879,8 +879,8 @@ export const close_paragraph = (state: MdzStreamParserState): void => {
 			emit(
 				state,
 				discard
-					? {type: 'close', id: entry.id, end: offset(state), discard: true}
-					: {type: 'close', id: entry.id, end: offset(state)},
+					? { type: 'close', id: entry.id, end: offset(state), discard: true }
+					: { type: 'close', id: entry.id, end: offset(state) }
 			);
 			state.active_text_id = null;
 			state.in_paragraph = false;
@@ -913,7 +913,7 @@ export const close_heading = (state: MdzStreamParserState): void => {
 	const heading_id = mdz_heading_id_from_text(heading_text);
 	// the heading is now the top of the stack
 	const entry = pop_stack_entry(state);
-	emit(state, {type: 'close', id: entry.id, end: offset(state), heading_id});
+	emit(state, { type: 'close', id: entry.id, end: offset(state), heading_id });
 	state.active_text_id = null;
 };
 
@@ -933,7 +933,7 @@ export const close_codeblock_at_eof = (state: MdzStreamParserState): void => {
 	if (state.codeblock.fence_indent === 0) {
 		trim_trailing_newline(state);
 	}
-	emit(state, {type: 'close', id: state.codeblock.id, end: offset(state)});
+	emit(state, { type: 'close', id: state.codeblock.id, end: offset(state) });
 	state.codeblock = null;
 };
 
@@ -987,7 +987,7 @@ export const close_list_item = (state: MdzStreamParserState): void => {
 	emit(state, {
 		type: 'close',
 		id: entry.id,
-		end: entry.has_children ? offset(state) : state.last_empty_item_end,
+		end: entry.has_children ? offset(state) : state.last_empty_item_end
 	});
 	state.active_text_id = null;
 };
@@ -1000,7 +1000,7 @@ export const close_list_item = (state: MdzStreamParserState): void => {
 export const close_list_level = (state: MdzStreamParserState): void => {
 	close_list_item(state);
 	const entry = pop_stack_entry(state);
-	emit(state, {type: 'close', id: entry.id, end: offset(state)});
+	emit(state, { type: 'close', id: entry.id, end: offset(state) });
 	state.list_levels.pop();
 };