// Copyright 2026 The V Language. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module markdown

import encoding.html as ehtml

// parse_inline parses src as inline content and returns a slice of inline nodes.
pub fn parse_inline(src string, opts Options, ref_map map[string]LinkRef) []&Node {
	mut p := InlineParser{
		src:     src
		opts:    opts
		ref_map: ref_map
	}
	return p.parse()
}

// InlineParser parses inline markdown content.
struct InlineParser {
	opts    Options
	ref_map map[string]LinkRef
mut:
	src string
	pos int
}

struct EmphDelim {
mut:
	node_idx  int
	ch        u8
	length    int
	orig_len  int
	can_open  bool
	can_close bool
	active    bool = true
}

@[inline]
fn rune_at_or_space(s string, pos int) rune {
	if pos < 0 || pos >= s.len {
		return ` `
	}
	char_len := utf8_char_len(s[pos])
	if char_len <= 0 || pos + char_len > s.len {
		return rune(s[pos])
	}
	return s[pos..pos + char_len].runes()[0]
}

@[inline]
fn prev_rune_or_space(s string, pos int) rune {
	if pos <= 0 {
		return ` `
	}
	mut i := pos - 1
	for i > 0 && (s[i] & u8(0xC0)) == u8(0x80) {
		i--
	}
	return rune_at_or_space(s, i)
}

// parse parses the full inline source and returns a node slice.
fn (mut p InlineParser) parse() []&Node {
	mut result := []&Node{}
	mut delims := []EmphDelim{}
	for p.pos < p.src.len {
		if p.src[p.pos] == `*` || p.src[p.pos] == `_` {
			start := p.pos
			ch := p.src[p.pos]
			for p.pos < p.src.len && p.src[p.pos] == ch {
				p.pos++
			}
			run := p.src[start..p.pos]
			before := prev_rune_or_space(p.src, start)
			after := rune_at_or_space(p.src, p.pos)
			can_open := can_open_emphasis(ch, before, after)
			can_close := can_close_emphasis(ch, before, after)
			result << text_node(run)
			if can_open || can_close {
				delims << EmphDelim{
					node_idx:  result.len - 1
					ch:        ch
					length:    run.len
					orig_len:  run.len
					can_open:  can_open
					can_close: can_close
				}
			}
			continue
		}
		nodes := p.parse_one()
		for n in nodes {
			result << n
		}
	}
	if delims.len > 0 {
		resolve_emphasis(mut result, mut delims)
		result = compact_empty_text_nodes(result)
	}
	return merge_text_nodes(result)
}

fn resolve_emphasis(mut nodes []&Node, mut delims []EmphDelim) {
	mut i := 0
	for i < delims.len {
		if !delims[i].active || !delims[i].can_close || delims[i].length == 0 {
			i++
			continue
		}
		mut opener := i - 1
		for opener >= 0 {
			if !delims[opener].active || !delims[opener].can_open || delims[opener].length == 0 {
				opener--
				continue
			}
			if delims[opener].ch != delims[i].ch {
				opener--
				continue
			}
			if (delims[i].can_open || delims[opener].can_close)
				&& (delims[opener].orig_len + delims[i].orig_len) % 3 == 0
				&& (delims[opener].orig_len % 3 != 0 || delims[i].orig_len % 3 != 0) {
				opener--
				continue
			}
			if delims[opener].node_idx + 1 >= delims[i].node_idx {
				opener--
				continue
			}
			break
		}
		if opener < 0 {
			i++
			continue
		}

		use_len := if delims[opener].length >= 2 && delims[i].length >= 2 { 2 } else { 1 }
		opener_idx := delims[opener].node_idx
		closer_idx := delims[i].node_idx
		if opener_idx < 0 || closer_idx < 0 || opener_idx >= nodes.len || closer_idx >= nodes.len
			|| opener_idx >= closer_idx {
			delims[i].active = false
			i++
			continue
		}
		if nodes[opener_idx].literal.len < use_len || nodes[closer_idx].literal.len < use_len {
			delims[i].active = false
			i++
			continue
		}

		nodes[opener_idx].literal = nodes[opener_idx].literal[..nodes[opener_idx].literal.len - use_len]
		nodes[closer_idx].literal = nodes[closer_idx].literal[use_len..]
		delims[opener].length -= use_len
		delims[i].length -= use_len

		mut emph := new_node(if use_len == 2 { .strong } else { .emphasis })
		for child in nodes[opener_idx + 1..closer_idx] {
			emph.append_child(child)
		}

		n_inner := closer_idx - opener_idx - 1
		if n_inner > 0 {
			nodes.delete_many(opener_idx + 1, n_inner)
			nodes.insert(opener_idx + 1, emph)
		}

		mut delta := n_inner - 1
		if delta < 0 {
			delta = 0
		}
		for j := 0; j < delims.len; j++ {
			if !delims[j].active {
				continue
			}
			if delims[j].node_idx > opener_idx && delims[j].node_idx < closer_idx {
				delims[j].active = false
				continue
			}
			if delta > 0 && delims[j].node_idx >= closer_idx {
				delims[j].node_idx -= delta
			}
		}

		if delims[opener].length == 0 {
			delims[opener].can_open = false
		}
		if delims[i].length == 0 {
			delims[i].can_close = false
		}
		i = opener + 1
	}
}

fn compact_empty_text_nodes(nodes []&Node) []&Node {
	mut out := []&Node{}
	for n in nodes {
		if n.kind == .text && n.literal.len == 0 {
			continue
		}
		out << n
	}
	return out
}

// parse_one parses one or more inline elements at the current position.
fn (mut p InlineParser) parse_one() []&Node {
	if p.pos >= p.src.len {
		return []
	}
	c := p.src[p.pos]
	match c {
		`\\` {
			return [p.parse_backslash()]
		}
		96 { // backtick
			if node := p.try_code_span() {
				return [node]
			}
			p.pos++
			return [text_node('`')]
		}
		`*`, `_` {
			p.pos++
			return [text_node(c.ascii_str())]
		}
		`~` {
			if p.opts.strikethrough {
				if node := p.try_strikethrough() {
					return [node]
				}
			}
			p.pos++
			return [text_node('~')]
		}
		`[` {
			if nodes := p.try_link_or_footnote() {
				return nodes
			}
			p.pos++
			return [text_node('[')]
		}
		`!` {
			if p.pos + 1 < p.src.len && p.src[p.pos + 1] == `[` {
				saved := p.pos
				p.pos += 2
				if nodes := p.try_image_after_bang() {
					return nodes
				}
				p.pos = saved
				p.pos++
				return [text_node('!')]
			}
			p.pos++
			return [text_node('!')]
		}
		`<` {
			if node := p.try_autolink_or_html() {
				return [node]
			}
			p.pos++
			return [text_node('<')]
		}
		`&` {
			if node := p.try_entity() {
				return [node]
			}
			p.pos++
			return [text_node('&')]
		}
		`\n` {
			return [p.parse_newline()]
		}
		else {
			r := rune_at_or_space(p.src, p.pos)
			step := utf8_char_len(p.src[p.pos])
			if p.opts.linkify {
				if node := p.try_linkify() {
					return [node]
				}
			}
			p.pos += step
			return [text_node(r.str())]
		}
	}
}

// text_node creates a text node with the given literal string.
fn text_node(s string) &Node {
	mut n := new_node(.text)
	n.literal = s
	return n
}

// merge_text_nodes merges consecutive text nodes into one.
fn merge_text_nodes(nodes []&Node) []&Node {
	if nodes.len <= 1 {
		return nodes
	}
	mut result := []&Node{}
	for node in nodes {
		if result.len > 0 && result[result.len - 1].kind == .text && node.kind == .text {
			result[result.len - 1].literal += node.literal
		} else {
			result << node
		}
	}
	return result
}

// can_open_emphasis reports whether a delimiter run can open emphasis.
fn can_open_emphasis(delim u8, before rune, after rune) bool {
	left_flanking := !is_unicode_space(after) && (!is_ascii_punct(after) || is_unicode_space(before)
		|| is_ascii_punct(before))
	right_flanking := !is_unicode_space(before)
		&& (!is_ascii_punct(before) || is_unicode_space(after)
		|| is_ascii_punct(after))
	if delim == `*` {
		return left_flanking
	}
	if delim == `_` {
		return left_flanking && (!right_flanking || is_ascii_punct(before))
	}
	return false
}

// can_close_emphasis reports whether a delimiter run can close emphasis.
fn can_close_emphasis(delim u8, before rune, after rune) bool {
	left_flanking := !is_unicode_space(after) && (!is_ascii_punct(after) || is_unicode_space(before)
		|| is_ascii_punct(before))
	right_flanking := !is_unicode_space(before)
		&& (!is_ascii_punct(before) || is_unicode_space(after)
		|| is_ascii_punct(after))
	if delim == `*` {
		return right_flanking
	}
	if delim == `_` {
		return right_flanking && (!left_flanking || is_ascii_punct(after))
	}
	return false
}

// parse_backslash handles backslash escapes and hard line breaks.
fn (mut p InlineParser) parse_backslash() &Node {
	p.pos++ // consume '\'
	if p.pos >= p.src.len {
		return text_node('\\')
	}
	ch := p.src[p.pos]
	if ch == `\n` {
		p.pos++
		return new_node(.hard_break)
	}
	if is_ascii_punct(ch) {
		p.pos++
		return text_node(ch.ascii_str())
	}
	return text_node('\\')
}

// try_code_span attempts to parse a backtick code span.
fn (mut p InlineParser) try_code_span() ?&Node {
	start := p.pos
	mut n := 0
	for p.pos < p.src.len && p.src[p.pos] == 96 {
		n++
		p.pos++
	}
	content_start := p.pos
	mut search := content_start
	for search < p.src.len {
		if p.src[search] == 96 {
			close_start := search
			mut close_n := 0
			for search < p.src.len && p.src[search] == 96 {
				close_n++
				search++
			}
			if close_n == n {
				code_raw := p.src[content_start..close_start]
				mut code := code_raw.replace('\n', ' ')
				if code.len >= 2 && code[0] == ` ` && code[code.len - 1] == ` `
					&& code.trim_space().len > 0 {
					code = code[1..code.len - 1]
				}
				mut node := new_node(.code_span)
				node.literal = code
				p.pos = search
				return node
			}
		} else {
			search++
		}
	}
	p.pos = start
	return none
}

// try_emphasis attempts to parse *em*, **strong**, _em_, __strong__.
fn (mut p InlineParser) try_emphasis(c u8) ?&Node {
	start := p.pos
	mut run := 0
	for p.pos < p.src.len && p.src[p.pos] == c {
		run++
		p.pos++
	}

	// Prevent splitting an intraword __ run into a synthetic single-underscore opener.
	if c == `_` && run == 1 && start > 1 && p.src[start - 1] == `_` {
		before2 := prev_rune_or_space(p.src, start - 1)
		after1 := rune_at_or_space(p.src, start + run)
		if is_wordish(before2) && is_wordish(after1) {
			p.pos = start
			return none
		}
	}

	before := prev_rune_or_space(p.src, start)
	after := rune_at_or_space(p.src, start + run)
	opener_can_open := can_open_emphasis(c, before, after)
	opener_can_close := can_close_emphasis(c, before, after)

	if !opener_can_open {
		p.pos = start
		return none
	}

	// Prefer em first for odd runs (e.g. ***foo*** -> <em><strong>foo</strong></em>).
	if run % 2 == 1 {
		p.pos = start + 1
		if node := p.match_close_delim(c, 1, run, opener_can_close) {
			return node
		}
		if run >= 2 {
			p.pos = start + 2
			if node := p.match_close_delim(c, 2, run, opener_can_close) {
				return node
			}
		}
	} else {
		if run >= 2 {
			p.pos = start + 2
			if node := p.match_close_delim(c, 2, run, opener_can_close) {
				return node
			}
		}
		p.pos = start + 1
		if node := p.match_close_delim(c, 1, run, opener_can_close) {
			return node
		}
	}

	p.pos = start
	return none
}

// is_wordish reports whether c behaves like a word character for emphasis
// boundary checks (includes non-ASCII bytes used in UTF-8 sequences).
@[inline]
fn is_wordish(c rune) bool {
	return !is_unicode_space(c) && !is_ascii_punct(c)
}

// match_close_delim parses content after the opening delimiter run and finds
// a matching closing delimiter of exactly `count` characters.
fn (mut p InlineParser) match_close_delim(c u8, count int, opener_run int, opener_can_close bool) ?&Node {
	content_start := p.pos
	mut content_nodes := []&Node{}

	for p.pos < p.src.len {
		loop_start_pos := p.pos
		ch := p.src[p.pos]
		// Check for closing delimiter.
		if ch == c {
			close_pos := p.pos
			mut close_run := 0
			for p.pos < p.src.len && p.src[p.pos] == c {
				close_run++
				p.pos++
			}
			if close_run >= count {
				// Verify right-flanking.
				before_close := prev_rune_or_space(p.src, close_pos)
				after_close := rune_at_or_space(p.src, p.pos)
				closer_can_close := can_close_emphasis(c, before_close, after_close)
				closer_can_open := can_open_emphasis(c, before_close, after_close)
				if closer_can_close {
					if count == 1 && opener_run == 1 && close_run > 1 && closer_can_open {
						p.pos = close_pos
					} else if count == 1 && opener_run > 1 && close_run > 1 && closer_can_open {
						// Keep extra delimiters inside the emphasis span so nested
						// strong parsing can consume them (e.g. foo***bar***baz).
						inner_end := close_pos + (close_run - count)
						if inner_end > content_start && inner_end <= p.src.len {
							inner_nodes := parse_inline(p.src[content_start..inner_end], p.opts,
								p.ref_map)
							mut node := new_node(.emphasis)
							for child in inner_nodes {
								node.append_child(child)
							}
							p.pos = close_pos + close_run
							return node
						}
					} else {
						if opener_can_close && closer_can_open && (opener_run + close_run) % 3 == 0
							&& (opener_run % 3 != 0 || close_run % 3 != 0) {
							p.pos = close_pos
						} else {
							if content_nodes.len == 0 {
								content_nodes << text_node(c.ascii_str())
								p.pos = close_pos + 1
								continue
							}
							// Rewind extra closing chars beyond `count`.
							p.pos = close_pos + count
							kind := if count == 2 { NodeKind.strong } else { NodeKind.emphasis }
							mut node := new_node(kind)
							for child in content_nodes {
								node.append_child(child)
							}
							return node
						}
					}
				}
			}
			p.pos = close_pos
			if count == 1 && opener_run > 1 && opener_can_close {
				content_nodes << text_node(c.ascii_str())
				p.pos++
				continue
			}
		}
		if ch == `\n` {
			// Newlines stop emphasis search.
			break
		}
		inner := p.parse_one()
		if p.pos <= loop_start_pos {
			// Safety net: force progress to avoid recursive delimiter stalls.
			fallback := rune_at_or_space(p.src, loop_start_pos)
			content_nodes << text_node(fallback.str())
			p.pos = loop_start_pos + utf8_char_len(p.src[loop_start_pos])
			continue
		}
		content_nodes << inner
	}

	// Not found; reset.
	p.pos = content_start
	return none
}

// try_strikethrough parses ~~text~~.
fn (mut p InlineParser) try_strikethrough() ?&Node {
	if p.pos + 1 >= p.src.len || p.src[p.pos + 1] != `~` {
		return none
	}
	p.pos += 2
	close := p.src.index_after_('~~', p.pos)
	if close < 0 {
		p.pos -= 2
		return none
	}
	inner := p.src[p.pos..close]
	inner_nodes := parse_inline(inner, p.opts, p.ref_map)
	mut node := new_node(.strikethrough)
	for child in inner_nodes {
		node.append_child(child)
	}
	p.pos = close + 2
	return node
}

// try_link_or_footnote handles [ and attempts to parse a link or footnote ref.
fn (mut p InlineParser) try_link_or_footnote() ?[]&Node {
	saved := p.pos
	p.pos++ // consume '['
	// Footnote reference [^label].
	if p.opts.footnotes && p.pos < p.src.len && p.src[p.pos] == `^` {
		fn_start := p.pos + 1
		fn_close := p.src.index_after_(']', fn_start)
		if fn_close > fn_start {
			label := p.src[fn_start..fn_close]
			mut fn_ref := new_node(.footnote_ref)
			fn_ref.fn_label = label
			p.pos = fn_close + 1
			return [fn_ref]
		}
	}
	text_start := p.pos
	close := find_bracket_close(p.src, p.pos)
	if close < 0 {
		p.pos = saved
		return none
	}
	link_text := p.src[text_start..close]
	p.pos = close + 1

	// Inline link (url).
	if p.pos < p.src.len && p.src[p.pos] == `(` {
		dest, title, end := parse_inline_link_dest_from(p.src, p.pos + 1)
		if end >= 0 {
			inner_nodes := parse_inline(link_text, p.opts, p.ref_map)
			mut node := new_node(.link)
			node.dest = unescape_string(dest)
			node.title = unescape_string(title)
			for child in inner_nodes {
				node.append_child(child)
			}
			p.pos = end + 1
			return [node]
		}
	}
	// Full reference [text][label].
	if p.pos < p.src.len && p.src[p.pos] == `[` {
		ref_start := p.pos + 1
		ref_close := p.src.index_after_(']', ref_start)
		if ref_close >= 0 {
			raw_label := p.src[ref_start..ref_close]
			label := normalize_label(if raw_label.len > 0 { raw_label } else { link_text })
			if label in p.ref_map {
				ref := p.ref_map[label]
				mut node := new_node(.link)
				node.dest = ref.dest
				node.title = ref.title
				node.label = label
				inner_nodes := parse_inline(link_text, p.opts, p.ref_map)
				for child in inner_nodes {
					node.append_child(child)
				}
				p.pos = ref_close + 1
				return [node]
			}
			if raw_label.len > 0 {
				// Do not downgrade explicit [text][label] to shortcut [text].
				p.pos = saved
				return none
			}
		}
	}
	// Shortcut reference [label].
	label := normalize_label(link_text)
	if label in p.ref_map {
		ref := p.ref_map[label]
		mut node := new_node(.link)
		node.dest = ref.dest
		node.title = ref.title
		node.label = label
		inner_nodes := parse_inline(link_text, p.opts, p.ref_map)
		for child in inner_nodes {
			node.append_child(child)
		}
		return [node]
	}
	p.pos = saved
	return none
}

// try_image_after_bang parses the [alt](url) part of an image after '![' was consumed.
fn (mut p InlineParser) try_image_after_bang() ?[]&Node {
	text_start := p.pos
	close := find_bracket_close(p.src, p.pos)
	if close < 0 {
		return none
	}
	alt_text := p.src[text_start..close]
	p.pos = close + 1

	if p.pos < p.src.len && p.src[p.pos] == `(` {
		dest, title, end := parse_inline_link_dest_from(p.src, p.pos + 1)
		if end >= 0 {
			mut node := new_node(.image)
			node.dest = unescape_string(dest)
			node.title = unescape_string(title)
			inner_nodes := parse_inline(alt_text, p.opts, p.ref_map)
			for child in inner_nodes {
				node.append_child(child)
			}
			p.pos = end + 1
			return [node]
		}
	}
	if p.pos < p.src.len && p.src[p.pos] == `[` {
		ref_start := p.pos + 1
		ref_close := p.src.index_after_(']', ref_start)
		if ref_close >= 0 {
			raw_label := p.src[ref_start..ref_close]
			label := normalize_label(if raw_label.len > 0 { raw_label } else { alt_text })
			if label in p.ref_map {
				ref := p.ref_map[label]
				mut node := new_node(.image)
				node.dest = ref.dest
				node.title = ref.title
				inner_nodes := parse_inline(alt_text, p.opts, p.ref_map)
				for child in inner_nodes {
					node.append_child(child)
				}
				p.pos = ref_close + 1
				return [node]
			}
		}
	}
	return none
}

// find_bracket_close finds the ] matching the [ at start, handling nesting and escapes.
fn find_bracket_close(s string, start int) int {
	mut depth := 1
	mut i := start
	for i < s.len {
		if s[i] == `\\` && i + 1 < s.len {
			i += 2
			continue
		}
		if s[i] == `[` {
			depth++
		} else if s[i] == `]` {
			depth--
			if depth == 0 {
				return i
			}
		}
		i++
	}
	return -1
}

// parse_inline_link_dest_from parses (url) or (url "title") starting at s[start]
// (start is after the opening paren). Returns (dest, title, end_paren_pos) or ("","", -1).
fn parse_inline_link_dest_from(s string, start int) (string, string, int) {
	i := skip_ws(s, start)
	if i >= s.len {
		return '', '', -1
	}
	dest, after_dest := parse_link_dest(s[i..])
	j := i + (s[i..].len - after_dest.len)
	k := skip_ws(s, j)
	if k < s.len && s[k] == `)` {
		return dest, '', k
	}
	title, after_title := parse_link_title(s[k..])
	l := k + (s[k..].len - after_title.len)
	m := skip_ws(s, l)
	if m < s.len && s[m] == `)` {
		return dest, title, m
	}
	return '', '', -1
}

// skip_ws returns the position in s after skipping whitespace from start.
fn skip_ws(s string, start int) int {
	mut i := start
	for i < s.len {
		ch := rune_at_or_space(s, i)
		if ch !in unicode_space {
			break
		}
		i += utf8_char_len(s[i])
	}
	return i
}

// try_autolink_or_html handles <...> for autolinks and raw HTML.
fn (mut p InlineParser) try_autolink_or_html() ?&Node {
	rest := p.src[p.pos..]
	auto_end := try_autolink(rest)
	if auto_end >= 0 {
		content := rest[1..auto_end]
		mut node := new_node(.autolink)
		node.literal = content
		if content.contains('@') && !content.contains('://') {
			node.dest = 'mailto:' + content
		} else {
			node.dest = content
		}
		p.pos += auto_end + 1
		return node
	}
	raw_end := try_raw_html_tag(rest)
	if raw_end >= 0 {
		mut node := new_node(.raw_html)
		node.literal = rest[..raw_end + 1]
		p.pos += raw_end + 1
		return node
	}
	return none
}

// try_autolink matches an <autolink> returning the position of '>' or -1.
fn try_autolink(s string) int {
	if s.len < 3 || s[0] != `<` {
		return -1
	}
	end := s.index_after_('>', 1)
	if end < 0 {
		return -1
	}
	inner := s[1..end]
	if inner.contains(' ') || inner.contains('<') {
		return -1
	}
	if inner.contains('://') {
		return end
	}
	if inner.contains('@') && !inner.starts_with('@') {
		return end
	}
	return -1
}

// try_raw_html_tag matches a raw HTML tag starting with '<' and returns the '>' position.
fn try_raw_html_tag(s string) int {
	if s.len < 3 || s[0] != `<` {
		return -1
	}
	if s.starts_with('<!--') {
		end := s.index_after_('-->', 4)
		if end >= 0 {
			return end + 2
		}
		return -1
	}
	if s.starts_with('<?') {
		end := s.index_after_('?>', 2)
		if end >= 0 {
			return end + 1
		}
		return -1
	}
	low := s.to_lower()
	if low.starts_with('<![cdata[') {
		end := s.index_after_(']]>', 9)
		if end >= 0 {
			return end + 2
		}
		return -1
	}
	end := s.index_after_('>', 1)
	if end < 0 {
		return -1
	}
	inner := s[1..end]
	if inner.len == 0 {
		return -1
	}
	if !is_alpha(inner[0]) && inner[0] != `/` && inner[0] != `!` {
		return -1
	}
	return end
}

// try_entity parses an HTML entity reference &name; or &#n; or &#xn'
fn (mut p InlineParser) try_entity() ?&Node {
	rest := p.src[p.pos..]
	semi := rest.index(';') or { return none }
	if semi > 32 || semi < 2 {
		return none
	}
	candidate := rest[..semi + 1]
	decoded := ehtml.unescape(candidate, all: true)
	if decoded == candidate {
		return none
	}
	p.pos += semi + 1
	return text_node(decoded)
}

// parse_newline handles a newline character.
fn (mut p InlineParser) parse_newline() &Node {
	// Hard break if preceded by two or more spaces.
	if p.pos >= 2 && p.src[p.pos - 1] == ` ` && p.src[p.pos - 2] == ` ` {
		p.pos++
		return new_node(.hard_break)
	}
	p.pos++
	return new_node(.soft_break)
}

// try_linkify matches a bare URL (linkify extension).
fn (mut p InlineParser) try_linkify() ?&Node {
	rest := p.src[p.pos..]
	for _, scheme in ['https://', 'http://', 'ftp://', 'mailto:'] {
		if rest.starts_with(scheme) {
			mut end := scheme.len
			for end < rest.len {
				ch := rest[end]
				if ch == ` ` || ch == `<` || ch == `>` || ch == `"` || ch == `\n` || ch == `\t` {
					break
				}
				end++
			}
			for end > scheme.len {
				last := rest[end - 1]
				if last == `.` || last == `,` || last == `;` || last == `!` || last == `?` {
					end--
				} else {
					break
				}
			}
			url := rest[..end]
			mut node := new_node(.autolink)
			node.literal = url
			node.dest = url
			p.pos += end
			return node
		}
	}
	return none
}